atomy 0.1.1 → 0.6.3

data/kernel/hashes.ay

@@ -1,39 +0,0 @@
-namespace(atomy)
-
-macro(#(l: List)):
-  keys = []
-  values = []
-
-  l elements each [p]:
-    p match:
-      `(~k -> ~v) -> do:
-        keys << k
-        values << v
-
-      Atomy::AST::Send -> do:
-        while(p respond-to?(#block) && p block):
-          keys << Atomy::AST::Particle new(p line, p method-name)
-          values << p block contents first
-          p =! p receiver
-
-  Atomy::AST::Hash new(line, keys, values)
-
-export:
-  class(Atomy::AST::Hash < Atomy::AST::Node):
-    children([#keys], [#values])
-    generate
-
-    bytecode(g) := do:
-      pos(g)
-
-      g push-cpath-top
-      g find-const(#Hash)
-      g push-int(@keys size)
-      g send(#new-from-literal, 1)
-
-      @keys each-with-index [n, i]:
-        g dup
-        n compile(g)
-        @values [i] compile(g)
-        g send("[]=" to-sym, 2)
-        g pop

data/kernel/namespaces.ay

@@ -1,63 +0,0 @@
-macro(namespace(n: Variable)):
-  `(evaluate-when(compile, run, load):
-      Atomy::Namespace ensure(#~n))
-
-macro(let-when(when, *bindings, &b)):
-  tmps = names(bindings size)
-  save = []
-  set = []
-  restore = []
-
-  bindings zip(tmps) [[`(~n = ~v), tmp]]:
-    save << `(Atomy::STATE [#~tmp] = ^~n)
-    set << set-dynvar(n, v)
-    restore << set-dynvar(n, `(Atomy::STATE delete(#~tmp)))
-
-  names [res]:
-    `(let(~*bindings):
-        evaluate-when(~when):
-          ~*save
-          ~*set
-
-        ~res = ~(b body)
-
-        evaluate-when(~when):
-          ~restore
-
-        ~res)
-
-macro(in-namespace(n, &b)):
-  `(do:
-      evaluate-when(load):
-        Atomy::Namespace create(#~n)
-
-      let-when(compile, namespace = Atomy::Namespace ensure(#~n)):
-        ~(b body))
-
-macro(no-namespace(&b)):
-  `(let-when(compile, namespace = nil):
-      ~(b body))
-
-macro(export(&b)):
-  `(let-when(compile, define-in = "_"):
-      ~(b body))
-
-macro(export-to(n, &b)):
-  `(let-when(compile, define-in = ~(n name)):
-      ~(b body))
-
-macro(use(*ns)):
-  current = Atomy::Namespace get
-  where = current && current name
-
-  `(evaluate-when(compile, run, load):
-      ~*(ns collect [n]:
-          `(Atomy::Namespace get(~where) use(#~n))))
-
-macro(symbols(*ns)):
-  current = Atomy::Namespace get
-  where = current && current name
-
-  `(evaluate-when(compile, run, load):
-      ~*(ns collect [n]:
-          `(Atomy::Namespace register(#~n, ~where))))

data/kernel/node.ay

@@ -1,48 +0,0 @@
-namespace(atomy)
-
-export:
-  module(Atomy::AST):
-    '_ pattern :=
-      Atomy::Patterns::Any new
-
-    `(~h . ~t) pattern :=
-      Atomy::Patterns::HeadTail new(h to-pattern, t to-pattern)
-
-    `(~p = ~d) pattern :=
-      Atomy::Patterns::Default new(p to-pattern, d)
-
-    `(? ~t) pattern :=
-      Atomy::Patterns::Predicate new(Atomy::Patterns::Any new, t)
-
-    `(~p ? ~t) pattern :=
-      Atomy::Patterns::Predicate new(p to-pattern, t)
-
-    `(~a & ~b) pattern :=
-      Atomy::Patterns::And new(a to-pattern, b to-pattern)
-
-    `(~a | ~b) pattern :=
-      Atomy::Patterns::Or new(a to-pattern, b to-pattern)
-
-    `(with(~attr, ~p)) pattern :=
-      Atomy::Patterns::With new(attr, p to-pattern)
-
-    `@@~n pattern :=
-      Atomy::Patterns::NamedClass new(n name)
-
-    `$~n pattern :=
-      Atomy::Patterns::NamedGlobal new(n name)
-
-    `@~n pattern :=
-      Atomy::Patterns::NamedInstance new(n name)
-
-    `%~x pattern :=
-      Atomy::Patterns::RuntimeClass new(x, nil)
-
-    `&~x pattern :=
-      Atomy::Patterns::BlockPass new(x to-pattern)
-
-    `*~x pattern :=
-      Atomy::Patterns::Splat new(x to-pattern)
-
-    `(Particle [~*as]) pattern :=
-      Atomy::Patterns::List new(as collect [a]: a to-pattern)

data/kernel/operators.ay

@@ -1,28 +0,0 @@
--- defining & assigning
-operator right 0 = := **= *= <<= >>= &&=
-                 &= ||= |= += -= /= ^= %=
-
--- association
-operator right 1 <- ->
-
--- predicate pattern
-operator right 2 ?
-
--- ranges
---operator 1 .. ...
-
--- comparison
-operator 5 <=> < <= >= >
-operator 4 == !=
-operator 3 &&
-operator 2 ||
-
--- math
-operator right 12 **
-operator 10 % * /
-operator 9 + -
-
--- bitwise and shifting
-operator 8 << >>
-operator 6 ^ |
-operator 7 &

data/kernel/precision.ay

@@ -1,148 +0,0 @@
-namespace(atomy)
-
-export:
-  module(Atomy::Patterns):
-    -- pattern precision hierarchy, from least precise to most
-    [ [ Any, BlockPass, Splat, Attribute,
-        NamedClass, NamedGlobal, NamedInstance
-      ]
-
-      [Constant, SingletonClass, RuntimeClass]
-
-      [HeadTail]
-
-      [List, QuasiQuote, Particle]
-
-      [Match, Quote]
-    ] each-with-index [ps, i]:
-        ps each [a]:
-          a send(#define-method, #precision):
-            i
-
-    Pattern precision := 0
-
-    Named precision := @pattern precision
-
-    Predicate precision :=
-      @pattern precision + 1
-
-    (a: Pattern) <=> (b: Pattern) :=
-      a precision <=> b precision
-
-    (a: BlockPass) <=> (b: BlockPass) :=
-      a pattern <=> b pattern
-
-    -- if one constant is a subclass of another, it is
-    -- higher precision.
-    (a: Constant) <=> (b: Constant) :=
-      condition:
-        (a ancestors nil? || b ancestors nil?) ->
-          0
-
-        (a ancestors first == b ancestors first) ->
-          0
-
-        b ancestors include?(a ancestors first) ->
-          -1
-
-        a ancestors include?(b ancestors first) ->
-          1
-
-        otherwise ->
-          0
-
-    (a: HeadTail) <=> (b: HeadTail) :=
-      Atomy::Patterns
-        compare([a head, a tail], [b head, b tail])
-
-    (a: List) <=> (b: List) :=
-      Atomy::Patterns
-        compare(a patterns, b patterns)
-
-    (a: Splat) <=> (b: Splat) :=
-      a pattern <=> b pattern
-
-    (a: Default) <=> (b: Default) :=
-      a pattern <=> b pattern
-    (d: Default) <=> (p: Pattern) := d pattern <=> p
-    (p: Pattern) <=> (d: Default) := p <=> d pattern
-
-    (a: Named) <=> (b: Named) :=
-      a pattern <=> b pattern
-    (n: Named) <=> (p: Pattern) :=
-      n pattern <=> p
-    (p: Pattern) <=> (n: Named) :=
-      p <=> n pattern
-
-
-    -- equivalence ignores named patterns
-    (a: Named) =~ (b: Named) :=
-      a pattern =~ b pattern
-    Named =~ (p: Pattern) := pattern =~ p
-    Pattern =~ (n: Named) := (=~ n pattern)
-
-    Any =~ Any := true
-
-    (a: BlockPass) =~ (b: BlockPass) :=
-      a pattern =~ b pattern
-
-    (a: Constant) =~ (b: Constant) :=
-      a constant =~ b constant
-
-    (a: Default) =~ (b: Default) :=
-      a pattern =~ b pattern
-    Default =~ (p: Pattern) := pattern =~ p
-    Pattern =~ (n: Default) := (=~ n pattern)
-
-    (a: HeadTail) =~ (b: HeadTail) :=
-      a head =~ b head && a tail =~ b tail
-
-    (a: List) =~ (b: List) :=
-      a patterns zip(b patterns) all? [[a, b]]:
-        when(a nil? || b nil?):
-          return(false)
-
-        a =~ b
-
-    (a: Match) =~ (b: Match) :=
-      a value == b value
-
-    (a: SingletonClass) =~ (b: SingletonClass) :=
-      a body == b body
-
-    NamedClass =~ NamedClass := true
-
-    NamedGlobal =~ NamedGlobal := true
-
-    NamedInstance =~ NamedInstance := true
-
-    (a: Particle) =~ (b: Particle) :=
-      a value == b value
-
-    (a: QuasiQuote) =~ (b: QuasiQuote) :=
-      -- TODO: go through quotes.
-      a expression == b expression
-
-    (a: Quote) =~ (b: Quote) :=
-      a expression == b expression
-
-    (a: Splat) =~ (b: Splat) :=
-      a pattern =~ b pattern
-
-    (a: Attribute) =~ (b: Attribute) :=
-      a receiver == b receiver &&
-        a name == b name &&
-        a arguments == b arguments
-
-    Pattern =~ Pattern := false
-
-
-    -- helper for comparing aggregate patterns like lists
-    { self } compare(xs, ys) := do:
-      total = 0
-
-      xs zip(ys) [[x, y]]:
-        unless(x nil? || y nil?):
-          total += x <=> y
-
-      total <=> 0

data/kernel/therie.ay

@@ -1,204 +0,0 @@
-namespace(therie)
-
-title"Testing with Therie"
-
-doc"
-Therie is a small and simple behavioral-style testing suite that comes with \
-Atomy. To use it, you should use the \hl{therie} namespace, which provides \
-the following methods.
-
-\atomy{
-  use(therie)
-}
-"
-
-dynamic(nesting-level, 0)
-
-doc"
-  A trivial container of \hl{passed} and \hl{failed} counts, with accessors \
-  for both.
-" for:
-  class(Stats):
-    attr-accessor(#passed, #failed)
-
-    export:
-      initialize := do:
-        @passed = 0
-        @failed = 0
-
-      inspect := f"Stats(@passed = %d, @failed = %d)" [@passed, @failed]
-
-  dynamic(stats, nil)
-
-
-section("Structure"):
-  doc"\evaluate{use(therie)}"
-
-  doc"
-    Run \hl{tests} and keep track of how many passed and how many failed, \
-    printing the stats at the end and returning them.
-  " spec {
-    => Stats
-  } for {
-    theorize(&tests) :=
-      let(stats = Stats new):
-        tests call
-        "\n" display
-
-        ^stats onto:
-          f"total of %d tests (%s passed, %s failed)" [
-            failed + passed
-            passed to-s colored(#green)
-            if(failed == 0)
-              then: "0"
-              else: failed to-s colored(#red)
-          ] display
-
-          "\n" display
-
-        ^stats
-  } examples:
-    theorize:
-      describe("foo"):
-        it("does x"): true should-be(false)
-        it("does x"): true should-be(true)
-
-
-  doc"
-    Logically group together a set of behavior.
-
-    Prints out \hl{what}, with each test in \hl{body} indented afterward.
-  " for {
-    describe(what, &body) := do:
-      f"- %s" [what] indented print
-
-      let(nesting-level = ^nesting-level + 1):
-        body call
-
-      nil
-  } examples:
-    describe("foo"):
-      it("does x"): true should-be(false)
-      it("does x"): true should-be(true)
-
-
-  doc"
-    Describe some behavior that the tests in \hl{body} will demonstrate.
-  " for {
-    it(description, &tests) := do:
-      { tests call
-        f"✓ %s" [description] indented colored(#green) print
-      } rescue {
-        e -> do:
-          when(^stats):
-            ^stats failed += 1
-
-          f"✗ %s" [description] indented colored(#red) print
-          f"  ` %s: %s" [
-            e class name
-            e message
-          ] indented colored(#yellow) print
-
-          e backtrace first(5) each [l]:
-            f"    %s" [l colored(#cyan)] indented print
-      } else:
-        when(^stats):
-          ^stats passed += 1
-
-      nil
-  } examples:
-    it("adds correctly"): (2 + 2) should-be(4)
-    it("adds correctly"): (1 + 2) should-be(4)
-
-
-section("Tests"):
-  doc"\evaluate{use(therie)}"
-
-  doc"
-    Test that \hl{predicate} is satisified by \hl{o} by evaluating it with \
-    \hl{o} as \hl{self}.
-  " for {
-    o should(&check) :=
-      unless(o onto(&check)):
-        raise(f"assertion failed for %v" [o])
-  } examples:
-    (2 + 2) should: even?
-    (2 + 2) should: odd?
-
-
-  doc"
-    Test for \hl{x == y}.
-  " for {
-    x should-be(y) :=
-      unless(x == y):
-        raise(f"expected %v, got %v" [y, x])
-  } examples:
-    (2 + 2) should-be(4)
-    (1 + 2) should-be(4)
-
-
-  doc"
-    Test that executing \hl{x} will raise an exception of class \hl{y}.
-  " spec {
-    x respond-to?(#call)
-    y is-a?(Class)
-  } for {
-    x should-raise(y) :=
-      x rescue {
-        e ->
-          unless(e kind-of?(y)):
-            raise(f"expected exception %s, got: %s" [y, e])
-      } else:
-          raise("#should-raise - no exception raised")
-  } examples:
-    { abc } should-raise(NoMethodError)
-    { #ok } should-raise(NoMethodError)
-
-
-  doc"
-    Test that executing \hl{x} will signal an error of class \hl{y}.
-  " spec {
-    x respond-to?(#call)
-    y is-a?(Class)
-  } for {
-    x should-error(y) :=
-      { with-restarts(errored -> nil):
-          x call
-          raise("#should-error - no error signaled")
-      } bind {
-        (e: ExceptionError) ->
-          raise(e exception)
-
-        (e: Error) -> do:
-          when(e kind-of?(y)):
-            restart(#errored)
-
-          raise(f"expected error %s, got: %s" [y, e message])
-      }
-  } examples:
-    { error(#foo) } should-error(SimpleError)
-    { #ok } should-error(SimpleError)
-
-
--- helpers
-String indented := " " * (^nesting-level * 2) + self
-
-String colored(color) := do:
-  -- only makes sense to colorize if we're outputting to a terminal
-  unless(^output-port tty?):
-    return(self)
-
-  codes =
-    [ #black
-      #red
-      #green
-      #yellow
-      #blue
-      #magenta
-      #cyan
-      #white
-    ] zip((0 .. 7) to-a)
-
-  hash = Hash [codes]
-
-  "\e[9" + hash [color] to-s + "m" + self + "\e[0m"