rouge-lang 0.0.1

data/lib/rouge.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+if RUBY_VERSION < "1.9"
+  STDERR.puts "Rouge will probably not run on anything less than Ruby 1.9."
+end
+
+module Rouge; end
+
+start = Time.now
+Rouge.define_singleton_method :start, lambda {start}
+
+class << Rouge
+  require 'rouge/version'
+  require 'rouge/wrappers'
+  require 'rouge/symbol'
+  require 'rouge/seq'
+  require 'rouge/reader'
+  require 'rouge/printer'
+  require 'rouge/context'
+  require 'rouge/repl'
+
+  def print(form, out)
+    Rouge::Printer.print form, out
+  end
+
+  def [](ns)
+    Rouge::Namespace[ns]
+  end
+
+  def boot!
+    return if @booted
+    @booted = true
+
+    core = Rouge[:"rouge.core"]
+    core.refer Rouge[:"rouge.builtin"]
+
+    user = Rouge[:user]
+    user.refer Rouge[:"rouge.builtin"]
+    user.refer Rouge[:"rouge.core"]
+    user.refer Rouge[:ruby]
+
+    Rouge::Context.new(user).readeval(
+        File.read(Rouge.relative_to_lib('boot.rg')))
+  end
+
+  def repl(argv)
+    boot!
+    Rouge::REPL.repl(argv)
+  end
+
+  def relative_to_lib name
+    File.join(File.dirname(File.absolute_path(__FILE__)), name)
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/lib/rouge/atom.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+class Rouge::Atom
+  def initialize(value)
+    @value = value
+  end
+
+  def ==(var)
+    var.object_id == object_id
+  end
+
+  def deref
+    @value
+  end
+
+  def swap! f, *args
+    @value = f.call(@value, *args)
+  end
+
+  def reset! v
+    @value = v
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/lib/rouge/builtins.rb

@@ -0,0 +1,596 @@
+# encoding: utf-8
+
+module Rouge::Builtins
+  require 'rouge/compiler'
+
+  SYMBOLS = {
+    :nil => nil,
+    :true => true,
+    :false => false,
+  }
+end
+
+class << Rouge::Builtins
+  def let(context, bindings, *body)
+    context = Rouge::Context.new context
+    bindings.to_a.each_slice(2) do |k, v|
+      destructure(context, k, v).each do |sk, sv|
+        context.set_here sk.name, sv
+      end
+    end
+    self.do(context, *body)
+  end
+
+  def _compile_let(ns, lexicals, bindings, *body)
+    lexicals = lexicals.dup
+
+    bindings = bindings.to_a.each_slice(2).flat_map do |k, v|
+      v = Rouge::Compiler.compile(ns, lexicals, v)
+      _compile_let_find_lexicals(lexicals, k)
+      [k, v]
+    end
+
+    [Rouge::Symbol[:let],
+     bindings,
+     *Rouge::Compiler.compile(ns, lexicals, body)]
+  end
+
+  def _compile_let_find_lexicals(lexicals, form)
+    if form.is_a?(Rouge::Symbol)
+      lexicals << form.name
+    elsif form.is_a?(Hash) and form.keys == [:keys]
+      form.values[0].each do |n|
+        lexicals << n.name
+      end
+    elsif form.is_a?(Hash)
+      form.keys.each do |p|
+        _compile_let_find_lexicals(lexicals, p)
+      end
+    elsif form.is_a?(Array)
+      form = form.dup
+      while form.length > 0
+        p = form.shift
+
+        next if p == :as
+        next if p == Rouge::Symbol[:&]
+        next if p == Rouge::Symbol[:|]
+
+        _compile_let_find_lexicals(lexicals, p)
+      end
+    else
+      raise ArgumentError, "unknown LHS of LET expression: #{form.inspect}"
+    end
+  end
+
+  def context(context)
+    context
+  end
+
+  def quote(context, form)
+    form
+  end
+
+  def _compile_quote(ns, lexicals, form)
+    [Rouge::Symbol[:quote], form]
+  end
+
+  def fn(context, *args)
+    if args[0].is_a? Rouge::Symbol
+      name = args.shift.to_sym
+    end
+
+    argv, *body = args
+
+    if argv[-2] == Rouge::Symbol[:&]
+      rest = argv[-1]
+      argv = argv[0...-2]
+    elsif argv[-4] == Rouge::Symbol[:&] and argv[-2] == Rouge::Symbol[:|]
+      rest = argv[-3]
+      argv = argv[0...-4] + argv[-2..-1]
+    else
+      rest = nil
+    end
+
+    if argv[-2] == Rouge::Symbol[:|]
+      block = argv[-1]
+      argv = argv[0...-2]
+    else
+      block = nil
+    end
+
+    fn = lambda {|*inner_args, &blockgiven|
+      if !rest ? (inner_args.length != argv.length) :
+                 (inner_args.length < argv.length)
+        begin
+          raise ArgumentError,
+              "wrong number of arguments " \
+              "(#{inner_args.length} for #{argv.length})"
+        rescue ArgumentError => e
+          # orig = e.backtrace.pop
+          # e.backtrace.unshift "(rouge):?:FN call (#{name || "<anonymous>"})"
+          # e.backtrace.unshift orig
+          raise e
+        end
+      end
+
+      inner_context = Rouge::Context.new(context)
+
+      argv.each.with_index do |arg, i|
+        inner_context.set_here(arg.name, inner_args[i])
+      end
+
+      if rest
+        inner_context.set_here(rest.name,
+                         Rouge::Seq::Cons[*inner_args[argv.length..-1]])
+      end
+
+      if block
+        inner_context.set_here(block.name, blockgiven)
+      end
+
+      begin
+        self.do(inner_context, *body)
+      rescue => e
+        # e.backtrace.unshift "(rouge):?: in #{name || "<anonymous>"}"
+        raise e
+      end
+    }
+
+    if name
+      fn.define_singleton_method(:to_s) { name }
+    end
+
+    fn
+  end
+
+  def _compile_fn(ns, lexicals, *args)
+    if args[0].is_a? Rouge::Symbol
+      name = args.shift
+    end
+
+    argv, *body = args
+
+    original_argv = argv
+
+    if argv[-2] == Rouge::Symbol[:&]
+      rest = argv[-1]
+      argv = argv[0...-2]
+    elsif argv[-4] == Rouge::Symbol[:&] and argv[-2] == Rouge::Symbol[:|]
+      rest = argv[-3]
+      argv = argv[0...-4] + argv[-2..-1]
+    else
+      rest = nil
+    end
+
+    if argv[-2] == Rouge::Symbol[:|]
+      block = argv[-1]
+      argv = argv[0...-2]
+    else
+      block = nil
+    end
+
+    lexicals = lexicals.dup
+    argv.each do |arg|
+      lexicals << arg.name
+    end
+    lexicals << rest.name if rest
+    lexicals << block.name if block
+
+    [Rouge::Symbol[:fn],
+     *(name ? [name] : []),
+     original_argv,
+     *Rouge::Compiler.compile(ns, lexicals, body)]
+  end
+
+  def def(context, name, *form)
+    if name.ns != nil
+      raise ArgumentError, "cannot def qualified var"
+    end
+
+    case form.length
+    when 0
+      context.ns.intern name.name
+    when 1
+      context.ns.set_here name.name, context.eval(form[0])
+    else
+      raise ArgumentError, "def called with too many forms #{form.inspect}"
+    end
+  end
+
+  def _compile_def(ns, lexicals, name, *form)
+    if name.ns != nil
+      raise ArgumentError, "cannot def qualified var"
+    end
+
+    lexicals = lexicals.dup
+    lexicals << name.name
+
+    [Rouge::Symbol[:def],
+     name,
+     *Rouge::Compiler.compile(ns, lexicals, form)]
+  end
+
+  def if(context, test, if_true, if_false=nil)
+    # Note that we rely on Ruby's sense of truthiness. (only false and nil are
+    # falsey)
+    if context.eval(test)
+      context.eval if_true
+    else
+      context.eval if_false
+    end
+  end
+
+  def do(context, *forms)
+    r = nil
+
+    while forms.length > 0
+      begin
+        form = Rouge::Compiler.compile(
+          context.ns,
+          Set[*context.lexical_keys],
+          forms.shift)
+
+        r = context.eval(form)
+      rescue Rouge::Context::ChangeContextException => cce
+        context = cce.context
+      end
+    end
+
+    r
+  end
+
+  def _compile_do(ns, lexicals, *forms)
+    [Rouge::Symbol[:do], *forms]
+  end
+
+  def ns(context, name, *args)
+    ns = Rouge[name.name]
+    ns.refer Rouge[:"rouge.builtin"]
+
+    args.each do |arg|
+      kind, *params = arg.to_a
+
+      case kind
+      when :use
+        params.each do |use|
+          ns.refer Rouge[use.name]
+        end
+      when :require
+        params.each do |param|
+          if param.is_a? Rouge::Symbol
+            Kernel.require param.name.to_s
+          elsif param.is_a? Array and
+                param.length == 3 and
+                param[0].is_a? Rouge::Symbol and
+                param[1] == :as and
+                param[2].is_a? Rouge::Symbol
+            unless Rouge::Namespace.exists? param[0].name
+              context.readeval(File.read("#{param[0].name}.rg"))
+            end
+            Rouge::Namespace[param[2].name] = Rouge[param[0].name]
+          end
+        end
+      else
+        raise "TODO bad arg in ns: #{kind}"
+      end
+    end
+
+    context = Rouge::Context.new ns
+    raise Rouge::Context::ChangeContextException, context
+  end
+
+  def _compile_ns(ns, lexicals, name, *args)
+    [Rouge::Symbol[:ns], name, *args]
+  end
+
+  def defmacro(context, name, *parts)
+    if name.ns
+      raise ArgumentError, "cannot defmacro fully qualified var"
+    end
+
+    if parts[0].is_a? Array
+      args, *body = parts
+      macro = Rouge::Macro[
+        context.eval(Rouge::Seq::Cons[Rouge::Symbol[:fn], args, *body])]
+    elsif parts.all? {|part| part.is_a? Rouge::Seq::Cons}
+      arities = {}
+
+      parts.each do |cons|
+        args, *body = cons.to_a
+
+        if !args.is_a? Array
+          raise ArgumentError,
+              "bad multi-form defmacro component #{args.inspect}"
+        end
+
+        if args.index(Rouge::Symbol[:&])
+          arity = -1
+        else
+          arity = args.length
+        end
+
+        if arities[arity]
+          raise ArgumentError, "seen same arity twice"
+        end
+
+        arities[arity] =
+            context.eval(Rouge::Seq::Cons[Rouge::Symbol[:fn], args, *body])
+      end
+
+      macro = Rouge::Macro[
+        lambda {|*inner_args, &blockgiven|
+          if arities[inner_args.length]
+            arities[inner_args.length].call(*inner_args, &blockgiven)
+          elsif arities[-1]
+            arities[-1].call(*inner_args, &blockgiven)
+          else
+            raise ArgumentError, "no matching arity in macro"
+          end
+        }]
+    else
+      raise ArgumentError, "neither single-form defmacro nor multi-form"
+    end
+
+    macro.define_singleton_method(:to_s) { :"#{context.ns.name}/#{name.name}" }
+
+    context.ns.set_here name.name, macro
+  end
+
+  def _compile_defmacro(ns, lexicals, name, *parts)
+    if name.ns
+      raise ArgumentError, "cannot defmacro fully qualified var"
+    end
+
+    if parts[0].is_a? Array
+      args, *body = parts
+      [Rouge::Symbol[:defmacro],
+       name,
+       *_compile_fn(ns, lexicals, args, *body)[1..-1]]
+    elsif parts.all? {|part| part.is_a? Rouge::Seq::Cons}
+      [Rouge::Symbol[:defmacro],
+       name,
+       *parts.map do |cons|
+        args, *body = cons.to_a
+
+        if !args.is_a? Array
+          raise ArgumentError,
+              "bad multi-form defmacro component #{args.inspect}"
+        end
+
+        Rouge::Seq::Cons[*_compile_fn(ns, lexicals, args, *body)[1..-1]]
+       end]
+    else
+      raise ArgumentError, "neither single-form defmacro nor multi-form"
+    end
+  end
+
+  def apply(context, fun, *args)
+    args =
+        args[0..-2].map {|f| context.eval f} +
+        context.eval(args[-1]).to_a
+    # This is a terrible hack.
+    context.eval(Rouge::Seq::Cons[
+        fun,
+        *args.map {|a| Rouge::Seq::Cons[Rouge::Symbol[:quote], a]}])
+  end
+
+  def var(context, f)
+    # HACK: just so it'll be found when fully qualified.
+    f
+  end
+
+  def _compile_var(ns, lexicals, symbol)
+    if symbol.ns
+      [Rouge::Symbol[:quote], Rouge[symbol.ns][symbol.name]]
+    else
+      [Rouge::Symbol[:quote], ns[symbol.name]]
+    end
+  end
+
+  def throw(context, throwable)
+    exception = context.eval(throwable)
+    begin
+      raise exception
+    rescue Exception => e
+      # TODO
+      #e.backtrace.unshift "(rouge):?:throw"
+      raise e
+    end
+  end
+
+  def try(context, *body)
+    return unless body.length > 0
+
+    form = body[-1]
+    if form.is_a?(Rouge::Seq::Cons) and
+       form[0].is_a? Rouge::Symbol and
+       form[0].name == :finally
+      finally = form[1..-1].freeze
+      body.pop
+    end
+
+    catches = {}
+    while body.length > 0
+      form = body[-1]
+      if !form.is_a?(Rouge::Seq::Cons) or
+         !form[0].is_a? Rouge::Symbol or
+         form[0].name != :catch
+        break
+      end
+
+      body.pop
+      catches[context.eval(form[1])] =
+        {:bind => form[2],
+         :body => form[3..-1].freeze}
+    end
+
+    r =
+      begin
+        self.do(context, *body)
+      rescue Exception => e
+        catches.each do |klass, caught|
+          if klass === e
+            subcontext = Rouge::Context.new context
+            subcontext.set_here caught[:bind].name, e
+            r = self.do(subcontext, *caught[:body])
+            self.do(context, *finally) if finally
+            return r
+          end
+        end
+        self.do(context, *finally) if finally
+        raise e
+      end
+
+    self.do(context, *finally) if finally
+    r
+  end
+
+  def _compile_try(ns, lexicals, *body)
+    return [Rouge::Symbol[:try]] unless body.length > 0
+
+    form = body[-1]
+    if form.is_a?(Rouge::Seq::Cons) and
+       form[0].is_a? Rouge::Symbol and
+       form[0].name == :finally
+      finally = form[1..-1].freeze
+      body.pop
+    end
+
+    catches = []
+    while body.length > 0
+      form = body[-1]
+      if !form.is_a?(Rouge::Seq::Cons) or
+         !form[0].is_a? Rouge::Symbol or
+         form[0].name != :catch
+        break
+      end
+
+      body.pop
+      catches <<
+        {:class => form[1],
+         :bind => form[2],
+         :body => form[3..-1].freeze}
+    end
+
+    form =
+    [Rouge::Symbol[:try],
+     *Rouge::Compiler.compile(ns, lexicals, body),
+     *catches.reverse.map {|c|
+      if !c[:bind].is_a?(Rouge::Symbol) or c[:bind].ns
+        raise ArgumentError, "bad catch binding #{c[:bind]}"
+      end
+
+      bind_lexicals = lexicals.dup << c[:bind].name
+      Rouge::Seq::Cons[Rouge::Symbol[:catch],
+                  Rouge::Compiler.compile(ns, lexicals, c[:class]),
+                  c[:bind],
+                  *c[:body].map {|f|
+                    Rouge::Compiler.compile(ns, bind_lexicals, f)
+                  }]
+    },
+    *(finally ? [Rouge::Seq::Cons[Rouge::Symbol[:finally],
+                             *finally.map {|f|
+                               Rouge::Compiler.compile(ns, lexicals, f)
+                             }]] : [])]
+  end
+
+  def destructure(context, parameters, values, evalled=false, r={})
+    # TODO: can probably move this elsewhere as a regular function.
+
+    if parameters.is_a?(Rouge::Symbol)
+      values = context.eval(values) if !evalled
+      r[parameters] = values
+      return r
+    end
+
+    if parameters.is_a?(Hash) and parameters.keys == [:keys]
+      keys = parameters.values[0]
+      context.eval(values).select do |k,v|
+        keys.include?(Rouge::Symbol[k])
+      end.each {|k,v| r[Rouge::Symbol[k]] = v}
+      return r
+    end
+
+    if parameters.is_a?(Hash)
+      values = context.eval(values) if !evalled
+      parameters.each do |local, foreign|
+        destructure(context, local, values[foreign], true, r)
+      end
+      return r
+    end
+
+    if !parameters.is_a?(Array) and !evalled
+      raise ArgumentError, "unknown destructure parameter list"
+    end
+
+    if !evalled and values.is_a? Array
+      if values[-2] == Rouge::Symbol[:|]
+        block = context.eval(values[-1])
+        block_supplied = true
+
+        values = values[0...-2]
+      end
+
+      if values[-2] == Rouge::Symbol[:&]
+        values =
+            values[0...-2].map {|v| context.eval(v)} +
+            context.eval(values[-1]).to_a
+      else
+        values = values.map {|v| context.eval(v)}
+      end
+    else
+      values = context.eval(values)
+    end
+
+    values = Rouge::Seq.seq(values)
+    original_values = values
+
+    parameters = parameters.dup
+    while parameters.length > 0
+      p = parameters.shift
+
+      if p == Rouge::Symbol[:&]
+        r[parameters.shift] = values
+        values = Rouge::Seq::Empty
+        next
+      end
+
+      if p == Rouge::Symbol[:|]
+        if not block_supplied
+          raise ArgumentError, "no block supplied"
+        end
+
+        r[parameters.shift] = block
+        next
+      end
+
+      if p == :as
+        r[parameters.shift] = Rouge::Seq.seq(original_values)
+        values = Rouge::Seq::Empty
+        next
+      end
+
+      if p.is_a? Array
+        destructure(context, p, Rouge::Seq.seq(values.first), true, r)
+      else
+        if p.ns
+          raise Rouge::Context::BadBindingError,
+              "cannot let qualified name in DESTRUCTURE"
+        end
+        r[p] = values ? values.first : nil
+      end
+
+      values = values ? values.next : nil
+    end
+
+    r
+  end
+
+  def _compile_destructure(ns, lexicals, parameters, values)
+    [Rouge::Symbol[:destructure],
+     parameters,
+     Rouge::Compiler.compile(ns, lexicals, values)]
+  end
+end
+
+# vim: set sw=2 et cc=80: