atomy 0.1.1 → 0.6.3

data/README.md

@@ -1 +0,0 @@
-Atomo-like language on the Rubinius VM.

data/kernel/block.ay

@@ -1,30 +0,0 @@
-namespace(atomy)
-
-macro(x onto(&b)):
-  names [ctx]:
-    shadowed? = false
-
-    blk = b through-quotes [n]:
-      n match:
-        `@~(v: Atomy::AST::Variable) -> do:
-          shadowed? =! true
-          `(~ctx instance-variable-get(#~("@" + v name)))
-
-        'self -> do:
-          shadowed? =! true
-          ctx
-
-        Atomy::AST::Send ? @private ->
-          n dup tap [p]:
-            p receiver = 'self
-
-        Atomy::AST::BinarySend ? @private ->
-          n dup tap [p]:
-            p lhs = 'self
-
-        _ ->
-          n
-
-    if(shadowed?)
-      then: `(do: ~ctx = self, ~blk block call-on-instance(~x))
-      else: `(~b block call-on-instance(~x))

data/kernel/boot.ay

@@ -1,10 +0,0 @@
-macro(_LINE): line
-macro(_FILE): Atomy::AST::File new(line)
-
-macro(import(name)): `(require-atomy(~name, "load" to-sym))
-
-"operators define cosmetics data comparison dynamic control-flow namespaces
-patterns precision data-delta documentation particles hashes node block errors
-doc pretty format concurrency io condition therie repl" split each [k]:
-  puts("loading " + k)
-  import(File expand-path("../", _FILE) + "/" + k)

data/kernel/comparison.ay

@@ -1,61 +0,0 @@
-module(Atomy::AST):
-  class(And < Node):
-    children(#a, #b)
-    generate
-
-    bytecode(g) := do:
-      pos(g)
-      done = g new-label
-      no = g new-label
-
-      @a compile(g)
-      g dup
-      g gif(done)
-
-      g pop
-      @b compile(g)
-
-      done set!
-
-  class(Or < Node):
-    children(#a, #b)
-    generate
-
-    bytecode(g) := do:
-      pos(g)
-      done = g new-label
-
-      @a compile(g)
-      g dup
-      g git(done)
-
-      g pop
-      @b compile(g)
-
-      done set!
-
-  class(Negate < Node):
-    children(#expression)
-    generate
-
-    bytecode(g) := do:
-      pos(g)
-      done = g new-label
-      yes = g new-label
-
-      @expression compile(g)
-      g git(yes)
-
-      g push-true
-      g goto(done)
-
-      yes set!
-      g push-false
-
-      done set!
-
-macro(a && b): Atomy::AST::And new(line, a, b)
-macro(a || b): Atomy::AST::Or new(line, a, b)
-macro(!a): Atomy::AST::Negate new(line, a)
-macro(a != b): `!(~a == ~b)
-macro(a !~ b): `!(~a =~ ~b)

data/kernel/concurrency.ay

@@ -1,84 +0,0 @@
-namespace(atomy)
-
-require("actor")
-
-title"Concurrency"
-
-doc"
-  Get the current actor.
-" spec {
-  => Actor
-} for:
-  me := Actor current
-
-
-section("Sending & Receiving"):
-  doc"
-    Send message \code{v} to the actor.
-  " spec {
-    => Actor
-  } for {
-    Actor <- v := send(v)
-  } examples:
-    a = spawn: receive { 42 -> #ok } write
-    a <- 42
-
-  doc"
-    Receive a message sent to the current actor that matches any of the \
-    patterns listed in \hl{body}. Blocks until a matching message is \
-    received. Non-matching messages are consumed and ignored.
-  " spec {
-    body contents all? [x]: x match { `(~_ -> ~_) -> true, _ -> false }
-    => any
-  } for {
-    macro(receive(&body)):
-      names [e]:
-        bs = body contents collect [`(~pat -> ~exp)]:
-          `(~e when('~pat to-pattern) [~pat]: ~exp)
-
-        `(Actor receive [~e]: ~*bs)
-  } examples:
-    a = spawn: receive { 1 -> #got-1 } write
-    a <- 0
-    a <- 2
-    a <- 1
-
-  doc"
-    Similar to \code{receive}, but with a timeout and an action to \
-    perform if it times out.
-  " spec {
-    body contents all? [x]: x match { `(~_ -> ~_) -> true, _ -> false }
-    timeout match: `(~_ -> ~_) -> true, _ -> false
-    => any
-  } for {
-    macro(receive(&body) after(timeout)):
-      names [e]:
-        bs = body contents collect [`(~pat -> ~exp)]:
-          `(~e when('~pat to-pattern) [~pat]: ~exp)
-
-        bs << `(~e after(~(timeout lhs)): ~(timeout rhs))
-
-        `(Actor receive [~e]: ~*bs)
-  } examples:
-    receive { 1 -> #ok } after(1 -> #too-slow)
-
-
-section("Spawning"):
-  doc"
-    Spawn a new actor, performing \code{action}.
-  " spec {
-    => Actor
-  } for {
-    spawn(&action) := Actor send(#spawn, &action)
-  } examples:
-    spawn: (2 + 2) write
-
-  doc"
-    Spawn a new actor, performing \code{action}, linked to the current \
-    actor.
-  " spec {
-    => Actor
-  } for {
-    spawn-link(&action) := Actor send(#spawn-link, &action)
-  } examples:
-    spawn-link: (2 + 2) write

data/kernel/cosmetics.ay

@@ -1,3 +0,0 @@
-`($~(x: Atomy::AST::Block)) as-message(send) :=
-  send receiver to-send dup tap [s]:
-    s arguments += x contents

data/kernel/data-delta.ay

@@ -1,105 +0,0 @@
-namespace(atomy)
-
-macro(data(root, &children)):
-  cs = children contents map [e]:
-    e match:
-      Atomy::AST::Send -> do:
-        name =
-          Atomy::AST::Constant new(0, e method-name)
-
-        pat = name
-
-        tmps = names(e arguments size) collect [t]:
-          Atomy::AST::Unquote new(0, t)
-
-        e arguments zip(tmps) [[a, t]]:
-          pat =! `(~pat & with(~a, ~t))
-
-        cons = `(~(name)(~*tmps))
-
-        pat-def =
-          `(~(Atomy::AST::QuasiQuote new(0, cons)) pattern :=
-              ~(Atomy::AST::QuasiQuote new(0, pat)) pattern)
-
-        define =
-          `(export:
-              class(~name < ~root):
-                attr-accessor $:
-                  ~*(e arguments collect [a]:
-                      `#~(a receiver))
-
-                initialize(~*(e arguments)) := nil
-
-              ~pat-def)
-
-        if(e block)
-          then:
-            `(do:
-                ~define
-
-                data(~name):
-                  ~*(e block contents))
-          else:
-            define
-
-      Atomy::AST::Constant ->
-        `(class(~e < ~root):)
-
-      Atomy::AST::ScopedConstant ->
-        `(class(~e < ~root):)
-
-      Atomy::AST::ToplevelConstant ->
-        `(class(~e < ~root):)
-
-      _ -> raise("unknown module name: " + e to-s)
-
-  `(do: class(~root):;, ~*cs, nil)
-
-
-macro(macro-quoter(n, &x)):
-  `(evaluate-when(compile, load):
-      Atomy::Macro::Environment quoter(#~n, &~x))
-
-macro-quoter(w) [c]: c split
-
-macro-quoter(r) [c, fs]:
-  flags = 0
-
-  when(fs include?("m")):
-    flags |= Regexp::MULTILINE
-
-  when(fs include?("i")):
-    flags |= Regexp::IGNORECASE
-
-  when(fs include?("x")):
-    flags |= Regexp::EXTENDED
-
-  when(fs include?("u")):
-    flags |= Regexp::KCODE_UTF8
-
-  `(Regexp new(~c, ~flags))
-
-macro-quoter(raw) [c]: c
-
-macro(_undefined):
-  Atomy::AST::Undefined new(line)
-
-macro($(x: Primitive ? @value is-a?(::Integer) && @value > 0)):
-  Atomy::AST::NthRef new(line, x value)
-
-export:
-  module(Atomy::AST):
-    class(Undefined < Node):
-      generate
-
-      bytecode(g) := do:
-        pos(g)
-        g push-undef
-
-      pattern := Atomy::Patterns::Any new
-
-    class(NthRef < Rubinius::AST::NthRef):
-      include(NodeLike)
-      extend(SentientNode)
-      attributes(#which)
-      generate

data/kernel/documentation.ay

@@ -1,135 +0,0 @@
-namespace(atomy/documentation)
-
-in-namespace(atomy):
-  symbols(pretty, show)
-
-for-macro:
-  escape(x) :=
-    x gsub(r"[\{\}\\]", raw"\\\0")
-
-  indent(x, n = 1) :=
-    x split("\n") collect [x] { (" " * n * 2) + x } join("\n")
-
-  str-expr(e) :=
-    escape $:
-      e match:
-        String -> e
-        Atomy::AST::String -> e value
-        _ -> e show
-
-  to-thumb(x: Atomy::AST::Macro) :=
-    indent(escape(x pattern show))
-  to-thumb(`(~meth := ~_)) :=
-    indent(escape(meth show))
-  to-thumb(d: `(data(Object))) :=
-    let(atomy/pretty/multiline? = true):
-      indent(escape(d block body show))
-  to-thumb(d: `(data(~r))) :=
-    let(atomy/pretty/multiline? = true):
-      indent(escape(`(~r ~(d block)) show))
-  to-thumb(`(dynamic(~n, ~r))) :=
-    indent(`^~n show + "\n> " + r show)
-  to-thumb(`(class(~n))) :=
-    indent(n show + "\n> Class")
-  to-thumb(`(module(~n))) :=
-    indent(n show + "\n> Module")
-  to-thumb(x) := str-expr(x)
-
-  to-spec([]) := ""
-  to-spec(b) :=
-    "\n" + indent $:
-      b collect [e] {
-        e match:
-          `(=> ~x) ->
-            "> " + str-expr(x)
-
-          _ ->
-            "| " + str-expr(e)
-      } join("\n")
-
-  to-examples(b) :=
-    b collect [e] {
-      "    " + str-expr(e)
-    } join("\n")
-
-export-to(atomy):
-  -- TODO: shoudln't need to export this; not being resolved in #section
-  macro(for-docs(&body)):
-    `(when(^documentation):
-        ^documentation << ~(body block-body))
-
-  macro-quoter(doc) [c]:
-    for-docs:
-      c + "\n\n"
-
-    c
-
-  macro-quoter(title) [c]:
-    for-docs:
-      "\\title{" + escape(c) + "}\n\n"
-
-    c
-
-  macro(section(name, &body)):
-    `(do:
-        evaluate-when(compile):
-          for-docs: "\\section{" + ~name + "}{\n\\style{Atomy}\n\n"
-
-        res = ~(body caller)
-
-        evaluate-when(compile):
-          for-docs: "}"
-
-        res)
-
-  macro(docs spec(&s) for(&code)):
-    for-docs:
-      [ "\\define{"
-        "\n" + to-thumb(code contents first)
-        to-spec(s contents)
-        "\n}{"
-        docs contents
-        "}\n\n"
-      ] join
-
-    code block-body
-
-  macro(docs for(&code)):
-    for-docs:
-      [ "\\define{"
-        "\n" + to-thumb(code contents first)
-        "\n}{"
-        docs contents
-        "}\n\n"
-      ] join
-
-    code block-body
-
-  macro(docs spec(&s) for(&code) examples(&es)):
-    for-docs:
-      [ "\\define{"
-        "\n" + to-thumb(code contents first)
-        to-spec(s contents)
-        "\n}{"
-        docs contents
-        "\n  \\examples{"
-        "\n" + to-examples(es contents)
-        "\n  }"
-        "\n}\n\n"
-      ] join
-
-    code block-body
-
-  macro(docs for(&code) examples(&es)):
-    for-docs:
-      [ "\\define{"
-        "\n" + to-thumb(code contents first)
-        "\n}{"
-        docs contents
-        "\n  \\examples{"
-        "\n" + to-examples(es contents)
-        "\n  }"
-        "\n}\n\n"
-      ] join
-
-    code block-body

data/kernel/errors.ay

@@ -1,6 +0,0 @@
-MethodFail message :=
-  ("method '" + @method-name to-s + "' did not understand " +
-  "its arguments (non-exhaustive patterns)")
-
-PatternMismatch message :=
-  "irrefutable pattern failed for " + @pattern to-s