hammock-ruby 0.0.1.alpha

data/lib/hammock/lazy_transformer.rb

@@ -0,0 +1,169 @@
+require 'atomic'
+require 'hammock/reduced'
+require 'hammock/meta'
+require 'hammock/ifn'
+
+module Hammock
+  class LazyTransformer
+    include Meta
+
+    attr_accessor :rest, :stepper
+    attr_writer :first
+
+    def self.create(xform, coll)
+      new(Stepper.new(xform, RT.iter(coll)))
+    end
+
+    def initialize(*args)
+      if Stepper === args.first
+        @stepper = args.first
+        @first = nil
+        @rest = nil
+        @meta = nil
+      else
+        @meta, @first, @rest = args
+        @stepper = nil
+      end
+    end
+
+    def with_meta(meta)
+      seq
+      self.class.new(meta, first, rest)
+    end
+
+    def stepper
+      @stepper
+    end
+
+    def seq
+      stepper.step(self) unless stepper.nil?
+
+      if @rest.nil?
+        nil
+      else
+        self
+      end
+    end
+
+    def first
+      seq unless stepper.nil?
+      if @rest.nil?
+        nil
+      else
+        @first
+      end
+    end
+
+    def next
+      seq unless stepper.nil?
+      if @rest.nil?
+        nil
+      else
+        @rest.seq
+      end
+    end
+    alias tail next
+
+    def more
+      seq unless stepper.nil?
+      if @rest.nil?
+        EmptyList.new
+      else
+        @rest.seq
+      end
+    end
+
+    def to_a
+      ret = []
+      s = seq
+      until s.nil?
+        ret << s.first
+        s = s.next
+      end
+      ret
+    end
+
+    def count
+      i = 0
+      s = seq
+      until s.nil?
+        i += 0
+        s = s.next
+      end
+      i
+    end
+
+    def realized?
+      stepper.nil?
+    end
+
+    def empty?
+      seq.nil?
+    end
+
+    def inspect
+      "(#{to_a.map(&:inspect).join(' ')})"
+    end
+    alias to_s inspect
+
+
+    class Stepper
+      class StepFn
+        include IFn
+        def call(*args)
+          if args.length == 1
+            apply_result(args.first)
+          else
+            apply_result_with_input(*args)
+          end
+        end
+
+        def apply_result_with_input(result, input)
+          lt = result
+          lt.first = input
+          lt.rest = LazyTransformer.new(lt.stepper)
+          lt.stepper = nil
+          lt.rest
+        end
+
+        def apply_result(result)
+          lt = result
+          lt.stepper = nil
+          result
+        end
+      end
+
+      def initialize(xform, iter)
+        @iter = iter
+        @xform = xform.call(StepFn.new)
+      end
+
+      def next?
+        @iter.peek
+        true
+      rescue StopIteration
+        false
+      end
+
+      def step(lt)
+        while !lt.stepper.nil? && next?
+          if RT.reduced?(@xform.call(lt, @iter.next))
+            lt.stepper = nil
+            et = lt
+            until et.rest.nil?
+              et = et.rest
+              et.stepper = nil
+            end
+            @xform.call(et)
+            return
+          end
+        end
+        unless lt.stepper.nil?
+          @xform.call(lt)
+        end
+        nil
+      end
+    end
+
+  end
+end

data/lib/hammock/list.rb

@@ -0,0 +1,232 @@
+require 'thread'
+require 'forwardable'
+require 'hamster/enumerable'
+require 'hammock/set'
+require 'hammock/compiler'
+require 'hammock/ipersistent_collection'
+require 'hammock/iseq'
+
+module Hammock
+  module List
+    include IPersistentCollection
+    include Hamster::Enumerable
+    include ISeq
+
+    Undefined = Object.new
+
+    CADR = /^c([ad]+)r$/
+
+    def first; head end
+    def null?; empty? end
+    def rest; tail end
+
+    def size
+      reduce(0) { |memo, item| memo.next }
+    end
+    alias length size
+    alias count size
+
+    def cons(item)
+      Sequence.new(item, self)
+    end
+    alias conj cons
+
+    def each
+      return self unless block_given?
+      list = self
+      while !list.empty?
+        yield(list.head)
+        list = list.tail
+      end
+    end
+
+    def to_a
+      ret = []
+      each do |obj|
+        ret << obj
+      end
+      ret
+    end
+
+    def map(&block)
+      return self unless block_given?
+      Stream.new do
+        next self if empty?
+        Sequence.new(yield(head), tail.map(&block))
+      end
+    end
+
+    def append(other)
+      Stream.new do
+        next other if empty?
+        Sequence.new(head, tail.append(other))
+      end
+    end
+    alias cat append
+    alias concat append
+    alias + append
+
+    def cycle
+      Stream.new do
+        next self if empty?
+        Sequence.new(head, tail.append(self.cycle))
+      end
+    end
+
+    def clear
+      EmptyList.new
+    end
+
+    def join(sep = "")
+      return "" if empty?
+      sep = sep.to_s
+      tail.reduce(head.to_s.dup) { |result, item| result << sep << item.to_s }
+    end
+
+    def last
+      list = self
+      while !list.tail.empty?
+        list = list.tail
+      end
+      list.head
+    end
+
+    def drop(number)
+      Stream.new do
+        list = self
+        while !list.empty? && number > 0
+          number -= 1
+          list = list.tail
+        end
+        list
+      end
+    end
+
+    def nth(n, default=Undefined)
+      res = drop(n)
+      if res.empty? && default != Undefined
+        default
+      else
+        res.head
+      end
+    end
+
+    def chunk(number)
+      Stream.new do
+        next self if empty?
+        first, remainder = split_at(number)
+        Sequence.new(first, remainder.chunk(number))
+      end
+    end
+
+    def each_chunk(number, &block)
+      chunk(number).each(&block)
+    end
+    alias each_slice each_chunk
+
+    def flatten
+      Stream.new do
+        next self if empty?
+        next head.append(tail.flatten) if head.is_a?(List)
+        Sequence.new(head, tail.flatten)
+      end
+    end
+
+    def group_by(&block)
+      return group_by { |item| item } unless block_given?
+      reduce(EmptyHash) do |hash, item|
+        key = yield(item)
+        hash.put(key, (hash.get(key) || EmptyList.new).cons(item))
+      end
+    end
+
+    def at(index)
+      drop(index).head
+    end
+
+    def eql?(other)
+      list = self
+      loop do
+        return true if other.equal?(list)
+        return false unless other.is_a?(List)
+        return other.empty? if list.empty?
+        return false if other.empty?
+        return false unless other.head.eql?(list.head)
+        list = list.tail
+        other = other.tail
+      end
+    end
+    alias == eql?
+
+    def hash
+      reduce(0) { |hash, item| (hash << 5) - hash + item.hash }
+    end
+
+    def empty
+      EmptyList.new
+    end
+
+    def dup
+      self
+    end
+    alias clone dup
+
+    def to_list
+      self
+    end
+
+    def respond_to?(name, include_private = false)
+      super || CADR === name.to_s
+    end
+
+    private
+
+    def method_missing(name, *args, &block)
+      return accessor($1) if CADR === name.to_s
+      super
+    end
+
+    def accessor(sequence)
+      sequence.reverse.each_char.reduce(self) do |memo, char|
+        case char
+        when "a" then memo.head
+        when "d" then memo.tail
+        end
+      end
+    end
+  end
+
+  class EmptyList
+    include List
+    include Meta
+
+    def initialize(meta=nil)
+      @meta = meta
+    end
+
+    def head
+      nil
+    end
+
+    def tail
+      self
+    end
+
+    def seq
+      nil
+    end
+
+    def with_meta(meta)
+      self.class.new(meta)
+    end
+
+    def empty?
+      true
+    end
+
+    def inspect
+      "()"
+    end
+    alias to_s inspect
+  end
+end

data/lib/hammock/loop_locals.rb

@@ -0,0 +1,34 @@
+require 'hammock/map'
+require 'hammock/vector'
+
+module Hammock
+  class LoopLocals
+    def self.empty
+      new([], [])
+    end
+
+    def initialize(names, bindings)
+      unless Hammock::Map === bindings
+        bindings = Hammock::Map.new bindings
+      end
+      unless Hammock::Vector === names
+        names = Hammock::Vector.from_array(names)
+      end
+      @bindings = bindings
+      @names = names
+    end
+
+    def frame
+      @bindings
+    end
+
+    def rebind(recur_locals)
+      bindings = Hammock::Map.from_array @names.to_a.zip(recur_locals.to_a).flatten(1)
+      self.class.new(@names, bindings)
+    end
+
+    def bind(name, val)
+      self.class.new(@names.cons(name), @bindings.assoc(name, val))
+    end
+  end
+end

data/lib/hammock/map.rb

@@ -0,0 +1,205 @@
+require 'forwardable'
+require 'hamster/immutable'
+require 'hamster/trie'
+
+require 'hammock/ipersistent_collection'
+require 'hammock/meta'
+require 'hammock/ifn'
+require 'hammock/ilookup'
+require 'hammock/iseq'
+
+module Hammock
+  class Map
+    include Hamster::Immutable
+    include IPersistentCollection
+    include Meta
+    include IFn
+    include ILookup
+    include ISeq
+
+    Undefined = Object.new
+
+    def self.alloc_from(map, meta=nil)
+      map.send(:transform) { @meta = meta }
+    end
+
+    def self.create(coll)
+      case coll
+      when Map
+        coll
+      when Hash
+        from_hash(coll)
+      else
+        from_array(coll.to_a)
+      end
+    end
+
+    def self.from_hash(hash = {})
+      map = new
+      hash.reduce(map) { |m, (k, v)| m.put(k, v) }
+    end
+
+    def self.from_array(array, meta=nil)
+      map = new(meta)
+      array.each_slice(2) do |pair|
+        map = map.put(pair.first, pair.last)
+      end
+      map
+    end
+
+    def self.from_pairs(array, meta=nil)
+      map = new(meta)
+      array.each do |pair|
+        map = map.put(pair.first, pair.last)
+      end
+      map
+    end
+
+    def initialize(meta=nil)
+      @meta = meta
+      @trie = Hamster::EmptyTrie
+    end
+
+    def size
+      @trie.size
+    end
+    alias length size
+    alias count size
+
+    def empty?
+      @trie.empty?
+    end
+    alias null? empty?
+
+    def has_key?(key)
+      @trie.has_key?(key)
+    end
+    alias key? has_key?
+
+    def entry_at(key)
+      @trie.get(key)
+    end
+
+    def get(key)
+      if entry = entry_at(key)
+        entry.value
+      end
+    end
+    alias [] get
+
+    def fetch(key, default = Undefined)
+      entry = @trie.get(key)
+      if entry
+        entry.value
+      elsif default != Undefined
+        default
+      elsif block_given?
+        yield
+      else
+        raise KeyError.new("key not found: #{key.inspect}")
+      end
+    end
+    alias val_at fetch
+
+    def call(key, default=nil)
+      fetch(key, default)
+    end
+
+    def put(key, value = Undefined)
+      if value.equal?(Undefined)
+        put(key, yield(get(key)))
+      else
+        transform { @trie = @trie.put(key, value) }
+      end
+    end
+    alias assoc put
+
+    def delete(key)
+      trie = @trie.delete(key)
+      transform_unless(trie.equal?(@trie)) { @trie = trie }
+    end
+    alias without delete
+    alias dissoc delete
+
+    def each
+      return self unless block_given?
+      @trie.each { |entry| yield(entry.key, entry.value) }
+    end
+
+    def reduce(memo)
+      return memo unless block_given?
+      @trie.reduce(memo) { |memo, entry| yield(memo, entry.key, entry.value) }
+    end
+
+    def merge(other)
+      transform { @trie = other.reduce(@trie, &:put) }
+    end
+    alias + merge
+
+    def keys
+      reduce(Hammock::EmptyList.new) { |keys, key, _| keys.cons(key) }
+    end
+
+    def values
+      reduce(Hammock::EmptyList.new) { |values, _, value| values.cons(value) }
+    end
+
+    def seq
+      return if count == 0
+      @trie.reduce(Hammock::EmptyList.new) { |entries, entry| entries.cons(entry)}
+    end
+
+    def cons(obj)
+      case obj
+      when Vector
+        assoc(obj.get(0), obj.get(1))
+      when Hamster::Trie::Entry
+        assoc(obj.key, obj.value)
+      when obj.respond_to?(:to_a)
+        put *obj
+      else
+        raise "You passed #{pair} as an argument to conj, but needs an Array-like arg"
+      end
+    end
+
+    def conj(pair)
+      return merge(pair) if Map === pair
+      if pair.respond_to?(:to_a)
+        put *pair
+      else
+        raise "You passed #{pair} as an argument to conj, but needs an Array-like arg"
+      end
+    end
+
+    def empty
+      self.class.new(meta)
+    end
+
+    def eql?(other)
+      instance_of?(other.class) && @trie.eql?(other.instance_variable_get(:@trie))
+    end
+    alias == eql?
+
+    def hash
+      reduce(0) { |hash, key, value| (hash << 32) - hash + key.hash + value.hash }
+    end
+
+    def to_a
+      ret = []
+      each do |k,v|
+        ret << [k,v]
+      end
+      ret
+    end
+    alias pairs to_a
+
+    def inspect
+      out = []
+      each do |k, v|
+        out << "#{k.inspect} #{v.inspect}"
+      end
+      "{#{out.join(', ')}}"
+    end
+    alias to_s inspect
+  end
+end