immutable 0.1.0

data/README.md

@@ -0,0 +1,39 @@
+immutable - immutable data structures for Ruby
+==============================================
+
+This project aims to provide immutable data structures for Ruby.
+
+Currently, immutable provides the following classes:
+
+* Immutable::List
+* Immutable::Map
+
+Install
+========================
+
+	$ gem install immutable
+
+License
+========================
+	(The MIT License)
+
+	Copyright (c) 2012 Shugo Maeda
+
+	Permission is hereby granted, free of charge, to any person obtaining
+	a copy of this software and associated documentation files (the
+	'Software'), to deal in the Software without restriction, including
+	without limitation the rights to use, copy, modify, merge, publish,
+	distribute, sublicense, and/or sell copies of the Software, and to
+	permit persons to whom the Software is furnished to do so, subject to
+	the following conditions:
+
+	The above copyright notice and this permission notice shall be
+	included in all copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+	IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+	CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+	TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+	SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/benchmark/benchmark_map.rb

@@ -0,0 +1,78 @@
+require 'benchmark'
+require 'avl_tree'
+require 'red_black_tree'
+require 'immutable/map'
+require 'openssl'
+
+#random = Random.new(0)
+
+TIMES = 100000
+key_size = 10
+
+def aset(h, keys)
+  keys.each do |k|
+    h[k] = 1
+  end
+end
+
+def aref(h, keys)
+  keys.each do |k|
+    h[k]
+  end
+end
+
+def delete(h, keys)
+  keys.each do |k|
+    h.delete(k)
+  end
+end
+
+def map_insert(h, keys)
+  keys.inject(h) { |m, k|
+    m.insert(k, 1)
+  }
+end
+
+def map_delete(h, keys)
+  keys.inject(h) { |m, k|
+    m.delete(k)
+  }
+end
+
+def run(bm, h, keys)
+  name = h.class.name
+  bm.report("#{name} aset") do
+    aset(h, keys)
+  end
+  bm.report("#{name} aref") do
+    aref(h, keys)
+  end
+  bm.report("#{name} delete") do
+    delete(h, keys)
+  end
+end
+
+def map_run(bm, h, keys)
+  name = h.class.name
+  bm.report("#{name} insert") do
+    h = map_insert(h, keys)
+  end
+  bm.report("#{name} aref") do
+    aref(h, keys)
+  end
+  bm.report("#{name} delete") do
+    h = map_delete(h, keys)
+  end
+end
+
+keys = []
+TIMES.times do
+  keys << OpenSSL::Random.random_bytes(key_size)
+end
+
+Benchmark.bmbm do |bm|
+  run(bm, Hash.new, keys)
+  run(bm, AVLTree.new, keys)
+  run(bm, RedBlackTree.new, keys)
+  map_run(bm, Immutable::Map.empty, keys)
+end

data/lib/immutable/list.rb

@@ -0,0 +1,455 @@
+# -*- tailcall-optimization: true; trace-instruction: false -*-
+
+module Immutable
+  # <code>Immutable::List</code> represents an immutable list.
+  #
+  # <code>Immutable::List</code> is an abstract class and
+  # <code>Immutable::List.[]</code> should be used instead of
+  # <code>Immutable::List.new</code>. For example:
+  #
+  #   include Immutable
+  #   p List[]      #=> List[]
+  #   p List[1, 2]  #=> List[1, 2]
+  #
+  # <code>Immutable::Nil</code> represents an empty list, and
+  # <code>Immutable::Cons</code> represents a cons cell, which is a node in
+  # a list. For example:
+  #
+  #   p Nil                    #=> List[]
+  #   p Cons[1, Cons[2, Nil]]  #=> List[1, 2]
+  class List
+    class EmptyError < StandardError
+      def initialize(msg = "list is empty")
+        super(msg)
+      end
+    end
+
+    # Returns a new list populated with the given objects.
+    def self.[](*args)
+      from_array(args)
+    end
+
+    # Converts the given array +ary+ to a list.
+    def self.from_array(ary)
+      ary.reverse_each.inject(Nil) { |x, y|
+        Cons.new(y, x)
+      }
+    end
+
+    # Converts +enum+ to a list. +enum+ should respond to <code>each</code>.
+    def self.from_enum(enum)
+      enum.inject(Nil) { |x, y|
+        Cons.new(y, x)
+      }.reverse
+    end
+
+    # Appends two lists +self+ and +xs+.
+    def +(xs)
+      foldr(xs) { |y, ys| Cons[y, ys] }
+    end
+
+    # Returns the first element of +self+. If +self+ is empty,
+    # <code>Immutable::List::EmptyError</code> is raised.
+    def head
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Returns the first element of +self+. If +self+ is empty,
+    # <code>Immutable::List::EmptyError</code> is raised.
+    def first
+      head
+    end
+
+    # Returns the last element of +self+. If +self+ is empty,
+    # <code>Immutable::List::EmptyError</code> is raised.
+    def last
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Returns the element after the head of +self+. If +self+ is empty,
+    # <code>Immutable::List::EmptyError</code> is raised.
+    def tail
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Returns all the element of +self+ except the last one.
+    # If +self+ is empty, <code>Immutable::List::EmptyError</code> is
+    # raised.
+    def init
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Returns <code>true</code> if +self+ is empty.
+    def empty?
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Returns <code>true</code> if +self+ is empty.
+    def null?
+      empty?
+    end
+
+    # Returns the number of elements in +self+. May be zero.
+    def length
+      foldl(0) { |x, y| x + 1 }
+    end
+
+    alias size length
+
+    # Returns the list obtained by applying the given block to each element
+    # in +self+.
+    def map
+      foldr(Nil) { |x, xs| Cons[yield(x), xs] }
+    end
+
+    # Returns the elements of +self+ in reverse order.
+    def reverse
+      foldl(Nil) { |x, y| Cons[y, x] }
+    end
+
+    # Inserts +xs+ in between the lists in +self+.
+    def intersperse(xs)
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Inserts +xs+ in between the lists in +self+ and concatenates the
+    # result.
+    # <code>xss.intercalate(xs)</code> is equivalent to
+    # <code>xss.intersperse(xs).flatten</code>.
+    def intercalate(xs)
+      intersperse(xs).flatten
+    end
+
+    # Transposes the rows and columns of +self+. For example:
+    # 
+    #   p List[List[1, 2, 3], List[4, 5, 6]].transpose
+    #   #=> List[List[1, 4], List[2, 5], List[3, 6]]
+    def transpose
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Reduces +self+ using +block+ from right to left. +e+ is used as the
+    # starting value. For example:
+    #
+    #   List[1, 2, 3].foldr(9) { |x, y| x + y } #=> 1 - (2 - (3 - 9)) = -7
+    def foldr(e, &block)
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Reduces +self+ using +block+ from right to left. If +self+ is empty,
+    # <code>Immutable::List::EmptyError</code> is raised.
+    def foldr1(&block)
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Reduces +self+ using +block+ from left to right. +e+ is used as the
+    # starting value. For example:
+    #
+    #   List[1, 2, 3].foldl(9) { |x, y| x + y } #=> ((9 - 1) - 2) - 3 = 3
+    def foldl(e, &block)
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Reduces +self+ using +block+ from left to right. If +self+ is empty,
+    # <code>Immutable::List::EmptyError</code> is raised.
+    def foldl1(&block)
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Concatenates a list of lists.
+    def flatten
+      foldr(Nil) { |x, xs| x + xs }
+    end
+
+    # An alias of <code>flatten</code>.
+    alias concat flatten
+
+    # Returns the list obtained by concatenating the results of the given
+    # block for each element in +self+.
+    def flat_map
+      foldr(Nil) { |x, xs| yield(x) + xs }
+    end
+
+    # An alias of <code>flat_map</code>.
+    alias concat_map flat_map
+
+    # An alias of <code>flat_map</code>.
+    alias bind flat_map
+
+    # Computes the sum of the numbers in +self+.
+    def sum
+      foldl(0, &:+)
+    end
+
+    # Computes the product of the numbers in +self+.
+    def product
+      foldl(1, &:*)
+    end
+
+    # Builds a list from the seed value +e+ and the given block. The block
+    # takes a seed value and returns <code>nil</code> if the seed should
+    # unfold to the empty list, or returns <code>[a, b]</code>, where
+    # <code>a</code> is the head of the list and <code>b</code> is the next
+    # seed from which to unfold the tail.  For example:
+    #
+    #   xs = List.unfoldr(3) { |x| x == 0 ? nil : [x, x - 1] }
+    #   p xs #=> List[3, 2, 1]
+    #
+    # <code>unfoldr</code> is the dual of <code>foldr</code>.
+    def self.unfoldr(e, &block)
+      x = yield(e)
+      if x.nil?
+        Nil
+      else
+        y, z = x
+        Cons[y, unfoldr(z, &block)]
+      end
+    end
+
+    # Returns the first +n+ elements of +self+, or +self+ itself if
+    # <code>n > self.length</code>.
+    def take(n)
+      raise ScriptError, "this method should be overriden"
+    end
+
+
+    # Returns the suffix of +self+ after the first +n+ elements, or
+    # <code>List[]</code> if <code>n > self.length</code>.
+    def drop(n)
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Returns the longest prefix of the elements of +self+ for which +block+
+    # evaluates to true.
+    def take_while(&block)
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Returns the suffix remaining after
+    # <code>self.take_while(&block)</code>.
+    def drop_while(&block)
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Returns the first element in +self+ for which the given block
+    # evaluates to true.  If such an element is not found, it
+    # returns <code>nil</code>.
+    def find(&block)
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Returns the elements in +self+ for which the given block evaluates to
+    # true.
+    def filter
+      foldr(Nil) { |x, xs|
+        if yield(x)
+          Cons[x, xs]
+        else
+          xs
+        end
+      }
+    end
+  end
+
+  Nil = List.new
+
+  class Cons < List
+    # Creates a list obtained by prepending +head+ to the list +tail+.
+    def self.[](head, tail = Nil)
+      self.new(head, tail)
+    end
+
+    # Creates a list obtained by prepending +head+ to the list +tail+.
+    def initialize(head, tail = Nil)
+      @head = head
+      @tail = tail
+    end
+
+    def Nil.head
+      raise EmptyError
+    end
+
+    attr_reader :head
+
+    def Nil.last
+      raise EmptyError
+    end
+
+    def last
+      if @tail.empty?
+        @head
+      else
+        @tail.last
+      end
+    end
+
+    def Nil.tail
+      raise EmptyError
+    end
+
+    attr_reader :tail
+
+    def Nil.init
+      raise EmptyError
+    end
+
+    def init
+      if @tail.empty?
+        Nil
+      else
+        Cons[@head, @tail.init]
+      end
+    end
+
+    def Nil.empty?
+      true
+    end
+
+    def empty?
+      false
+    end
+
+    def Nil.foldr(e)
+      e
+    end
+
+    def foldr(e, &block)
+      yield(@head, @tail.foldr(e, &block))
+    end
+
+    def Nil.foldr1
+      raise EmptyError
+    end
+
+    def foldr1(&block)
+      if @tail.empty?
+        @head
+      else
+        yield(@head, @tail.foldr1(&block))
+      end
+    end
+
+    def Nil.foldl(e)
+      e
+    end
+
+    def foldl(e, &block)
+      @tail.foldl(yield(e, @head), &block)
+    end
+
+    def Nil.foldl1
+      raise EmptyError
+    end
+
+    def foldl1(&block)
+      @tail.foldl(@head, &block)
+    end
+
+    def ==(xs)
+      if xs.empty?
+        false
+      else
+        @head == xs.head && @tail == xs.tail
+      end
+    end
+
+    def Nil.inspect
+      "List[]"
+    end
+
+    def inspect
+      "List[" + @head.inspect +
+        @tail.foldl("") {|x, y| x + ", " + y.inspect } + "]"
+    end
+
+    def Nil.intersperse(sep)
+      Nil
+    end
+
+    def intersperse(sep)
+      Cons[@head, @tail.prepend_to_all(sep)]
+    end
+
+    def Nil.prepend_to_all(sep)
+      Nil
+    end
+
+    def prepend_to_all(sep)
+      Cons[sep, Cons[@head, @tail.prepend_to_all(sep)]]
+    end
+
+    def Nil.transpose
+      Nil
+    end
+
+    def transpose
+      if @head == Nil
+        @tail.transpose
+      else
+        tail = @tail.filter { |x| !x.empty? }
+        Cons[Cons[@head.head, tail.map(&:head)],
+          Cons[@head.tail, tail.map(&:tail)].transpose]
+      end
+    end
+
+    def Nil.take(n)
+      Nil
+    end
+
+    def take(n)
+      if n <= 0
+        Nil
+      else
+        Cons[@head, @tail.take(n - 1)]
+      end
+    end
+
+    def Nil.take_while
+      Nil
+    end
+
+    def take_while(&block)
+      if yield(@head)
+        Cons[@head, @tail.take_while(&block)]
+      else
+        Nil
+      end
+    end
+
+    def Nil.drop(n)
+      Nil
+    end
+
+    def drop(n)
+      if n > 0
+        @tail.drop(n - 1)
+      else
+        self
+      end
+    end
+
+    def Nil.drop_while
+      Nil
+    end
+
+    def drop_while(&block)
+      if yield(@head)
+        @tail.drop_while(&block)
+      else
+        self
+      end
+    end
+
+    def Nil.find
+      nil
+    end
+
+    def find(&block)
+      if yield(@head)
+        @head
+      else
+        @tail.find(&block)
+      end
+    end
+  end
+end

data/lib/immutable/map.rb

@@ -0,0 +1,385 @@
+# -*- tailcall-optimization: true; trace-instruction: false -*-
+# ported from http://www.cs.kent.ac.uk/people/staff/smk/redblack/Untyped.hs
+
+module Immutable
+  # <code>Immutable::Map</code> represents an immutable map from keys to
+  # values.
+  #
+  # <code>Immutable::Map</code> is an abstract class and
+  # <code>Immutable::Map.[]</code> should be used instead of
+  # <code>Immutable::Map.new</code>. For example:
+  #
+  #   include Immutable
+  #   p Map[]            #=> Map[]
+  #   p Map[a: 1, b: 2]  #=> Map[:a => 1, :b => 2]
+  #
+  # <code>Immutable::Map#insert</code> inserts a key/value pair and
+  # returns a new <code>Immutable::Map</code>. The original map never be
+  # changed by <code>Immutable::Map#insert</code>. For example:
+  #
+  #   m = Map[a: 1]
+  #   p m   #=> Map[:a => 1]
+  #   m2 = m.insert(:b, 2)
+  #   p m2  #=> Map[:a => 1, :b => 2]
+  #   p m   #=> Map[:a => 1]
+  class Map
+    class InvarianceViolationError < StandardError
+    end
+
+    # Returns an empty map.
+    def self.empty
+      Leaf
+    end
+
+    # Returns a map that has only one pair whose key is +key+ and whose
+    # value is +value+.
+    def self.singleton(key, value)
+      Leaf.insert(key, value)
+    end
+
+    # Returns a map that has the same key/value pairs as the
+    # <code>Hash</code> object +h+.
+    def self.[](h = {})
+      h.inject(Leaf) { |m, (k, v)| m.insert(k, v) }
+    end
+
+    # Inserts +key+/+value+ in +self+.
+    def insert(key, value)
+      ins(key, value).make_black
+    end
+
+    # Returns the value at +key+ in +self+, or <code>nil</code> if +key+
+    # isn't in +self+.
+    def [](key)
+      raise ScriptError, "this method should be overriden"
+    end
+
+    # Deletes +key+ and its value from +self+.
+    def delete(key)
+      m = del(key)
+      if m.empty?
+        m
+      else
+        m.make_black
+      end
+    end
+
+    def inspect
+      "Map[" + foldr_with_key("") { |k, v, s|
+        x = k.inspect + " => " + v.inspect
+        if s.empty?
+          x
+        else
+          x + ", " + s
+        end
+      } + "]"
+    end
+
+    # Folds the values in +self+ from right to left.
+    def foldr(e)
+      foldr_with_key(e) { |k, v, x| yield(v, x) }
+    end
+
+    # Folds the values in +self+ from left to right.
+    def foldl(e)
+      foldl_with_key(e) { |x, k, v| yield(x, v) }
+    end
+
+    # Maps the given block over all values in +self+.
+    def map
+      map_with_key { |k, v| yield(v) }
+    end
+
+    # Maps the given block over all keys and values in +self+.
+    def map_with_key
+      foldr_with_key(List[]) { |k, v, xs| Cons[yield(k, v), xs] }
+    end
+
+    # :nodoc:
+    Leaf = Map.new
+
+    def Leaf.empty?
+      true
+    end
+
+    def Leaf.red?
+      false
+    end
+
+    def Leaf.black?
+      true
+    end
+
+    def Leaf.[](key)
+      nil
+    end
+
+    def Leaf.ins(key, value)
+      RedFork[Leaf, key, value, Leaf]
+    end
+
+    def Leaf.del(key)
+      Leaf
+    end
+
+    def Leaf.each
+    end
+
+    class Fork < Map  #:nodoc:
+      attr_reader :left, :key, :value, :right
+
+      def initialize(left, key, value, right)
+        @left, @key, @value, @right = left, key, value, right
+      end
+
+      def self.extract(val)
+        accept_self_instance_only(val)
+        [val.left, val.key, val.value, val.right]
+      end
+
+      class << self
+        alias [] new
+      end
+
+      def empty?
+        false
+      end
+
+      def [](key)
+        if key < self.key
+          left[key]
+        elsif key > self.key
+          right[key]
+        else
+          value
+        end
+      end
+
+      def del(key)
+        if key < self.key
+          del_left(left, self.key, self.value, right, key)
+        elsif key > self.key
+          del_right(left, self.key, self.value, right, key)
+        else
+          app(left, right)
+        end
+      end
+
+      def each(&block)
+        left.each(&block)
+        yield key, value
+        right.each(&block)
+      end
+
+      def Leaf.foldr_with_key(e)
+        e
+      end
+
+      def foldr_with_key(e, &block)
+        r = @right.foldr_with_key(e, &block)
+        @left.foldr_with_key(yield(@key, @value, r), &block)
+      end
+
+      def Leaf.foldl_with_key(e)
+        e
+      end
+
+      def foldl_with_key(e, &block)
+        l = @left.foldl_with_key(e, &block)
+        @right.foldl_with_key(yield(l, @key, @value), &block)
+      end
+
+      private
+
+      def balance(left, key, value, right)
+        # balance (T R a x b) y (T R c z d) = T R (T B a x b) y (T B c z d)
+        if left.red? && right.red?
+          RedFork[left.make_black, key, value, right.make_black]
+        # balance (T R (T R a x b) y c) z d = T R (T B a x b) y (T B c z d)
+        elsif left.red? && left.left.red?
+          RedFork[
+            left.left.make_black, left.key, left.value,
+            BlackFork[left.right, key, value, right]
+          ]
+        # balance (T R a x (T R b y c)) z d = T R (T B a x b) y (T B c z d)
+        elsif left.red? && left.right.red?
+          RedFork[
+            BlackFork[left.left, left.key, left.value, left.right.left],
+            left.right.key, left.right.value,
+            BlackFork[left.right.right, key, value, right]
+          ]
+        # balance a x (T R b y (T R c z d)) = T R (T B a x b) y (T B c z d)
+        elsif right.red? && right.right.red?
+          RedFork[
+            BlackFork[left, key, value, right.left],
+            right.key, right.value, right.right.make_black
+          ]
+        # balance a x (T R (T R b y c) z d) = T R (T B a x b) y (T B c z d)
+        elsif right.red? && right.left.red?
+          RedFork[
+            BlackFork[left, key, value, right.left.left],
+            right.left.key, right.left.value,
+            BlackFork[right.left.right, right.key, right.value, right.right]
+          ]
+        # balance a x b = T B a x b
+        else
+          BlackFork[left, key, value, right]
+        end
+      end
+
+      def del_left(left, key, value, right, del_key)
+        if left.black?
+          bal_left(left.del(del_key), key, value, right)
+        else
+          RedFork[left.del(del_key), key, value, right]
+        end
+      end
+
+      def del_right(left, key, value, right, del_key)
+        if right.black?
+          bal_right(left, key, value, right.del(del_key))
+        else
+          RedFork[left, key, value, right.del(del_key)]
+        end
+      end
+
+      def bal_left(left, key, value, right)
+        if left.red?
+          RedFork[left.make_black, key, value, right]
+        elsif right.black?
+          balance(left, key, value, right.make_red)
+        elsif right.red? && right.left.black?
+          RedFork[
+            BlackFork[left, key, value, right.left.left],
+            right.left.key, right.left.value,
+            balance(right.left.right, right.key, right.value,
+                    sub1(right.right))
+          ]
+        else
+          raise ScriptError, "should not reach here"
+        end
+      end
+
+      def bal_right(left, key, value, right)
+        if right.red?
+          RedFork[left, key, value, right.make_black]
+        elsif left.black?
+          balance(left.make_red, key, value, right)
+        elsif left.red? && left.right.black?
+          RedFork[
+            balance(sub1(left.left), left.key, left.value, left.right.left),
+            left.right.key, left.right.value,
+            BlackFork[left.right.right, key, value, right]
+          ]
+        else
+          raise ScriptError, "should not reach here"
+        end
+      end
+
+      def sub1(node)
+        if node.black?
+          node.make_red
+        else
+          raise InvarianceViolationError, "invariance violation"
+        end
+      end
+
+      def app(left, right)
+        if left.empty?
+          right
+        elsif right.empty?
+          left
+        elsif left.red? && right.red?
+          m = app(left.right, right.left)
+          if m.red?
+            RedFork[
+              RedFork[left.left, left.key, left.value, m.left],
+              m.key, m.value,
+              RedFork[m.right, right.key, right.value, right.right]
+            ]
+          else
+            RedFork[
+              left.left, left.key, left.value,
+              RedFork[m, right.key, right.value, right.right]
+            ]
+          end
+        elsif left.black? && right.black?
+          m = app(left.right, right.left)
+          if m.red?
+            RedFork[
+              BlackFork[left.left, left.key, left.value, m.left],
+              m.key, m.value,
+              BlackFork[m.right, right.key, right.value, right.right]
+            ]
+          else
+            bal_left(left.left, left.key, left.value,
+                     BlackFork[m, right.key, right.value, right.right])
+          end
+        elsif right.red?
+          RedFork[app(left, right.left), right.key, right.value,
+            right.right]
+        elsif left.red?
+          RedFork[left.left, left.key, left.value, app(left.right, right)]
+        else
+          raise ScriptError, "should not reach here"
+        end
+      end
+    end
+
+    class RedFork < Fork  #:nodoc:
+      def red?
+        true
+      end
+
+      def black?
+        false
+      end
+
+      def make_red
+        self
+      end
+
+      def make_black
+        BlackFork[left, key, value, right]
+      end
+
+      def ins(key, value)
+        if key < self.key
+          RedFork[left.ins(key, value), self.key, self.value, right]
+        elsif key > self.key
+          RedFork[left, self.key, self.value, right.ins(key, value)]
+        else
+          RedFork[left, key, value, right]
+        end
+      end
+    end
+
+    class BlackFork < Fork  #:nodoc:
+      def red?
+        false
+      end
+
+      def black?
+        true
+      end
+
+      def make_red
+        RedFork[left, key, value, right]
+      end
+
+      def make_black
+        self
+      end
+
+      def ins(key, value)
+        if key < self.key
+          balance(left.ins(key, value), self.key, self.value, right)
+        elsif key > self.key
+          balance(left, self.key, self.value, right.ins(key, value))
+        else
+          BlackFork[left, key, value, right]
+        end
+      end
+    end
+  end
+end

data/test/immutable/test_list.rb

@@ -0,0 +1,255 @@
+require "test/unit"
+require "immutable/list"
+
+module Immutable
+  class TestList < Test::Unit::TestCase
+    def test_s_from_array
+      assert_equal(List[], List.from_array([]))
+      assert_equal(List[1, 2, 3], List.from_array([1, 2, 3]))
+    end
+
+    def test_s_from_enum
+      assert_equal(List[], List.from_enum([]))
+      assert_equal(List[1, 2, 3], List.from_enum(1..3))
+      assert_equal(List["a", "b", "c"], List.from_enum("abc".chars))
+    end
+
+    def test_head
+      assert_raise(List::EmptyError) do
+        List[].head
+      end
+      assert_equal(1, List[1].head)
+      assert_equal(1, List[1, 2, 3].head)
+    end
+
+    def test_last
+      assert_raise(List::EmptyError) do
+        List[].last
+      end
+      assert_equal(1, List[1].last)
+      assert_equal(3, List[1, 2, 3].last)
+    end
+
+    def test_tail
+      assert_raise(List::EmptyError) do
+        List[].tail
+      end
+      assert_equal(List[], List[1].tail)
+      assert_equal(List[2, 3], List[1, 2, 3].tail)
+    end
+
+    def test_init
+      assert_raise(List::EmptyError) do
+        List[].init
+      end
+      assert_equal(List[], List[1].init)
+      assert_equal(List[1, 2], List[1, 2, 3].init)
+    end
+
+    def test_empty?
+      assert(List[].empty?)
+      assert(!List[1].empty?)
+      assert(!List[1, 2, 3].empty?)
+    end
+
+    def test_foldr
+      assert_equal(0, List[].foldr(0, &:+))
+      assert_equal(123, List[].foldr(123, &:+))
+
+      assert_equal(6, List[1, 2, 3].foldr(0, &:+))
+      # 1 - (2 - (3 - 10))
+      assert_equal(-8, List[1, 2, 3].foldr(10, &:-))
+    end
+
+    def test_foldr1
+      assert_raise(List::EmptyError) do
+        List[].foldr1(&:+)
+      end
+      assert_equal(1, List[1].foldr1(&:+))
+      assert_equal(3, List[1, 2].foldr1(&:+))
+      assert_equal(6, List[1, 2, 3].foldr1(&:+))
+      assert_equal(2, List[1, 2, 3].foldr1(&:-))
+    end
+
+    def test_foldl
+      assert_equal(0, List[].foldl(0, &:+))
+      assert_equal(123, List[].foldl(123, &:+))
+
+      assert_equal(6, List[1, 2, 3].foldl(0, &:+))
+      # ((10 - 1) - 2) - 3
+      assert_equal(4, List[1, 2, 3].foldl(10, &:-))
+    end
+
+    def test_foldl1
+      assert_raise(List::EmptyError) do
+        List[].foldl1(&:+)
+      end
+      assert_equal(1, List[1].foldl1(&:+))
+      assert_equal(3, List[1, 2].foldl1(&:+))
+      assert_equal(6, List[1, 2, 3].foldl1(&:+))
+      assert_equal(-4, List[1, 2, 3].foldl1(&:-))
+    end
+
+    def test_eq
+      assert(List[] == List[])
+      assert(List[] != List[1])
+      assert(List[1] != List[])
+      assert(List[1] == List[1])
+      assert(List[1] != List[2])
+      assert(List["foo"] == List["foo"])
+      assert(List["foo"] != List["bar"])
+      assert(List[1, 2, 3] == List[1, 2, 3])
+      assert(List[1, 2, 3] != List[1, 2])
+      assert(List[1, 2, 3] != List[1, 2, 3, 4])
+      assert(List[List[1, 2], List[3, 4]] == List[List[1, 2], List[3, 4]])
+      assert(List[List[1, 2], List[3, 4]] != List[List[1, 2], List[3]])
+    end
+
+    def test_inspect
+      assert_equal('List[]', List[].inspect)
+      assert_equal('List[1]', List[1].inspect)
+      assert_equal('List["foo"]', List["foo"].inspect)
+      assert_equal('List[1, 2, 3]', List[1, 2, 3].inspect)
+      assert_equal('List[List[1, 2], List[3, 4]]',
+                   List[List[1, 2], List[3, 4]].inspect)
+    end
+
+    def test_length
+      assert_equal(0, List[].length)
+      assert_equal(1, List[1].length)
+      assert_equal(3, List[1, 2, 3].length)
+      assert_equal(100, List[*(1..100)].length)
+    end
+
+    def test_plus
+      assert_equal(List[], List[] + List[])
+      assert_equal(List[1, 2, 3], List[] + List[1, 2, 3])
+      assert_equal(List[1, 2, 3], List[1, 2, 3] + List[])
+      assert_equal(List[1, 2, 3], List[1] + List[2, 3])
+      assert_equal(List[1, 2, 3], List[1, 2] + List[3])
+    end
+
+    def test_flatten
+      assert_equal(List[], List[].flatten)
+      assert_equal(List[1], List[List[1]].flatten)
+      assert_equal(List[List[1]], List[List[List[1]]].flatten)
+      assert_equal(List[1, 2, 3], List[List[1, 2], List[3]].flatten)
+      assert_equal(List[1, 2, 3], List[List[1], List[2], List[3]].flatten)
+    end
+
+    def test_map
+      assert_equal(List[], List[].map(&:to_s))
+      assert_equal(List["1", "2", "3"], List[1, 2, 3].map(&:to_s))
+    end
+
+    def test_flat_map
+      assert_equal(List[], List[].flat_map {})
+      assert_equal(List["1", "2", "3"], List[1, 2, 3].map(&:to_s))
+    end
+
+    def test_find
+      assert_equal(nil, List[].find(&:odd?))
+      assert_equal(1, List[1, 2, 3, 4, 5].find(&:odd?))
+      assert_equal(2, List[1, 2, 3, 4, 5].find(&:even?))
+    end
+
+    def test_filter
+      assert_equal(List[], List[].filter(&:odd?))
+      assert_equal(List[1, 3, 5], List[1, 2, 3, 4, 5].filter(&:odd?))
+      assert_equal(List[2, 4], List[1, 2, 3, 4, 5].filter(&:even?))
+    end
+
+    def test_take
+      assert_equal(List[], List[].take(1))
+      assert_equal(List[], List[1, 2, 3].take(0))
+      assert_equal(List[], List[1, 2, 3].take(-1))
+      assert_equal(List[1], List[1, 2, 3].take(1))
+      assert_equal(List[1, 2], List[1, 2, 3].take(2))
+      assert_equal(List[1, 2, 3], List[1, 2, 3].take(3))
+      assert_equal(List[1, 2, 3], List[1, 2, 3].take(4))
+    end
+
+    def test_take_while
+      assert_equal(List[], List[].take_while { true })
+      assert_equal(List[], List[1, 2, 3].take_while { |x| x < 1 })
+      assert_equal(List[1], List[1, 2, 3].take_while { |x| x < 2 })
+      assert_equal(List[1, 2], List[1, 2, 3].take_while { |x| x < 3 })
+      assert_equal(List[1, 2, 3], List[1, 2, 3].take_while { |x| x < 4 })
+    end
+
+    def test_drop
+      assert_equal(List[], List[].drop(1))
+      assert_equal(List[1, 2, 3], List[1, 2, 3].drop(0))
+      assert_equal(List[1, 2, 3], List[1, 2, 3].drop(-1))
+      assert_equal(List[2, 3], List[1, 2, 3].drop(1))
+      assert_equal(List[3], List[1, 2, 3].drop(2))
+      assert_equal(List[], List[1, 2, 3].drop(3))
+      assert_equal(List[], List[1, 2, 3].drop(4))
+    end
+
+    def test_drop_while
+      assert_equal(List[], List[].drop_while { false })
+      assert_equal(List[1, 2, 3], List[1, 2, 3].drop_while { |x| x < 1 })
+      assert_equal(List[2, 3], List[1, 2, 3].drop_while { |x| x < 2 })
+      assert_equal(List[3], List[1, 2, 3].drop_while { |x| x < 3 })
+      assert_equal(List[], List[1, 2, 3].drop_while { |x| x < 4 })
+    end
+
+    def test_reverse
+      assert_equal(List[], List[].reverse)
+      assert_equal(List[1], List[1].reverse)
+      assert_equal(List[2, 1], List[1, 2].reverse)
+      assert_equal(List[3, 2, 1], List[1, 2, 3].reverse)
+    end
+
+    def test_intersperse
+      assert_equal(List[], List[].intersperse(0))
+      assert_equal(List[1], List[1].intersperse(0))
+      assert_equal(List[1, 0, 2], List[1, 2].intersperse(0))
+      assert_equal(List[1, 0, 2, 0, 3], List[1, 2, 3].intersperse(0))
+    end
+
+    def test_intercalate
+      assert_equal(List[], List[].intercalate(List[0]))
+      assert_equal(List[1], List[List[1]].intercalate(List[0]))
+      xs = List[List[1, 2], List[3, 4], List[5, 6]].intercalate(List[0])
+      assert_equal(List[1, 2, 0, 3, 4, 0, 5, 6], xs)
+    end
+
+    def test_transpose
+      assert_equal(List[], List[].transpose)
+      assert_equal(List[], List[List[]].transpose)
+      assert_equal(List[List[1], List[2]], List[List[1, 2]].transpose)
+      assert_equal(List[List[1, 4], List[2, 5], List[3, 6]],
+                   List[List[1, 2, 3], List[4, 5, 6]].transpose)
+      assert_equal(List[List[1, 4], List[2, 5], List[3]],
+                   List[List[1, 2, 3], List[4, 5]].transpose)
+    end
+
+    def test_sum
+      assert_equal(0, List[].sum)
+      assert_equal(1, List[1].sum)
+      assert_equal(10, List[1, 2, 3, 4].sum)
+    end
+
+    def test_product
+      assert_equal(1, List[].product)
+      assert_equal(1, List[1].product)
+      assert_equal(24, List[1, 2, 3, 4].product)
+    end
+
+    def test_s_unfoldr
+      xs = List.unfoldr(3) { |x| x == 0 ? nil : [x, x - 1] }
+      assert_equal(List[3, 2, 1], xs)
+      xs = List.unfoldr("foo,bar,baz") { |x|
+        if x.empty?
+          nil
+        else
+          y = x.slice(/([^,]*),?/, 1)
+          [y, $']
+        end
+      }
+      assert_equal(List["foo", "bar", "baz"], xs)
+    end
+  end
+end

data/test/immutable/test_map.rb

@@ -0,0 +1,113 @@
+require "test/unit"
+require "immutable/map"
+
+module Immutable
+  class TestMap < Test::Unit::TestCase
+    def test_empty?
+      assert(Map[].empty?)
+      assert(!Map[a: 1].empty?)
+      assert(!Map[a: 1, b: 2].empty?)
+    end
+
+    def test_inspect
+      assert_equal("Map[]", Map.empty.inspect)
+      assert_equal("Map[:a => 1, :b => 2]", Map[a: 1, b: 2].inspect)
+    end
+
+    def test_insert
+      5.times do
+        map = (1..100).to_a.shuffle.inject(Map.empty) { |m, k|
+          m.insert(k, k.to_s)
+        }
+        for i in 1..100
+          assert_equal(i.to_s, map[i])
+        end
+      end
+    end
+
+    def test_delete
+      5.times do
+        keys = (1..100).to_a.shuffle
+        map = keys.inject(Map.empty) { |m, k|
+          m.insert(k, k.to_s)
+        }
+        keys.shuffle!
+        deleted_keys = keys.shift(20)
+        map2 = deleted_keys.inject(map) { |m, k|
+          m.delete(k)
+        }
+        for i in 1..100
+          assert_equal(i.to_s, map[i])
+        end
+        keys.each do |k|
+          assert_equal(k.to_s, map2[k])
+        end
+        deleted_keys.each do |k|
+          assert_equal(nil, map2[k])
+        end
+      end
+    end
+
+    def test_foldr
+      xs = Map[].foldr(List[]) { |v, ys| Cons[v, ys] }
+      assert_equal(List[], xs)
+
+      xs = Map[a: 1, c: 3, b: 2].foldr(List[]) { |v, ys| Cons[v, ys] }
+      assert_equal(List[1, 2, 3], xs)
+    end
+
+    def test_foldl
+      xs = Map[].foldl(List[]) { |ys, v| Cons[v, ys] }
+      assert_equal(List[], xs)
+
+      xs = Map[a: 1, c: 3, b: 2].foldl(List[]) { |ys, v| Cons[v, ys] }
+      assert_equal(List[3, 2, 1], xs)
+    end
+
+    def test_foldl_with_key
+      xs = Map[].foldl_with_key(List[]) { |ys, k, v| Cons[[k, v], ys] }
+      assert_equal(List[], xs)
+
+      xs = Map[a: 1, c: 3, b: 2].foldl_with_key(List[]) { |ys, k, v|
+        Cons[[k, v], ys]
+      }
+      assert_equal(List[[:c, 3], [:b, 2], [:a, 1]], xs)
+    end
+
+    def test_foldr_with_key
+      xs = Map[].foldr_with_key(List[]) { |k, v, ys| Cons[[k, v], ys] }
+      assert_equal(List[], xs)
+
+      xs = Map[a: 1, c: 3, b: 2].foldr_with_key(List[]) { |k, v, ys|
+        Cons[[k, v], ys]
+      }
+      assert_equal(List[[:a, 1], [:b, 2], [:c, 3]], xs)
+    end
+
+    def test_foldl_with_key
+      xs = Map[].foldl_with_key(List[]) { |ys, k, v| Cons[[k, v], ys] }
+      assert_equal(List[], xs)
+
+      xs = Map[a: 1, c: 3, b: 2].foldl_with_key(List[]) { |ys, k, v|
+        Cons[[k, v], ys]
+      }
+      assert_equal(List[[:c, 3], [:b, 2], [:a, 1]], xs)
+    end
+
+    def test_map
+      xs = Map[].map { |v| v.to_s }
+      assert_equal(List[], xs)
+
+      xs = Map[a: 1, c: 3, b: 2].map { |v| v.to_s }
+      assert_equal(List["1", "2", "3"], xs)
+    end
+
+    def test_map_with_key
+      xs = Map[].map_with_key { |k, v| [k, v].join(":") }
+      assert_equal(List[], xs)
+
+      xs = Map[a: 1, c: 3, b: 2].map_with_key { |k, v| [k, v].join(":") }
+      assert_equal(List["a:1", "b:2", "c:3"], xs)
+    end
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: immutable
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+  - Shugo Maeda
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-09 00:00:00 Z
+dependencies: []
+
+description: 
+email: shugo@ruby-lang.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - lib/immutable/map.rb
+  - lib/immutable/list.rb
+  - benchmark/benchmark_map.rb
+  - test/immutable/test_list.rb
+  - test/immutable/test_map.rb
+  - README.md
+homepage: http://github.com/shugo/immutable
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Immutable data structures for Ruby
+test_files: []
+