hammock-ruby 0.0.1.alpha

data/lib/hammock/environment.rb

@@ -0,0 +1,40 @@
+module Hammock
+  class Environment
+    attr_reader :frame
+
+    def initialize(frame)
+      unless Hammock::Map === frame
+        frame = Hammock::Map.create frame
+      end
+      @frame = frame
+    end
+
+    def bind(name, val)
+      self.class.new(@frame.assoc name, val)
+    end
+
+    def merge(env)
+      self.class.new(@frame.merge(env.frame))
+    end
+
+    def find(name)
+      if item = @frame[name]
+        item
+      end
+    end
+    alias [] find
+
+    def key?(name)
+      @frame.key?(name)
+    end
+
+    def inspect
+      parts = []
+      f = frame.each do |k,v|
+        parts << " #{k}\t#{v.inspect}"
+      end
+      "#<#{self.class}\n#{parts.join("\n")}"
+    end
+    alias to_s inspect
+  end
+end

data/lib/hammock/errors.rb

@@ -0,0 +1,14 @@
+module Hammock
+  class Error < StandardError
+  end
+
+  class CompileError < Error
+    def initialize(form, msg=nil)
+      parts = [msg || "Error compiling form"]
+      if Meta === form && form.meta && form.meta[:line]
+        parts << "Originated from #{form.meta[:file]}:#{form.meta[:line]}, col #{form.meta[:column]}"
+      end
+      super(parts.join("\n"))
+    end
+  end
+end

data/lib/hammock/function.rb

@@ -0,0 +1,187 @@
+require 'hammock/meta'
+require 'hammock/ifn'
+
+module Hammock
+  class Function
+    include Meta
+    include IFn
+
+    attr_reader :arities
+    attr_writer :meta
+
+    def self.alloc_from(fn, meta)
+      new(fn.internal_name, fn.ns, fn.env, fn.arities).tap do |fn|
+        fn.meta = meta
+      end
+    end
+
+    def self.create(name, ns, env, arities)
+      new(name, ns, env, arities)
+    end
+
+    def initialize(internal_name, ns, env, arities)
+      @internal_name = internal_name || generate_name
+      @ns = ns
+      @env = env
+      @arities = arities
+      @meta = nil
+    end
+
+    def variadic?
+      arities.any?(&:variadic?)
+    end
+
+    def arity_counts
+      arities.map(&:arity)
+    end
+
+    def find_arity!(*args)
+      needed = args.to_a.length
+      arities.detect {|a| a.handles_arity?(needed)} or \
+        raise ArgumentError, wrong_arity_message(needed)
+    end
+
+    def wrong_arity_message(needed)
+      c = arity_counts.map(&:to_s)
+      c << "more" if variadic?
+      if c.length == 1
+        counts = c.first
+      else
+        counts = c[0..-2].join(", ") + " or #{c.last}"
+      end
+      "Wrong number of args passed to #{name}. Expected #{counts}; Got #{needed}"
+    end
+
+    def name
+      "#{ns.name}/#@internal_name"
+    end
+
+    def meta=(meta)
+      @meta = meta
+    end
+
+    def trace
+      return unless meta
+      "#{meta[:file]}:#{meta[:line]} in #@internal_name"
+    end
+
+    def to_proc
+      fn = self
+      lambda { |*args| fn.call(*args) }
+    end
+
+    def to_block
+      Block.new(self)
+    end
+
+    def call(*args)
+      arity = find_arity!(*args)
+
+      env = @env.bind("__namespace__", @ns)
+      env = env.bind(@internal_name, self)
+
+      locals = args
+
+      loop do
+        env = arity.bind_env(env, locals.to_a)
+        ret = nil
+        body = arity.body.dup
+        until body.empty?
+          ret = Compiler.evaluate(env, body.first)
+          body.shift
+        end
+        if RecurLocals === ret
+          if ret.to_a.last.nil?
+            locals = ret.to_a[0..-2]
+          else
+            locals = ret
+          end
+        else
+          break ret
+        end
+      end
+    end
+
+    def inspect
+      "#<Hammock::Function #@internal_name>"
+    end
+
+    protected
+
+    attr_reader :ns, :env, :internal_name
+
+    private
+
+    def generate_name
+      "fn__#{RT.next_id}"
+    end
+
+    class Arity
+      AMPERSAND = Symbol.intern("&")
+
+      attr_reader :bindings, :body, :arity, :args
+
+      def initialize(bindings, *body)
+        @bindings, @body = bindings, body
+        @locals, @args, @variadic, @variadic_name = unpack_args(bindings)
+        @arity = @args.length
+      end
+
+      def bind_env(env, args)
+        max = variadic? ? @args.length - 1 : @args.length
+
+        0.upto(max) do |i|
+          env = env.bind @args[i], args[i]
+        end
+
+        if variadic?
+          lastarg = nil
+          if args.length > max
+            tail = args[max..-1]
+            lastarg = Sequence.from_array(tail) if tail && !tail.empty?
+          end
+          env = env.bind @variadic_name, lastarg
+        end
+
+        env
+      end
+
+      def handles_arity?(count)
+        if variadic?
+          count >= @arity - 1
+        else
+          count == @arity
+        end
+      end
+
+      def variadic?
+        @variadic
+      end
+
+      def unpack_args(form)
+        locals = {}
+        args = []
+        lastisargs = false
+        argsname = nil
+
+        form.each do |x|
+          if x == AMPERSAND
+            lastisargs = true
+            next
+          end
+          if lastisargs and argsname
+            raise "variable length argument must be the last in the function #{form.inspect}"
+          end
+          argsname = x.name if lastisargs
+          if !(Symbol === x) || x.ns
+            raise "fn* arguments must be non namespaced symbols, got #{x}: in #{form.inspect}"
+          end
+          locals[x] = RT.list(x)
+          args << x.name
+        end
+
+        return locals, args, lastisargs, argsname
+      end
+    end
+  end
+end

data/lib/hammock/ichunked_seq.rb

@@ -0,0 +1,23 @@
+module Hammock
+  module IChunkedSeq
+    Undefined = Object.new
+
+    def nth(n, notfound=Undefined)
+      list = seq
+
+      n.times do
+        list = list.rest
+      end
+
+      if list.empty?
+        if notfound == Undefined
+          raise IndexError
+        else
+          notfound
+        end
+      else
+        list.first
+      end
+    end
+  end
+end

data/lib/hammock/ideref.rb

@@ -0,0 +1,5 @@
+module Hammock
+  module IDeref
+    # def deref; end
+  end
+end

data/lib/hammock/ifn.rb

@@ -0,0 +1,10 @@
+module Hammock
+  module IFn
+    # def call(*args)
+    # end
+
+    def apply_to(sequence)
+      call(*sequence.to_a)
+    end
+  end
+end

data/lib/hammock/ilookup.rb

@@ -0,0 +1,6 @@
+module Hammock
+  module ILookup
+    # def fetch(key, default=Undefined)
+    # end
+  end
+end

data/lib/hammock/interfaces.rb

@@ -0,0 +1,80 @@
+module IPersistentCollection
+  # returns int
+  def count; end
+
+  # returns a collection
+  def cons(obj); end
+
+  # returns empty collection
+  def empty(); end
+
+  # returns true or false
+  # def equiv(obj); end
+end
+
+module IPersistentVector
+  # returns int
+  def length; end
+
+  # returns IPersistentVector
+  def assocN(i, obj); end
+
+  # returns IPersistentVector
+  def cons(obj); end
+end
+
+module ILookup
+  def val_at(key, not_found=nil); end
+end
+
+module Associative
+  # returns MapEntry
+  def entry_at(key); end
+
+  # returns Associative
+  def assoc(key, val); end
+end
+
+module IPersistentMap
+  # returns IPersistentMap
+  def assoc(key, val); end
+
+  # returns IPersistentMap
+  def assocEx(key, val); end
+
+  # returns IPersistentMap
+  def without(key); end
+end
+
+module IMeta
+  def meta; end
+end
+
+module IObj
+  # returns IObj
+  def with_meta(meta); end
+end
+
+module ISeq
+  def first; end
+  def next; end
+  def more; end
+  def cons(obj); end
+end
+
+module IFn
+  def invoke(*args); end
+end
+
+module IReduce
+  def reduce(fn, start=nil); end
+end
+
+# module IEditableCollection
+#   def as_transient; end
+# end
+
+# module ITransientCollection
+#   def conj(obj); end
+#   def persistent; end
+# end

data/lib/hammock/ipersistent_collection.rb

@@ -0,0 +1,15 @@
+module Hammock
+  module IPersistentCollection
+    # returns int
+    def count; end
+
+    # returns a collection
+    def cons(obj); end
+
+    # returns empty collection
+    def empty(); end
+
+    # returns true or false
+    # def equiv(obj); end
+  end
+end

data/lib/hammock/ireference.rb

@@ -0,0 +1,15 @@
+require 'hammock/meta'
+
+module Hammock
+  module IReference
+    include Meta
+    def reset_meta(meta)
+      @meta = meta
+    end
+
+    def alter_meta(fn, args)
+      args = [@meta] + args.to_a
+      @meta = fn.invoke(*args)
+    end
+  end
+end

data/lib/hammock/iseq.rb

@@ -0,0 +1,12 @@
+module Hammock
+  module ISeq
+    def first; end
+    def next; end
+    def rest; end
+
+    # override
+    def cons(obj)
+      Sequence.new(obj, self)
+    end
+  end
+end

data/lib/hammock/lazy_sequence.rb

@@ -0,0 +1,82 @@
+require 'atomic'
+require 'hammock/meta'
+require 'hammock/list'
+
+module Hammock
+  class LazySequence
+    include List
+    include Meta
+
+    attr_reader :s
+
+    def self.alloc_from(ls, meta=nil)
+      new(meta, ls.fn, ls.s)
+    end
+
+    def initialize(meta=nil, fn=nil, s=nil)
+      @meta = meta
+      @fn = Atomic.new(fn)
+      @s = s
+      @target = nil
+    end
+
+    def seq
+      list = sval
+      while list.is_a?(LazySequence)
+        list = list.sval
+      end
+      @s = RT.seq(list)
+    end
+
+    def empty?
+      seq.nil?
+    end
+
+    def head
+      seq
+      return nil if @s.nil?
+      @s.head
+    end
+
+    def tail
+      seq
+      return nil if @s.nil?
+      @s.tail
+    end
+
+    def rest
+      seq
+      return EmptyList.new if @s.nil?
+      @s.rest
+    end
+
+    def each
+      return self unless block_given?
+      list = self
+      while !list.empty?
+        yield(list.head)
+        list = list.rest
+      end
+    end
+
+    def inspect
+      seq.inspect
+    end
+
+    def fn
+      @fn.value
+    end
+
+    protected
+
+    def sval
+      unless fn.nil?
+        @fn.update do |v|
+          @target = v.call
+          nil
+        end
+      end
+      @target.nil? ? @s : @target
+    end
+  end
+end