hammock-ruby 0.0.1.alpha

data/lib/hammock/sequence.rb

@@ -0,0 +1,59 @@
+require 'hammock/meta'
+require 'hammock/list'
+
+module Hammock
+  class Sequence
+    include List
+    include Meta
+
+    attr_reader :head, :tail
+
+    def self.from_array(array, meta=nil)
+      return EmptyList.new(meta) if array.nil? || array.empty?
+      ret = array.to_a.reverse.inject(EmptyList.new) do |prev, el|
+        new(el, prev)
+      end
+      ret.with_meta(meta)
+    end
+
+    def self.alloc_from(other, meta=nil)
+      new(other.head, other.tail, meta)
+    end
+
+    def initialize(head, tail = Hammock::EmptyList.new, meta=nil)
+      @meta = meta
+      @head = head
+      @tail = tail
+    end
+
+    def car
+      head
+    end
+
+    def cdr
+      tail
+    end
+
+    def ==(other)
+      return false unless other.respond_to?(:tail)
+      first == other.first && tail == other.tail
+    end
+
+    def seq
+      self
+    end
+
+    def with_meta(meta)
+      self.class.new(head, tail, meta)
+    end
+
+    def inspect
+      "(#{to_a.map(&:inspect).join(' ')})"
+    end
+    alias to_s inspect
+
+    def empty?
+      false
+    end
+  end
+end

data/lib/hammock/set.rb

@@ -0,0 +1,144 @@
+require 'hamster/immutable'
+require 'hamster/trie'
+
+require 'hammock/ipersistent_collection'
+require 'hammock/meta'
+require 'hammock/ifn'
+require 'hammock/ilookup'
+
+module Hammock
+  class Set
+    include Hamster::Immutable
+    include IPersistentCollection
+    include Meta
+    include IFn
+    include ILookup
+
+    Undefined = Object.new
+
+    def self.alloc_from(other, meta=nil)
+      new(meta, other.instance_variable_get(:@trie))
+    end
+
+    def self.create(coll)
+      if self === coll
+        coll
+      else
+        from_array(coll.to_a)
+      end
+    end
+
+    def self.from_array(items, meta=nil)
+      items.reduce(new(meta)) { |set, item| set.add(item) }
+    end
+
+    def initialize(meta=nil, trie=Hamster::EmptyTrie)
+      @meta = meta
+      @trie = trie
+    end
+
+    def empty?
+      @trie.empty?
+    end
+
+    def size
+      @trie.size
+    end
+    alias count size
+    alias length size
+
+    def add(item)
+      transform_unless(include?(item)) { @trie = @trie.put(item, nil) }
+    end
+    alias conj add
+    alias cons add
+
+    def delete(item)
+      trie = @trie.delete(item)
+      transform_unless(trie.equal?(@trie)) { @trie = trie }
+    end
+    alias remove delete
+    alias disjoin delete
+
+    def each
+      return self unless block_given?
+      @trie.each { |entry| yield(entry.key) }
+    end
+
+    def map
+      return self unless block_given?
+      return self if empty?
+      transform do
+        @trie = @trie.reduce(Hamster::EmptyTrie) do |trie, entry|
+          trie.put(yield(entry.key), nil)
+        end
+      end
+    end
+
+    def reduce(memo = Undefined)
+      each do |item|
+        memo = memo.equal?(Undefined) ? item : yield(memo, item)
+      end if block_given?
+      memo unless memo.equal?(Undefined)
+    end
+
+    def any?
+      return any? { |item| item } unless block_given?
+      each { |item| return true if yield(item) }
+      false
+    end
+
+    def include?(object)
+      has_key?(object)
+    end
+
+    def has_key?(key)
+      @trie.has_key?(key)
+    end
+    alias key? has_key?
+
+    def fetch(object, default=Undefined)
+      if has_key?(object)
+        object
+      elsif !default.equal?(Undefined)
+        default
+      end
+    end
+    alias call fetch
+    alias val_at fetch
+
+    def get(object)
+      object if has_key?(object)
+    end
+
+    def seq
+      return if count == 0
+      Sequence.from_array(to_a)
+    end
+
+    def eql?(other)
+      instance_of?(other.class) && @trie.eql?(other.instance_variable_get(:@trie))
+    end
+    alias == eql?
+
+    def hash
+      reduce(0) { |hash, item| (hash << 5) - hash + item.hash }
+    end
+
+    def empty
+      self.class.new(meta)
+    end
+
+    def to_a
+      ret = []
+      each do |obj|
+        ret << obj
+      end
+      ret
+    end
+
+    def inspect
+      "\#{#{to_a.map(&:inspect).join(' ')}}"
+    end
+  end
+end

data/lib/hammock/stream.rb

@@ -0,0 +1,40 @@
+require 'hammock/list'
+require 'forwardable'
+
+module Hammock
+  class Stream
+    extend Forwardable
+    include List
+    include Meta
+
+    def initialize(meta=nil, &block)
+      @meta = meta
+      @block = block
+      @lock = Mutex.new
+    end
+
+    def_delegators :target, :head, :tail, :empty?
+
+    protected
+
+    def vivify
+      @lock.synchronize do
+        unless @block.nil?
+          @target = @block.call
+          @block = nil
+        end
+      end
+      @target
+    end
+
+    private
+
+    def target
+      list = vivify
+      while list.is_a?(Stream)
+        list = list.vivify
+      end
+      list
+    end
+  end
+end

data/lib/hammock/symbol.rb

@@ -0,0 +1,65 @@
+module Hammock
+  class Symbol
+    include Meta
+
+    attr_reader :name, :ns
+
+    def self.intern(*args)
+      return args.first if Hammock::Symbol === args.first
+
+      if args.length == 1
+        *ns, name = args.first.split("/", 2)
+        new(ns.first, name)
+      else
+        new(*args)
+      end
+    end
+
+    def self.alloc_from(other, meta)
+      new(other.instance_variable_get("@ns"), other.name, meta)
+    end
+
+    def initialize(ns, name, meta=nil)
+      @name = name
+      @ns = ns if ns && !ns.to_s.empty?
+      @name.freeze
+      @ns.freeze
+      @meta = meta
+    end
+
+    def ==(other)
+      return false unless other.respond_to?(:name)
+      return false unless other.respond_to?(:ns)
+      other.ns == ns && other.name == name
+    end
+    alias eql? ==
+
+    def constant
+      return @constant if defined?(@constant)
+      n = name.gsub(".", "::")
+      @constant = begin
+                    Object.const_defined?(n) && Object.const_get(n)
+                  rescue NameError
+                  end
+    end
+
+    def inspect
+      @to_s ||= if @ns
+                  "#@ns/#@name"
+                else
+                  name
+                end
+    end
+    alias to_s inspect
+
+    def namespace(contextual=nil)
+      inns = Hammock::RT::CURRENT_NS.deref
+      prefer_ns = contextual || inns
+      if @ns
+        prefer_ns.lookup_alias(@ns) || Namespace.find(@ns)
+      else
+        prefer_ns
+      end
+    end
+  end
+end

data/lib/hammock/var.rb

@@ -0,0 +1,186 @@
+require 'atomic'
+require 'hammock/ideref'
+require 'hammock/errors'
+require 'hammock/map'
+
+module Hammock
+  class Var
+    include Meta
+    include IFn
+    Undefined = Object.new
+
+    BINDING_KEY = "__bindings__".freeze
+
+    class Frame
+      attr_reader :bindings, :prev
+      def initialize(bindings, prev)
+        @bindings, @prev = bindings, prev
+      end
+      TOP = new(Map.new, nil)
+    end
+
+    def self.dvals
+      Thread.current[BINDING_KEY] ||= Frame::TOP
+    end
+
+    def self.dvals=(vals)
+      Thread.current[BINDING_KEY] = vals
+    end
+
+    def self.thread_bindings
+      f = dvals
+      ret = Map.new
+      f.bindings.each do |k,v|
+        ret.assoc(k, v)
+      end
+      ret
+    end
+
+    def self.push_thread_bindings(bindings)
+      f = dvals
+      bmap = f.bindings
+      bindings.each do |v,val|
+        if !v.dynamic?
+          raise Error, "Can't dynamically bind non-dynamic var: #{v.inspect}"
+        end
+        v.thread_bound!
+        bmap = bmap.assoc(v, val)
+      end
+      self.dvals = Frame.new(bmap, f)
+    end
+
+    def self.pop_thread_bindings
+      f = dvals.prev
+      if f.nil?
+        raise Error, "Pop without matching push"
+      else
+        self.dvals = f
+      end
+    end
+
+    def self.intern(ns_name, sym, val=Undefined)
+      if Namespace === ns_name
+        ns = ns_name
+      else
+        ns = Namespace.find_or_create(ns_name)
+      end
+
+      var = ns.intern(sym)
+      var.bind_root(val) unless val == Undefined
+      var
+    end
+
+    def self.find(ns_qualified_sym)
+      unless ns = ns_qualified_sym.ns
+        raise Error, "Symbol must be namespace-qualified"
+      end
+      unless namespace = Namespace.find(ns)
+        raise Error, "No such namespace: #{ns}"
+      end
+      namespace.find_var(ns_qualified_sym.name)
+    end
+
+    attr_reader :ns, :symbol, :root
+
+    def initialize(*args)
+      if args.length > 1
+        @ns, @symbol, @root = args
+      else
+        @root = args.first
+      end
+
+      @meta = nil
+      @dynamic = false
+      @public = true
+      @thread_bound = Atomic.new(false)
+      @rev = 0
+    end
+
+    alias namespace ns
+
+    def trace
+      return unless meta
+      "#{meta[:file]}:#{meta[:line]} in #@symbol"
+    end
+
+    def macro!
+      @meta = meta.assoc :macro, true
+    end
+
+    def dynamic!
+      @dynamic = true
+      self
+    end
+
+    def thread_bound!
+      @thread_bound.value = true
+    end
+
+    def thread_bound?
+      @thread_bound.value
+    end
+
+    def thread_binding
+      if thread_bound?
+        self.class.dvals.bindings[self]
+      end
+    end
+
+    def bound?
+      root? || (thread_bound? && self.class.dval.bindings.key?(self))
+    end
+
+    def root?
+      @rev > 0
+    end
+
+    def dynamic?
+      @dynamic
+    end
+
+    def public?
+      @public
+    end
+
+    def private?
+      !@public
+    end
+
+    def deref
+      thread_binding || @root
+    end
+
+    def bind_root(val)
+      @rev += 1
+      @root = val
+    end
+
+    def unbind_root
+      @root = nil
+    end
+
+    def meta=(meta)
+      if meta[:private]
+        @public = false
+      end
+      if meta[:dynamic]
+        @dynamic = true
+      end
+      @meta = meta
+    end
+
+    def call(*args)
+      @root.call(*args)
+    end
+
+    def to_s
+      if @ns
+        "#'#{@ns.name}/#{symbol.name}"
+      else
+        n = symbol ? symbol.to_s : "--unnamed--"
+        "#<Var: #{n}>"
+      end
+    end
+    alias inspect to_s
+  end
+end