Verwendung von Perl 6 benutzerdefinierte Operatoren

Question

Ich studiere Chemie in der Universität und möchte versuchen, Lehrbuch Beispiele in Perl6 oder Perl, wie Ausgleich der chemischen Formel oder andere Prozesse!

Dann stieß ich auf das Problem ist perl6 benutzerdefinierte Betreiber. Ich fühle, dass ich meinen Code und mich selbst wiederholt habe, wenn ich das Feature nutze. Es ist schwer zu lesen und zu schreiben. Wie kann ich das vereinfachen?

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

Ich ersetzte Fail-Meldungen mit deklarierenden Typen am Eingang. Dadurch wird sich Perl 6 Gedanken darüber machen, ob Zahlen eingegeben werden, und entsprechende Fehlermeldungen ausgeben, falls dies nicht der Fall ist. Ich baute auch die Annahme auf, dass alle Längen und Massen positiv sind.

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