atomy 0.1.1 → 0.6.3

data/kernel/quotes.ay

@@ -0,0 +1,29 @@
+use(require("core"))
+use(require("define"))
+use(require("control-flow"))
+
+macro(macro-quoter(~n) [~*as]: ~*body):
+  strpat = Unquote new('(string-literal & StringLiteral))
+  argpat = Unquote new('*args)
+
+  `({
+      quoter = [~*as]: ~*body
+
+      macro(~n ~strpat):
+        quoter call(string-literal value, [], evaluate(string-literal))
+
+      macro(~n (~strpat)(~argpat)):
+        quoter call(string-literal value, args collect &.text, evaluate(string-literal))
+    } call)
+
+
+macro-quoter(w) [_, _, v]:
+  `[~*(v split collect [s]: Atomy Grammar AST StringLiteral new(s))]
+
+macro-quoter(s) [_, _, v]:
+  `[~*(v split collect [s]:
+         if(s =~ Regexp new("[\p{Ll}_]", Regexp KCODE_UTF8))
+           then: `.~(Atomy Grammar AST Word new(s tr("-", "_") to-sym))
+           else: `.~(Atomy Grammar AST Word new(s to-sym)))]
+
+macro-quoter(raw) [r]: Atomy Code StringLiteral new(r, true)

data/kernel/range.ay

@@ -0,0 +1,4 @@
+use(require("core"))
+
+macro(~a .. ~b): `(//Range new(~a, ~b))
+macro(~a ... ~b): `(//Range new(~a, ~b, true))

data/kernel/regexp.ay

@@ -0,0 +1,23 @@
+use(require("core"))
+use(require("define"))
+use(require("quotes"))
+use(require("control-flow"))
+use(require("mutation"))
+interpolate = require("interpolation")
+
+macro-quoter(r) [r, fs]:
+  flags = 0
+
+  when(fs include?(.m)):
+    flags |= Regexp MULTILINE
+
+  when(fs include?(.i)):
+    flags |= Regexp IGNORECASE
+
+  when(fs include?(.x)):
+    flags |= Regexp EXTENDED
+
+  -- UTF8 by default
+  flags |= Regexp KCODE_UTF8
+
+  `(//Regexp new(~(interpolate interpolated(r)), ~(Atomy Grammar AST Number new(flags))))

data/kernel/repl.ay

@@ -1,140 +1,114 @@
-namespace(atomy)
+use(require("atomy"))
 
-title"The REPL"
+use(require("doc"))
+condition = use(require("condition"))
+pretty = require("pretty")
 
 require("readline")
 
-doc"
-  The basics of a REPL - reading, evaluating, and printing in a loop. More \
-  flexibility is provided by various signals. See \hl{repl} for a fancier \
-  REPL, which builds upon this, and \hl{ReplDebugger}.
-
-  When showing the prompt, \hl{#prompt} is signaled with a \hl{#use-prompt} \
-  restart available. Invoke this restart and pass along a string to \
-  override the prompt, which defaults to \code{>>}.
+fn(try(source, module, debug = false)):
+  with-restarts(
+      retry: try(source, module)
+      abort: .ok):
+    condition signal(.evaluated(module evaluate(Atomy Parser parse-string(source), module compile-context))) rescue:
+      (e & (StandardError | ScriptError)): error(e)
 
-  Input preceded by a colon (\code{:}) and followed by an alphanumeric \
-  character is assumed to be a \italic{special command}. These are not \
-  evaluated, and are signaled as \hl{#special(\italic{text})}.
+fn(basic-repl(module, debug = false)):
+  loop:
+    prompt =
+      with-restarts(use-prompt(p): p):
+        condition signal(.prompt)
+        ">> "
 
-  When the user sends \code{EOF} (Ctrl+D) or an interrupt (Ctrl+C), \
-  \hl{#quit} is signaled.
-
-  When the user enters code, \hl{#input(\italic{text})} is signaled. The code\
-  is evaluated with two restarts registered: \code{#retry} for re-attempting \
-  evaluation, and \code{#abort}, for canceling the evaluation. After the code\
-  is evaluated, \hl{#evaluated(\italic{result})} is signaled.
+    input =
+      Readline readline(prompt, true) rescue:
+        Interrupt: condition signal(.quit), ""
 
-  \hl{#loop} is signaled before the loop starts over again (i.e., after the \
-  input is handled).
-" spec {
-  bnd is-a?(Binding)
-} for:
-  basic-repl(bnd = TOPLEVEL_BINDING) :=
-    loop:
-      prompt =
-        with-restarts(use-prompt(p) -> p):
-          signal(#prompt)
-          ">> "
+    input match:
+      nil: condition signal(.quit)
 
-      in =
-        { Readline readline(prompt)
-        } rescue:
-          Interrupt -> do { signal(#quit), "" }
+      "": .ok
 
-      in match:
-        nil -> signal(#quit)
+      (String & { =~ r"^:[[:alnum:]]" }):
+        condition signal(.special(input[1 .. -1]))
 
-        "" -> #ok
+      source:
+        condition signal(.input(source))
+        try(source, module, debug)
 
-        String ? (=~ r"^:[[:alnum:]]") ->
-          signal(#special(in [1 .. -1]))
+    condition signal(.loop)
 
-        source -> do:
-          signal(#input(source))
 
-          try = {
-            with-restarts(retry -> try [], abort -> #ok):
-              res = Atomy::Compiler evaluate(source, bnd)
-              signal(#evaluated(res))
-          }
+condition DefaultDebugger data(ReplDebugger(@error))
 
-          try []
+ReplDebugger open:
+  attr-accessor(.module)
 
-      signal(#loop)
+def(ReplDebugger run):
+  condition signal(.debug(self))
 
+  show-banner
 
-doc"
-  An interactive debugger REPL for handling errors. This will list the \
-  results along with a number, allow the user to continue evaluating code, \
-  and once they enter a \italic{special command} in the form of \
-  \code{:\italic{number}}, the specified restart will be invoked.
-" for:
-  class(ReplDebugger):
-    class(<< self):
-      show-backtrace(e) := do:
-        Rubinius::Backtrace backtrace(e backtrace) _/show print
-        debug(e)
+  with-restarts(backtrace: show-backtrace):
+    debug
 
-      run(e) := do:
-        DefaultDebugger show-error-banner(e)
+def(ReplDebugger(e) show-banner):
+  puts("-" * 78)
+  i"#{e name}: #{e message}" split("\n") each [l]:
+    puts(i"*** #{l}")
 
-        with-restarts(backtrace -> show-backtrace(e)):
-          debug(e)
+def(ReplDebugger debug):
+  show-restarts
 
-      debug(e) := do:
-        DefaultDebugger show-options-for(e)
+  basic-repl(@module) bind:
+    .prompt: condition restart(.use-prompt, "[!]> ")
 
-        { basic-repl } bind:
-          #prompt -> restart(#use-prompt, "[!]> ")
+    .special(n & { =~ r"\d+" }):
+      ^(condition Restarts) [n to-i] invoke
 
-          #special(n ? (=~ r"\d+")) ->
-            ^restarts [n to-i] invoke
+    .quit: exit(1)
 
-          #quit -> exit(1)
 
-dynamic(debugger, ReplDebugger)
+def(repl(history = nil, module = nil, debug = false)):
+  unless(module):
+    &module = Atomy Module new
+    module file = ."(repl)"
+    module use(require("atomy"))
 
-doc"
-  A more feature-filled REPL, providing persistent history and setting \
-  \hl{^debugger} to \hl{ReplDebugger}.
+  when(history && File exists?(history)):
+    File open(history, "r") [f]:
+      f readlines each [l]:
+        Readline HISTORY << l strip
 
-  History will be managed and appended to a file specified by \hl{history} \
-  upon termination.
-" spec {
-  history is-a?(String)
-  bnd is-a?(Binding)
-} for:
-  repl(history = nil, bnd = TOPLEVEL_BINDING) := do:
-    when(history && File exists?(history)):
-      File open(history, "r") [f]:
-        f readlines each [l]:
-          Readline::HISTORY << l strip
-
-    SANE_HISTORY = []
+  sane-history = []
 
-    { let(debugger = ReplDebugger):
-        frame = 0
+  with(condition Debugger = ReplDebugger) {
+    frame = 0
 
-        { let(atomy/pretty/colored? = true):
-            basic-repl(bnd)
-        } bind:
-          #prompt ->
-            restart(#use-prompt, "[" + frame to-s + "]> ")
-
-          #loop ->
-            (frame += 1)
+    basic-repl(module, debug) bind:
+      .prompt:
+        restart(.use-prompt, i"[#{frame}]> ")
 
-          #quit -> exit(0)
-
-          #input(str) -> (SANE_HISTORY << str)
+      .loop:
+        frame += 1
 
-          #special("h") ->
-            ":h\thelp" print
+      .quit:
+        exit(0)
 
-          #evaluated(r) ->
-            (" => " + r show) print
-    } ensuring:
-      when(history):
-        File open(history, "a") [f]:
-          f puts(*SANE_HISTORY)
+      .input(str):
+        sane-history << str
+
+      .special(String & { == "h" }):
+        puts(":h\thelp")
+
+      .debug(dbg):
+        dbg module = module
+
+      .evaluated(r):
+        with(pretty Multiline = true,
+             pretty Colored = true):
+          puts((text(" =>") <+> pretty doc(r)) render(56))
+  } ensuring:
+    when(history):
+      File open(history, "a") [f]:
+        f puts(*sane-history)

data/kernel/stack-local.ay

@@ -0,0 +1,21 @@
+use(require("core"))
+use(require("define"))
+use(require("control-flow"))
+use(require("patterns"))
+
+class(Local):
+  class(Setter):
+    def(initialize(@local, @code)) {}
+
+    def(bytecode(gen, mod)):
+      mod compile(gen, @code)
+      gen set-stack-local(@local allocate(gen))
+
+  def(bytecode(gen, mod)):
+    gen push-stack-local(allocate(gen))
+
+  def(allocate(gen)):
+    @stack-local = (@stack-local || gen new-stack-local)
+
+  def(set(code)):
+    Setter new(self, code)

data/lib/atomy.rb

@@ -0,0 +1,37 @@
+require "atomy/method"
+
+class Object
+  attr_reader :atomy_methods
+
+  def atomy_methods
+    @atomy_methods ||= {}
+  end
+end
+
+module Atomy
+  module_function
+
+  def register_branch(target, name, branch)
+    methods = target.atomy_methods
+    method = methods[name] ||= Atomy::Method.new(name)
+    branch = method.add_branch(branch)
+    [method, branch]
+  end
+
+  def define_branch(binding, name, branch)
+    target =
+      if branch.receiver
+        branch.receiver.target
+      else
+        binding.constant_scope.for_method_definition
+      end
+
+    method, branch = register_branch(target, name, branch)
+
+    if branch.name
+      Rubinius.add_method(branch.name, branch.as_method, target, :public)
+    end
+
+    Rubinius.add_method(name, method.build, target, :public)
+  end
+end

data/lib/atomy/bootstrap.rb

@@ -0,0 +1,256 @@
+require "atomy/grammar"
+require "atomy/module"
+require "atomy/code/assign"
+require "atomy/code/block"
+require "atomy/code/class_variable"
+require "atomy/code/constant"
+require "atomy/code/define_method"
+require "atomy/code/define_function"
+require "atomy/code/false"
+require "atomy/code/instance_variable"
+require "atomy/code/integer"
+require "atomy/code/list"
+require "atomy/code/nil"
+require "atomy/code/pattern"
+require "atomy/code/pattern/and"
+require "atomy/code/pattern/quasi_quote"
+require "atomy/code/pattern/splat"
+require "atomy/code/pattern/wildcard"
+require "atomy/code/quasi_quote"
+require "atomy/code/quote"
+require "atomy/code/self"
+require "atomy/code/send"
+require "atomy/code/sequence"
+require "atomy/code/string_literal"
+require "atomy/code/symbol"
+require "atomy/code/true"
+require "atomy/code/undefined"
+require "atomy/code/variable"
+require "atomy/node/meta"
+require "atomy/node/equality"
+require "atomy/pattern/and"
+require "atomy/pattern/equality"
+require "atomy/pattern/kind_of"
+require "atomy/pattern/quasi_quote"
+require "atomy/pattern/splat"
+require "atomy/pattern/wildcard"
+require "atomy/message_structure"
+
+module Atomy
+  Bootstrap = Atomy::Module.new do
+    def expand(node)
+      node.accept(NodeExpander.new(self)) || super
+    end
+
+    def pattern(node)
+      node.accept(PatternExpander.new(self)) || super
+    end
+
+    def macro_definer(pattern, body)
+      BootstrapHelper::WithGrammar.new(Atomy::Code::DefineMethod.new(:expand, body, nil, [pattern]))
+    end
+
+    def pattern_definer(pattern, body)
+      BootstrapHelper::WithGrammar.new(Atomy::Code::DefineMethod.new(:pattern, body, nil, [pattern]))
+    end
+
+    def make_send(recv, msg, args = [])
+      Atomy::Code::Send.new(recv, msg.text, args)
+    end
+
+    def make_constant(name, parent = nil)
+      Atomy::Code::Constant.new(name, parent)
+    end
+
+    def make_sequence(nodes)
+      Atomy::Grammar::AST::Sequence.new(nodes)
+    end
+
+    def make_quasiquote(node)
+      Atomy::Grammar::AST::QuasiQuote.new(node)
+    end
+
+    private
+
+    class NodeExpander
+      def initialize(mod)
+        @module = mod
+      end
+
+      def visit(node)
+        structure = Atomy::MessageStructure.new(node)
+
+        block = nil
+        if block_arg = structure.block
+          block = Atomy::Code::Block.new(
+            Atomy::Code::Sequence.new(block_arg.body),
+            block_arg.arguments,
+            nil,
+            false,
+          )
+        end
+
+        Code::Send.new(
+          structure.receiver,
+          structure.name,
+          structure.arguments,
+          structure.splat_argument,
+          structure.proc_argument,
+          block,
+        )
+      rescue Atomy::MessageStructure::UnknownMessageStructure
+      end
+
+      def visit_stringliteral(node)
+        Code::StringLiteral.new(node.value)
+      end
+
+      def visit_sequence(node)
+        Code::Sequence.new(node.nodes)
+      end
+
+      def visit_list(node)
+        Code::List.new(node.nodes)
+      end
+
+      def visit_word(node)
+        case node.text
+        when :self
+          Code::Self.new
+        else
+          Code::Variable.new(node.text)
+        end
+      end
+
+      def visit_constant(node)
+        Code::Constant.new(node.text)
+      end
+
+      def visit_number(node)
+        Code::Integer.new(node.value)
+      end
+
+      def visit_quote(node)
+        Code::Quote.new(node.node)
+      end
+
+      def visit_quasiquote(node)
+        Code::QuasiQuote.new(node.node)
+      end
+    end
+
+    class PatternExpander
+      def initialize(mod)
+        @module = mod
+      end
+
+      def visit(_)
+        nil
+      end
+
+      def visit_word(node)
+        name = nil
+        if node.text != :_
+          name = node.text
+        end
+
+        Code::Pattern::Wildcard.new(name)
+      end
+
+      def visit_number(node)
+        Code::Pattern.new(
+          Code::Send.new(
+            Code::Constant.new(
+              :Equality,
+              Code::Constant.new(
+                :Pattern,
+                Code::Constant.new(:Atomy))),
+            :new,
+            [node]))
+      end
+
+      def visit_quote(node)
+        Code::Pattern.new(
+          Code::Send.new(
+            Code::Constant.new(
+              :Equality,
+              Code::Constant.new(
+                :Pattern,
+                Code::Constant.new(:Atomy))),
+            :new,
+            [node]))
+      end
+
+      def visit_quasiquote(node)
+        Code::Pattern::QuasiQuote.new(node, @module)
+      end
+
+      def visit_prefix(node)
+        if node.operator == :*
+          Code::Pattern::Splat.new(@module.pattern(node.node))
+        end
+      end
+
+      def visit_infix(node)
+        if node.operator == :&
+          Code::Pattern::And.new(@module.pattern(node.left), @module.pattern(node.right))
+        end
+      end
+
+      def visit_constant(node)
+        Code::Pattern.new(
+          Code::Send.new(
+            Code::Constant.new(
+              :KindOf,
+              Code::Constant.new(
+                :Pattern,
+                Code::Constant.new(:Atomy))),
+            :new,
+            [node]))
+      end
+    end
+  end
+
+  # helpers that shouldn't be exposed through using Bootstrap
+  module BootstrapHelper
+    extend self
+
+    class WithGrammar
+      def initialize(body)
+        @body = body
+      end
+
+      def bytecode(gen, mod)
+        gen.create_block(build_block(gen.state.scope, mod))
+        gen.send(:call, 0)
+      end
+
+      private
+
+      def build_block(scope, mod)
+        Atomy::Compiler.generate(mod.file) do |blk|
+          # close over the outer scope
+          blk.state.scope.parent = scope
+
+          # capture original module
+          blk.push_scope
+          blk.send(:module, 0)
+
+          # add Atomy::Grammar::AST to the constant scope
+          blk.push_cpath_top
+          blk.find_const(:Atomy)
+          blk.find_const(:Grammar)
+          blk.find_const(:AST)
+          blk.add_scope
+
+          # restore original module for definition targets
+          blk.push_scope
+          blk.swap
+          blk.send(:current_module=, 1)
+
+          mod.compile(blk, @body)
+        end
+      end
+    end
+  end
+end