hammock-ruby 0.0.1.alpha

data/lib/hammock/aref.rb

@@ -0,0 +1,57 @@
+require 'hammock/map'
+require 'hammock/errors'
+require 'hammock/ireference'
+
+module Hammock
+  class ARef
+    include IReference
+
+    attr_writer :validator
+
+    def initialize(meta=nil)
+      @meta = meta
+      @watches = Map.new
+      @validator = nil
+    end
+
+    def validate(fn_or_obj, obj=nil)
+      if obj
+        fn = fn_or_obj
+      else
+        obj = fn_or_obj
+        fn = validator
+      end
+
+      if fn && !fn.call(obj)
+        raise Error, "Illegal reference state"
+      end
+    end
+
+    def add_watch(key, cb)
+      @watches = watches.assoc(key, cb)
+    end
+
+    def remove_watch(key)
+      @watches = watches.without(key)
+    end
+
+    def notify_watches(oldval, newval)
+      return if watches.count == 0
+      watches.each do |key, fn|
+        if fn
+          fn.call(key, self, oldval, newval)
+        end
+      end
+    end
+
+    def watches
+      @watches
+    end
+
+    protected
+
+    def validator
+      @validator
+    end
+  end
+end

data/lib/hammock/array_chunk.rb

@@ -0,0 +1,49 @@
+require 'hammock/errors'
+
+module Hammock
+  class ArrayChunk
+    Undefined = Object.new
+
+    def initialize(array, offset, endi=nil)
+      @array = array
+      @offset = offset
+      @end = endi || array.length
+    end
+
+    def fetch(i, not_found=Undefined)
+      if not_found == Undefined || (i >= 0 && i < count)
+        @array[@offset + i]
+      else
+        not_found
+      end
+    end
+    alias nth fetch
+
+    def count
+      @end - @offset
+    end
+    alias size count
+    alias length count
+
+    def drop_first
+      if @offset == @end
+        raise Error, "drop_first of empty chunk"
+      else
+        self.class.new(@array, @offset + 1, @end)
+      end
+    end
+
+    def reduce(fn, start)
+      ret = fn.call(start, @array[@offset])
+      return ret if RT.reduced?(ret)
+
+      x = @offset + 1
+      while x < @end
+        ret = fn.call(ret, @array[x])
+        return ret if RT.reduced?(ret)
+        x += 1
+      end
+      ret
+    end
+  end
+end

data/lib/hammock/atom.rb

@@ -0,0 +1,50 @@
+require 'atomic'
+require 'hammock/aref'
+require 'hammock/ideref'
+
+module Hammock
+  class Atom < ARef
+    include IDeref
+    def initialize(obj, meta=nil)
+      super(meta)
+      @state = Atomic.new(obj)
+    end
+
+    def deref
+      @state.get
+    end
+
+    def swap(fn, *args)
+      loop do
+        v = deref
+        new_value = fn.call(v, *args)
+        validate(new_value)
+        if @state.compare_and_set(v, new_value)
+          notify_watches(v, new_value)
+          return new_value
+        end
+      end
+    end
+
+    def compare_and_set(old_value, new_value)
+      validate(new_value)
+      ret = @state.compare_and_set(old_value, new_value)
+      notify_watches(old_value, new_value) if ret
+      ret
+    end
+
+    def reset(new_value)
+      old_value = deref
+      validate(new_value)
+      @state.value = new_value
+      notify_watches(old_value, new_value)
+      new_value
+    end
+
+    def inspect
+      prefix = "#<#{self.class}:0x#{self.__id__.to_s(16)}"
+      "#{prefix} #{deref.inspect}>"
+    end
+    alias to_s inspect
+  end
+end

data/lib/hammock/block.rb

@@ -0,0 +1,8 @@
+module Hammock
+  class Block
+    attr_reader :value
+    def initialize(value)
+      @value = value
+    end
+  end
+end

data/lib/hammock/chunk_buffer.rb

@@ -0,0 +1,25 @@
+require 'hammock/array_chunk'
+
+module Hammock
+  class ChunkBuffer
+    def initialize(capacity)
+      @buffer = ::Array.new(capacity)
+      @end = 0
+    end
+
+    def add(obj)
+      @buffer[@end] = obj
+      @end += 1
+    end
+
+    def chunk
+      ret = ArrayChunk.new(@buffer, 0, @end)
+      @buffer = nil
+      ret
+    end
+
+    def count
+      @end
+    end
+  end
+end

data/lib/hammock/chunked_cons.rb

@@ -0,0 +1,108 @@
+require 'hammock/meta'
+require 'hammock/ichunked_seq'
+require 'hammock/iseq'
+
+module Hammock
+  class ChunkedCons
+    include Meta
+    include IChunkedSeq
+    include ISeq
+
+    def initialize(chunk, more, meta=nil)
+      @chunk = chunk
+      @_more = more
+      @meta = meta
+    end
+
+    def with_meta(meta)
+      if @meta == meta
+        self
+      else
+        self.class.new(@chunk, @_more, meta)
+      end
+    end
+
+    def first
+      @chunk.nth(0)
+    end
+    alias head first
+
+    def rest
+      if @chunk.count > 1
+        self.class.new(@chunk.drop_first, @_more)
+      elsif @_more.nil?
+        EmptyList.new
+      else
+        @_more
+      end
+    end
+
+    def next
+      if @chunk.count > 1
+        self.class.new(@chunk.drop_first, @_more)
+      else
+        chunked_next
+      end
+    end
+    alias tail next
+
+    def chunked_first
+      @chunk
+    end
+
+    def chunked_next
+      chunked_rest.seq
+    end
+
+    def chunked_rest
+      if @_more.nil?
+        EmptyList.new
+      else
+        @_more
+      end
+    end
+
+    def each
+      return self unless block_given?
+      list = self
+      until list.nil? || list.empty?
+        yield(list.head)
+        list = list.tail
+      end
+    end
+
+    def to_a
+      ret = []
+      each do |i|
+        ret << i
+      end
+      ret
+    end
+
+    def empty?
+      false
+    end
+
+    def seq
+      self
+    end
+
+    def empty
+      EmptyList.new
+    end
+
+    def dup
+      self
+    end
+    alias clone dup
+
+    def to_list
+      self
+    end
+
+    def inspect
+      "(#{to_a.map(&:inspect).join(' ')})"
+    end
+    alias to_s inspect
+  end
+end

data/lib/hammock/chunked_seq.rb

@@ -0,0 +1,97 @@
+require 'hammock/meta'
+require 'hammock/array_chunk'
+require 'hammock/ichunked_seq'
+require 'hammock/iseq'
+
+module Hammock
+  class ChunkedSeq
+    include IChunkedSeq
+    include ISeq
+    include Meta
+
+    def initialize(vec, i, offset, node=nil, meta=nil)
+      @vec = vec
+      @i = i
+      @offset = offset
+      @meta = meta
+      @node = node || @vec.array_for(i)
+    end
+
+    def chunked_first
+      ArrayChunk.new(@node, @offset)
+    end
+
+    def chunked_next
+      if @i + @node.length < @vec.count
+        ChunkedSeq.new(vec, @i + @node.length, 0)
+      end
+    end
+
+    def chunked_rest
+      seq = chunked_next
+      return EmptyList.new if seq.nil?
+      seq
+    end
+
+    def with_meta(meta)
+      self.class.new(@vec, @i, @offset, @node, meta)
+    end
+
+    def first
+      @node[@offset]
+    end
+    alias head first
+
+    def next?
+      (@offset + 1 < @node.length) || (@i + @node.length < @vec.count)
+    end
+
+    def each
+      return self unless block_given?
+      list = self
+      while list.next?
+        yield(list.head)
+        list = list.next
+      end
+    end
+
+    def to_a
+      ret = []
+      each do |v|
+        ret << v
+      end
+      ret
+    end
+
+    def next
+      if @offset + 1 < @node.length
+        ChunkedSeq.new(@vec, @i, @offset + 1, @node)
+      else
+        chunked_next
+      end
+    end
+
+    def rest
+      t = self.next
+      return EmptyList.new if t.nil?
+      t
+    end
+    alias tail rest
+
+    def seq
+      self
+    end
+
+    def empty?
+      seq.nil?
+    end
+
+    def count
+      @vec.count - (@i + @offset)
+    end
+
+    def inspect
+      "[#{to_a.map(&:inspect).join(' ')}]"
+    end
+  end
+end

data/lib/hammock/compiler.rb

@@ -0,0 +1,197 @@
+require 'hammock/symbol'
+require 'hammock/errors'
+
+module Hammock
+  module Compiler
+    extend self
+    DOT = Symbol.intern(".")
+    NEW = Symbol.intern("new")
+
+    def namespace(env, sym)
+      env["__namespace__"] || sym.namespace || RT::CURRENT_NS.deref
+    end
+
+    def find_var(env, sym)
+      namespace(env, sym).find_var(sym)
+    end
+
+    def macro?(form)
+      Meta === form && form.meta && form.meta[:macro]
+    end
+
+    def expand_method(form)
+      meta = form.meta
+      method, target, *args = *form
+      args = Sequence.from_array(args)
+      method = Symbol.intern(method.name[1..-1])
+      if args
+        args = args.cons(method)
+      else
+        args = method
+      end
+      Sequence.from_array([DOT, target, args], meta)
+    end
+
+    def expand_new(form)
+      meta = form.meta
+      klass, *args = *form
+      args = Sequence.from_array(args)
+      klass = Symbol.intern(klass.name[0..-2])
+      if args
+        args = args.cons(NEW)
+      else
+        args = NEW
+      end
+      Sequence.from_array([DOT, klass, args], meta)
+    end
+
+    def macroexpand1(form, env=RT.global_env)
+      form, _ = _macroexpand1(env, form)
+      form
+    end
+
+    def _macroexpand1(env, form)
+      return form, false unless form.is_a?(List)
+      sym = form.car
+      return form, false unless Hammock::Symbol === sym
+      meta = form.meta
+
+      if item = find_var(env, sym)
+        dreffed = item.deref
+        if macro?(item) || macro?(dreffed)
+          begin
+            form = dreffed.call(form, env, *form.tail)
+            if meta && Meta === form
+              form = form.with_meta(meta)
+            end
+          rescue => e
+            raise Hammock::CompileError.new(form), "Error compiling: #{e}", e.backtrace
+          end
+          return form, true
+        else
+          return form, false
+        end
+      elsif sym.name == DOT.name
+        return form, false
+      elsif sym.name.start_with?(DOT.name)
+        form = expand_method(form)
+        return form, false
+      elsif sym.name.end_with?(DOT.name)
+        form = expand_new(form)
+        return form, false
+      else
+        return form, false
+      end
+    end
+
+    def special(form)
+      return unless form.is_a?(List)
+      RT.special(form.car)
+    end
+
+    def macroexpand(env, form)
+      return form unless List === form && Hammock::Symbol === form.first
+      ret = true
+      spec = nil
+      while ret && !spec
+        form, ret = _macroexpand1(env, form)
+        spec = special(form) if form
+      end
+      form
+    end
+
+    def compile(env, form)
+      return form unless IPersistentCollection === form
+      meta = form.meta
+      new_form = form.to_a.map do |f|
+        compile(env, f)
+      end
+      case form
+      when List
+        list = Sequence.from_array(new_form, meta)
+        macroexpand(env, list)
+      when Vector
+        Vector.from_array(new_form, meta)
+      when Map
+        Map.from_pairs(new_form).with_meta(meta)
+      when Set
+        Set.from_array(new_form, meta)
+      end
+    end
+
+    def evaluate(env, form)
+      form = macroexpand(env, form)
+
+      case form
+      when Var
+        form.root
+      when EmptyList
+        form
+      when Hammock::Symbol
+        return env[form.name] if env.key?(form.name) && !form.ns
+        namespace = form.namespace(env["__namespace__"])
+        if namespace.has_var?(form.name) && (v = namespace.find_var(form.name))
+          v.deref
+        elsif form.constant
+          form.constant
+        else
+          raise "Unable to resolve symbol #{form.name} in this context"
+        end
+      when List
+        if s = special(form)
+          return s.call(form, env, *form.tail)
+        end
+
+        head = form.car
+
+        fn = evaluate(env, head)
+
+        if Var === fn
+          fn = fn.deref
+        end
+
+        if fn.respond_to?(:trace) && (t = fn.trace)
+          env = env.bind("__stack__", env["__stack__"].add(t))
+        end
+
+        case fn
+        when IFn
+          args = (form.tail || []).to_a.map { |elem| evaluate(env, elem) }
+          begin
+            fn.call *args
+          rescue => e
+            raise e.class, e.message, (env["__stack__"].to_a.reverse)
+          end
+        when ::Symbol
+          args = (form.tail || []).to_a.map { |elem| evaluate(env, elem) }
+          if args.count > 2
+            raise ArgumentError, "more than one arg passed as argument to Keyword #{fn}", env["__stack__"].to_a
+          end
+          map, default = *args
+          if ILookup === map
+            map.fetch(fn, default)
+          end
+        else
+          raise Error, "What? #{head.inspect}, #{fn.inspect}, #{form}, #{form.meta}"
+        end
+      when Map
+        ret = []
+        form.each do |k,v|
+          ret << [evaluate(env, k), evaluate(env, v)]
+        end
+        Map.from_pairs(ret, form.meta)
+      when RT::Finally, RT::Catch
+        RT::Do.new.call(nil, env, *form.body)
+      when Hammock::Set, Vector
+        klass = form.class
+        ret = []
+        form.each do |v|
+          ret << evaluate(env, v)
+        end
+        klass.from_array(ret, form.meta)
+      else # un-evaluable
+        form
+      end
+    end
+  end
+end