perl6/core.pm

   1 unit module core;
   2 use types;
   3 use printer;
   4 use reader;
   5
   6 sub equal ($a, $b) {
   7   if $a ~~ MalSequence && $b ~~ MalSequence {
   8     return $FALSE if $a.elems != $b.elems;
   9     for |$a Z |$b -> ($a_el, $b_el) {
  10       return $FALSE if equal($a_el, $b_el) ~~ $FALSE;
  11     }
  12     return $TRUE;
  13   }
  14   elsif $a ~~ MalHashMap && $b ~~ MalHashMap {
  15     return $FALSE if $a.elems != $b.elems;
  16     for $a.pairs {
  17       return $FALSE if !$b{.key} || equal(.value, $b{.key}) ~~ $FALSE;
  18     }
  19     return $TRUE;
  20   }
  21   else {
  22     return $a.^name eq $b.^name && $a.val ~~ $b.val ?? $TRUE !! $FALSE;
  23   }
  24 }
  25
  26 our %ns = (
  27   '+'         => MalCode({ MalNumber($^a.val + $^b.val) }),
  28   '-'         => MalCode({ MalNumber($^a.val - $^b.val) }),
  29   '*'         => MalCode({ MalNumber($^a.val * $^b.val) }),
  30   '/'         => MalCode({ MalNumber(($^a.val / $^b.val).Int) }),
  31   '<'         => MalCode({ $^a.val < $^b.val ?? $TRUE !! $FALSE }),
  32   '<='        => MalCode({ $^a.val <= $^b.val ?? $TRUE !! $FALSE }),
  33   '>'         => MalCode({ $^a.val > $^b.val ?? $TRUE !! $FALSE }),
  34   '>='        => MalCode({ $^a.val >= $^b.val ?? $TRUE !! $FALSE }),
  35   '='         => MalCode({ equal($^a, $^b) }),
  36   prn         => MalCode({ say @_.map({ pr_str($_, True) }).join(' '); $NIL }),
  37   println     => MalCode({ say @_.map({ pr_str($_) }).join(' '); $NIL }),
  38   pr-str      => MalCode({ MalString(@_.map({ pr_str($_, True) }).join(' ') ) }),
  39   str         => MalCode({ MalString(@_.map({ pr_str($_) }).join) }),
  40   read-string => MalCode({ read_str($^a.val) }),
  41   slurp       => MalCode({ MalString($^a.val.IO.slurp) }),
  42   list        => MalCode({ MalList(@_) }),
  43   'list?'     => MalCode({ $^a ~~ MalList ?? $TRUE !! $FALSE }),
  44   'empty?'    => MalCode({ $^a.elems ?? $FALSE !! $TRUE }),
  45   count       => MalCode({ MalNumber($^a ~~ $NIL ?? 0 !! $^a.elems) }),
  46   atom        => MalCode({ MalAtom($^a) }),
  47   'atom?'     => MalCode({ $^a ~~ MalAtom ?? $TRUE !! $FALSE }),
  48   deref       => MalCode({ $^a.val }),
  49   'reset!'    => MalCode({ $^a.val = $^b }),
  50   'swap!'     => MalCode(-> $atom, $func, *@args { $atom.val = $func.apply($atom.val, |@args) }),
  51   cons        => MalCode({ MalList([$^a, |$^b.val]) }),
  52   concat      => MalCode({ MalList([@_.map({|$_.val})]) }),
  53   nth         => MalCode({ $^a[$^b.val] // die X::MalOutOfRange.new }),
  54   first       => MalCode({ $^a[0] // $NIL }),
  55   rest        => MalCode({ MalList([$^a[1..*]]) }),
  56   throw       => MalCode({ die X::MalThrow.new(value => $^a) }),
  57   apply       => MalCode(-> $func, *@args { $func.apply(|@args[0..*-2], |@args[*-1].val) }),
  58   map         => MalCode(-> $func, $list { MalList([$list.map({ $func.apply($_) })]) }),
  59   'nil?'      => MalCode({ $^a ~~ MalNil ?? $TRUE !! $FALSE }),
  60   'true?'     => MalCode({ $^a ~~ MalTrue ?? $TRUE !! $FALSE }),
  61   'false?'    => MalCode({ $^a ~~ MalFalse ?? $TRUE !! $FALSE }),
  62   'symbol?'   => MalCode({ $^a ~~ MalSymbol ?? $TRUE !! $FALSE }),
  63   symbol      => MalCode({ MalSymbol($^a.val) }),
  64   keyword     => MalCode({ $^a.val ~~ /^\x29E/ ?? $^a !! MalString("\x29E" ~ $^a.val) }),
  65   'keyword?'  => MalCode({ $^a.val ~~ /^\x29E/ ?? $TRUE !! $FALSE }),
  66   vector      => MalCode({ MalVector(@_) }),
  67   'vector?'   => MalCode({ $^a ~~ MalVector ?? $TRUE !! $FALSE }),
  68   hash-map    => MalCode({ MalHashMap(@_.map({ $^a.val => $^b }).Hash) }),
  69   'map?'      => MalCode({ $^a ~~ MalHashMap ?? $TRUE !! $FALSE }),
  70   assoc       => MalCode(-> $map, *@kv { MalHashMap(Hash.new(|$map.kv, |@kv.map({$^a.val, $^b}))) }),
  71   dissoc      => MalCode(-> $map, *@keys { my %h = $map.val.clone; %h{@keys.map(*.val)}:delete; MalHashMap(%h) }),
  72   get         => MalCode({ $^a.val{$^b.val} // $NIL }),
  73   'contains?' => MalCode({ $^a.val{$^b.val}:exists ?? $TRUE !! $FALSE }),
  74   keys        => MalCode({ MalList([$^a.keys.map({ MalString($_) })]) }),
  75   vals        => MalCode({ MalList([$^a.values]) }),
  76   'sequential?' => MalCode({ $^a ~~ MalList|MalVector ?? $TRUE !! $FALSE }),
  77   readline    => MalCode({ with prompt($^a.val) { MalString($_) } else { $NIL } }),
  78   time-ms     => MalCode({ MalNumber((now * 1000).Int) }),
  79   conj        => MalCode(-> $seq, *@args { $seq.conj(@args) }),
  80   'string?'   => MalCode({ $^a ~~ MalString && $^a.val !~~ /^\x29E/ ?? $TRUE !! $FALSE }),
  81   seq         => MalCode({ $^a.seq }),
  82   with-meta   => MalCode({ return $NIL if !$^a.can('meta'); my $x = $^a.clone; $x.meta = $^b; $x }),
  83   meta        => MalCode({ $^a.?meta // $NIL }),
  84 );