atomy 0.1.1

data/COPYING

@@ -0,0 +1,30 @@
+Copyright (c)2010, Alex Suraci
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Alex Suraci nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

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

data/bin/atomy

@@ -0,0 +1,134 @@
+#!/usr/bin/env rbx
+
+base = File.expand_path "../../lib/", __FILE__
+kernel = File.expand_path "../../kernel/", __FILE__
+
+require 'readline'
+require 'optparse'
+
+require base + "/macros"
+require base + "/method"
+require base + "/util"
+require base + "/namespace"
+require base + "/compiler/compiler"
+require base + "/compiler/stages"
+require base + "/parser"
+require base + "/patterns"
+require base + "/code_loader"
+
+def require_atomy(*as)
+  before = Atomy::Namespace.get
+  begin
+    Atomy::CodeLoader.load_file *as
+  ensure
+    Atomy::Namespace.set(before)
+  end
+end
+
+options = {}
+
+unless ARGV.empty? || ARGV[0][0] != ?-
+  OptionParser.new do |o|
+    o.banner = "usage: atomy [options]"
+
+    o.on("-B", "--print-bytecode", "print out compiled bytecode") do |v|
+      options[:debug] = v
+    end
+
+    o.on("-e", "--evaluate EXPR", "evaluate EXPR and print the result") do |v|
+      options[:evaluate] = v
+    end
+
+    o.on("-s", "--before-start EXPR", "evaluate EXPR beforehand") do |v|
+      options[:start] = v
+    end
+
+    o.on("-l", "--load FILE", "load FILENAME and start the REPL") do |v|
+      options[:load] = v
+    end
+
+    o.on("-d", "--documentation DIR", "generate documentation with output to DIR") do |v|
+      Atomy::CodeLoader.documentation = v
+    end
+
+    o.on_tail("-h", "--help", "show this message") do
+      puts o
+      exit
+    end
+  end.parse!
+end
+
+a = Time.now
+puts "loading kernel"
+require_atomy(kernel + "/boot.ay")
+puts Time.now - a
+
+Atomy::Namespace.ensure(:user)
+
+def run_atomy(options)
+  if str = options[:evaluate] || options[:start]
+    $0 = "(eval)"
+    res = Atomy::Compiler.evaluate(
+      str,
+      nil,
+      "(eval)",
+      1,
+      options[:debug]
+    )
+
+    if options[:evaluate]
+      res.send(Atomy.namespaced("atomy", "write").to_sym)
+      return
+    end
+  end
+
+  if file = options[:load] || ARGV[0]
+    $0 = file
+    require_atomy(file, ARGV[0] ? :run : :load, options[:debug])
+    return if ARGV[0]
+  end
+
+  if respond_to?(Atomy.namespaced("atomy", "repl").to_sym, true)
+    send(Atomy.namespaced("atomy", "repl").to_sym, File.expand_path("~/.atomy_history"))
+  else
+    $stderr.puts("main REPL startup failed! here's a basic one:")
+
+    history_file = File.expand_path("~/.atomy_history")
+
+    if File.exists?(history_file)
+      File.open(history_file, "r") do |f|
+        f.readlines.each do |l|
+          Readline::HISTORY << l.strip
+        end
+      end
+    end
+
+    begin
+      sane_history = []
+      while str = Readline.readline("> ")
+        next if str.empty?
+
+        sane_history << str
+
+        begin
+          res = Atomy::Compiler.evaluate str, TOPLEVEL_BINDING
+          if res.respond_to?(:pretty)
+            puts "=> #{res.pretty.render}"
+          else
+            puts "=> #{res.inspect}"
+          end
+        rescue StandardError => e
+          puts "ERROR!"
+          puts "#{e}:\n  #{e.message}"
+          puts e.backtrace
+        end
+      end
+    ensure
+      File.open(history_file, "a") do |f|
+        f.puts(*sane_history)
+      end
+    end
+  end
+end
+
+run_atomy(options)

data/kernel/block.ay

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,84 @@
+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/condition.ay

@@ -0,0 +1,277 @@
+namespace(atomy)
+
+title"Condition System"
+
+doc"
+  Rather than traditional exceptions, Atomy sports a condition/restart \
+  system modeled on Common Lisp's design. The native Ruby exception handling \
+  is available, but conditions and restarts are much more flexible.
+"
+
+-- registered handlers/restarts
+dynamic(handlers, [])
+dynamic(restarts, [])
+
+for-macro:
+  catcher(x) :=
+    Atomy::AST::Variable new(x line) $:
+      x match:
+        Atomy::AST::Variable ->
+          "restart:" + x name
+
+        Atomy::AST::Send ->
+          "restart:" + x method-name
+
+data(Object):
+  Restart(@name, @action)
+
+Restart invoke(*args) :=
+  throw(("restart:" + @name to-s) to-sym, @action [*args])
+
+symbols(signal, warning, error, restart)
+
+section("Conditions"):
+  doc"
+    Condition system hierarchy. You should subclass one of these to create \
+    your own conditions.
+  " for:
+    data(Object):
+      Condition:
+        Error(@backtrace):
+          SimpleError(@value)
+          ExceptionError(@exception)
+          NoRestartError(@name)
+          PortError(@port):
+            EndOfFile
+
+        Warning(@backtrace):
+          SimpleWarning(@value)
+
+  doc"
+    Get the name of a condition. By default, this will be the class name, \
+    but you may override this for your own behaviour.
+  " for:
+    Condition name := class name
+
+    ExceptionError name := @exception class name
+
+  doc"
+    A human-friendly message displayed for the condition. Override this.
+  " for:
+    Condition message := inspect
+
+    SimpleError message := @value to-s
+    ExceptionError message := @exception message
+    SimpleWarning message := @value to-s
+    NoRestartError message := "unknown restart " + @name show
+    EndOfFile message := "unexpected end-of-file for " + @port show
+
+
+section("Handling"):
+  doc"
+    Invoke the \hl{name} restart, passing \hl{args} along to its callback.
+
+    See \hl{with-restarts}.
+  " spec {
+    name is-a?(Symbol)
+    => any
+  } for {
+    restart(name, *args) := do:
+      ^restarts each [r]:
+        when(r name == name):
+          r invoke(*args)
+
+      error(NoRestartError new(name))
+  } examples:
+    { with-restarts(foo -> 42):
+        signal(#bar)
+    } bind: #bar -> restart(#foo)
+
+
+  doc"
+    Register handlers for various signals for the duration of \hl{x}'s \
+    execution.
+
+    The body of \hl{y} is similar to \hl{match}; \hl{\italic{pattern} -> \
+    \italic{body}}.
+
+    The result is the result of \hl{body}.
+  " spec {
+    y contents all? [x]: x match { `(~_ -> ~_) -> true, _ -> false }
+    => any
+  } for {
+    macro(body bind(&y)):
+      names [a]:
+        callback = `([~a]: ~a match: ~*(y contents))
+        `(let(handlers = ^handlers + [~callback]):
+            ~body rescue:
+              (e: StandardError) -> error(e))
+  } examples:
+    { signal(#a) } bind: #a -> "got A!" print
+    { signal(#b) } bind: #a -> "got A!" print
+    { { signal(#a) } bind: #a -> "inner" print } bind: #a -> "outer" print
+
+
+  doc"
+    Register restarts available for the duration of \hl{body}'s execution.
+
+    The \hl{restarts} should be in the form of \
+    \hl{\italic{name}(*\italic{args}) -> \italic{body}}.
+
+    The result is the result of \hl{body}.
+  " spec {
+    => any
+  } for {
+    macro(with-restarts(*restarts, &block)):
+      rs = restarts collect [`(~n -> ~e)]:
+        n match:
+          Atomy::AST::Variable ->
+            `(Restart new(#~n, { ~e }))
+
+          Atomy::AST::Send -> do:
+            name = Atomy::AST::Variable new(0, n method-name)
+            `(Restart new(#~name, [~*(n arguments)] { ~e }))
+
+      body =
+        restarts reduce(
+          `{ ~block rescue: (e: StandardError) -> error(e) }
+        ) [x, `(~name -> ~_)]:
+          `{ catch(#~catcher(name), &~x) }
+
+      `(let(restarts = [~*rs] + ^restarts, &~body))
+  } examples:
+    { with-restarts(x -> 1, y -> 2):
+        signal(#a)
+    } bind: #a -> restart(#x)
+
+    { with-restarts(x -> 1, y -> 2):
+        signal(#a)
+    } bind: #a -> restart(#y)
+
+    { with-restarts(x(a) -> a * 7):
+        signal(#a)
+    } bind: #a -> restart(#x, 6)
+
+
+section("Signalling"):
+  doc"
+    Signal a value through all bound handlers, nearest-first, stopping when \
+    a restart is invoked.
+  " spec {
+    => nil
+  } for {
+    signal(c) := do:
+      ^handlers reverse-each [callback]:
+        callback [c]
+
+      nil
+  } examples:
+    signal(#foo)
+    { signal(#foo) } bind: #foo -> "got foo" print
+
+
+  doc"
+    Like \hl{signal}, except that if no restart is invoked, the current \
+    \hl{^debugger} is started.
+
+    If the given value is not an \hl{Error}, it is wrapped in a \
+    \hl{SimpleError}. If the value is a Ruby \hl{Exception}, it is wrapped \
+    in an \hl{ExceptionError}.
+  " spec {
+    => _
+  } for {
+    error(x) := do:
+      e =
+        x match:
+          Exception ->
+            ExceptionError new(x) tap [err]:
+              err backtrace = x locations
+
+          Error ->
+            x tap [err]:
+              err backtrace = Rubinius::VM backtrace(0)
+
+          _ ->
+            SimpleError new(x) tap [err]:
+              err backtrace = Rubinius::VM backtrace(0)
+
+      signal(e)
+
+      with-output-to(^error-port):
+        ^debugger run(e)
+  } examples:
+    error("Oh no!")
+    { error("Oh no!") } bind: Error -> "INCOMING" print
+
+
+  doc"
+    Like \hl{signal}, except that if no restart is invoked, the warning is \
+    printed to \hl{^error-port}.
+
+    If the given value is not a \hl{Warning}, it is wrapped in a \
+    \hl{SimpleWarning}. Warning messages can be muffled by binding for \
+    \hl{Warning} and invoking the \hl{#muffle-warning} restart.
+  " spec {
+    => nil
+  } for {
+    warning(x) :=
+      with-restarts(muffle-warning -> nil):
+        w =
+          x match:
+            Warning ->
+              x tap [wrn]:
+                wrn backtrace = Rubinius::VM backtrace(0)
+
+            _ ->
+              SimpleWarning new(x) tap [wrn]:
+                wrn backtrace = Rubinius::VM backtrace(0)
+
+        signal(w)
+
+        with-output-to(^error-port):
+          (w name + ": " + w message) print
+
+        nil
+  } examples:
+    warning("Suspicious!")
+    { warning("Quiet, you!") } bind: Warning -> restart(#muffle-warning)
+
+
+section("Debuggers"):
+  doc"
+    The default debugger. This will show the condition name, its message, \
+    and let the user pick from the available restarts.
+  " for:
+    class(DefaultDebugger):
+      class(<< self):
+        define(show-error-banner(e)):
+          ("-" * 78) print
+          (e name + ": " + e message) each-line [l]:
+            ("*** " + l) display
+
+          "\n" display
+
+        define(show-options-for(e)):
+          when(^restarts empty?):
+            exit(1)
+
+          "\n" display
+          "restarts:" print
+          ^restarts each-with-index [r, i]:
+            ("  :" + i to-s + " -> " + r name to-s) print
+
+        define(run(e)):
+          show-error-banner(e)
+
+          show-options-for(e)
+
+          "!> " display
+          ^restarts [gets to-i] invoke
+
+  doc"
+    The current debugger. \hl{run} will be called with the condition as an \
+    argument.
+  " spec {
+    respond-to?(#run)
+  } for:
+    dynamic(debugger, DefaultDebugger)