Perl 6 özel işleçlerini kullanma

Question

Üniversitede kimya eğitimi alıyorum ve kimyasal formül veya diğer işlemleri dengeleme gibi Perl6 veya Perl'deki ders kitabı örneklerini yazmaya çalışıyorum!

Ardından, sorunun perl6 özel işleci ile ilgili olduğunu gördüm. Özelliği kullandığımda kodumu ve kendimi tekrarladığımı hissediyorum. Okumak ve yazmak zor. Bunu nasıl basitleştirebilirim?

#!/usr/bin/env perl6 
use v6; 
#basic SI(International System of Units) type 


role MetricPrefix { 
    method baseOn (Str $base , Numeric $input) { 
     given $base { 
      when 'pico' { return $input * 10**-12 } 
      when 'namo' { return $input * 10**-9 } 
      when 'micro' { return $input * 10**-6} 
      when 'milli' { return $input * 10**-3 } 
      when 'centi' { return $input * 10**-2 } 
      when 'hecto' { return $input * 10**2 } 
      when 'kilo' { return $input * 10**3 } 
      when 'mega' { return $input * 10**6 } 
      when 'giga' { return $input * 10**9 } 
      when 'tera' { return $input * 10**12 } 
      default { fail "you must input a metric prefix which allow pico to tera" } 
     } 
    } 
} 



class Mass does MetricPrefix { 
    #basic Mass is g is different form si statda 
    has $.g; 

    submethod BUILD (:$!g ) { 
    } 

} 

class Length does MetricPrefix { 
    has $.Length ; 

    submethod BUILD (:$!Length ) { 
    } 
} 



multi postfix:<(kg)>($input) { 
    return Mass.new(g => Mass.baseOn("kilo",$input)) or fail "you Must input a number"; 
} 

multi postfix:<(g)>($input) { 
    return Mass.new(g => $input) or fail "you Must input a number"; 
} 

multi infix:<+>(Mass $inputOne , Mass $inputTwo) is assoc<right> { 
    return Mass.new(g => $inputOne.g + $inputTwo.g) or fail "error in there "; 
} 

multi infix:<->(Mass $inputOne , Mass $inputTwo) is assoc<right> { 
    return Mass.new(g => $inputOne.g - $inputTwo.g) or fail "error in there "; 
} 

multi infix:<*>(Mass $inputOne , Mass $inputTwo) is assoc<right> is tighter(&infix:<+>) is tighter(&infix:<->) is tighter(&infix:</>) { 
    return Mass.new(g => $inputOne.g * $inputTwo.g) or fail "error in there "; 
} 

multi infix:</>(Mass $inputOne , Mass $inputTwo) is assoc<right> is tighter(&infix:<+>) is tighter(&infix:<->) { 
    return Mass.new(g => $inputOne.g/$inputTwo.g) or fail "error in there "; 
} 





#the meterLeng 
multi postfix:<(km)>($input) { 
    return Length.new(Length => Length.baseOn("kilo",$input)) or fail "you Must input a number"; 
} 

multi postfix:<(m)>($input) { 
    return Length.new(Length => $input) or fail "you Must input a number"; 
} 

multi infix:<+>(Length $inputOne , Length $inputTwo) is assoc<right> { 
    return Length.new(Length => $inputOne.Length + $inputTwo.Length) or fail "error in there "; 
} 

multi infix:<->(Length $inputOne , Length $inputTwo) is assoc<right> { 
    return Length.new(Length => $inputOne.Length - $inputTwo.Length) or fail "error in there "; 
} 

multi infix:<*>(Length $inputOne , Length $inputTwo) is assoc<right> is tighter(&infix:<+>) is tighter(&infix:<->) is tighter(&infix:</>) { 
    return Length.new(Length => $inputOne.Length * $inputTwo.Length) or fail "error in there "; 
} 

multi infix:</>(Length $inputOne , Length $inputTwo) is assoc<right> is tighter(&infix:<+>) is tighter(&infix:<->) { 
    return Length.new(Length => $inputOne.Length/$inputTwo.Length) or fail "error in there "; 
} 


#just a test 
say 10(kg) + 1(g); 
say 10(m) + 1(m); 

Answer 1

Hata mesajlarını girişte bildiren tiplerle değiştiriyorum. Bu sayede, Perl 6 sayıların girilip girilmediği konusunda endişelenir ve eğer uygun değilse, uygun hata mesajları verir. Ayrıca tüm uzunlukların ve kitlelerin olumlu olduğu varsayımıyla inşa ettim.

#!/usr/bin/env perl6 
use v6; 
#basic SI(International System of Units) type 

role MetricPrefix { 
    method baseOn (Str $base , Numeric $input) { 
     given $base { 
      when 'pico' { return $input * 10**-12 } 
      when 'namo' { return $input * 10**-9 } 
      when 'micro' { return $input * 10**-6 } 
      when 'milli' { return $input * 10**-3 } 
      when 'centi' { return $input * 10**-2 } 
      when 'hecto' { return $input * 10**2 } 
      when 'kilo' { return $input * 10**3 } 
      when 'mega' { return $input * 10**6 } 
      when 'giga' { return $input * 10**9 } 
      when 'tera' { return $input * 10**12 } 
      default { fail "you must input a metric prefix within the range of pico to tera" } 
     } 
    } 
} 

class Mass does MetricPrefix { 
    #basic Mass is g is different form si statda 
    has $.g where * > 0; 
} 

class Length does MetricPrefix { 
    has $.Length where * > 0; 
} 

# Mass 
multi postfix:<(kg)>($input where * > 0) { 
    return Mass.new(g => Mass.baseOn("kilo",$input)); 
} 

multi postfix:<(g)>($input where * > 0) { 
    return Mass.new(g => $input); 
} 

multi infix:<+>(Mass $inputOne , Mass $inputTwo) is assoc<right> { 
    return Mass.new(g => $inputOne.g + $inputTwo.g); 
} 

multi infix:<->(Mass $inputOne , Mass $inputTwo) is assoc<right> { 
    return Mass.new(g => $inputOne.g - $inputTwo.g); 
} 

multi infix:<*>(Mass $inputOne , Mass $inputTwo) is assoc<right> is tighter(&infix:<+>) is tighter(&infix:<->) is tighter(&infix:</>) { 
    return Mass.new(g => $inputOne.g * $inputTwo.g); 
} 

multi infix:</>(Mass $inputOne , Mass $inputTwo) is assoc<right> is tighter(&infix:<+>) is tighter(&infix:<->) { 
    return Mass.new(g => $inputOne.g/$inputTwo.g); 
} 

#Length 
multi postfix:<(km)>($input where * > 0) { 
    return Length.new(Length => Length.baseOn("kilo",$input)); 
} 

multi postfix:<(m)>($input where * > 0) { 
    return Length.new(Length => $input); 
} 

multi infix:<+>(Length $inputOne , Length $inputTwo) is assoc<right> { 
    return Length.new(Length => $inputOne.Length + $inputTwo.Length); 
} 

multi infix:<->(Length $inputOne , Length $inputTwo) is assoc<right> { 
    return Length.new(Length => $inputOne.Length - $inputTwo.Length); 
} 

multi infix:<*>(Length $inputOne , Length $inputTwo) is assoc<right> is tighter(&infix:<+>) is tighter(&infix:<->) is tighter(&infix:</>) { 
    return Length.new(Length => $inputOne.Length * $inputTwo.Length); 
} 

multi infix:</>(Length $inputOne , Length $inputTwo) is assoc<right> is tighter(&infix:<+>) is tighter(&infix:<->) { 
    return Length.new(Length => $inputOne.Length/$inputTwo.Length); 
} 


#just a test 
say 10(kg) + 1(g); 
say 10(m) + 1(m);