Korzystanie z Perla 6 operatorów niestandardowych

Question

Studiuję chemię na uniwersytecie i chcę wypróbować przykłady podręczników w Perl6 lub Perl, jak na przykład równoważenie formuły chemicznej lub innych procesów!

Następnie napotkałem problem na niestandardowym operatorze perl6. Czuję, że powtarzam swój kod i siebie, kiedy używam tej funkcji. Trudno jest czytać i pisać. Jak mogę to uprościć?

#!/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

Wymieniłem komunikaty o błędach z zadeklarowanymi typami na wejściu. To pozwoli Perlowi 6 martwić się o to, czy wprowadzane są cyfry i dostarczać odpowiednie komunikaty o błędach, jeśli tak nie jest. Zbudowałem również przy założeniu, że wszystkie długości i masy są pozytywne.

#!/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);