hamster 1.0.1.pre.rc2 → 1.0.1.pre.rc3

data/lib/hamster/core_ext/enumerator.rb

@@ -1,16 +0,0 @@
-require "hamster/list"
-
-module Hamster
-  module CoreExt
-    module Enumerator
-      # @deprecated Please use Hamster#enumerate instead
-      def to_list
-        Hamster.enumerate(self)
-      end
-    end
-  end
-end
-
-class Enumerator
-  include Hamster::CoreExt::Enumerator
-end

data/lib/hamster/experimental/mutable_stack.rb

@@ -1,30 +0,0 @@
-require "forwardable"
-require "hamster/stack"
-require "hamster/read_copy_update"
-
-module Hamster
-  def self.mutable_stack(*items)
-    MutableStack.new(stack(*items))
-  end
-
-  class MutableStack
-    extend Forwardable
-    include ReadCopyUpdate
-
-    def push(item)
-      transform { |stack| stack.push(item) }
-    end
-    def_delegator :self, :push, :<<
-    def_delegator :self, :push, :enqueue
-
-    def pop
-      top = nil
-      transform do |stack|
-        top = stack.peek
-        stack.pop
-      end
-      top
-    end
-    def_delegator :self, :pop, :dequeue
-  end
-end

data/lib/hamster/groupable.rb

@@ -1,12 +0,0 @@
-module Hamster
-  module Groupable
-    def group_by_with(empty_group, &block)
-      return group_by { |item| item } unless block_given?
-      reduce(EmptyHash) do |hash, item|
-        key = yield(item)
-        group = hash.get(key) || empty_group
-        hash.put(key, group.conj(item))
-      end
-    end
-  end
-end

data/lib/hamster/queue.rb

@@ -1,86 +0,0 @@
-require "forwardable"
-require "hamster/immutable"
-require "hamster/list"
-
-module Hamster
-  def self.queue(*items)
-    items.reduce(EmptyQueue) { |queue, item| queue.enqueue(item) }
-  end
-
-  class Queue
-    extend Forwardable
-    include Immutable
-
-    def initialize
-      @front = @rear = EmptyList
-    end
-
-    def empty?
-      @front.empty? && @rear.empty?
-    end
-    def_delegator :self, :empty?, :null?
-
-    def size
-      @front.size + @rear.size
-    end
-    def_delegator :self, :size, :length
-
-    def head
-      return @front.head unless @front.empty?
-      @rear.last
-    end
-    def_delegator :self, :head, :first
-    def_delegator :self, :head, :peek
-    def_delegator :self, :head, :front
-
-    def enqueue(item)
-      transform { @rear = @rear.cons(item) }
-    end
-    def_delegator :self, :enqueue, :<<
-    def_delegator :self, :enqueue, :add
-    def_delegator :self, :enqueue, :conj
-    def_delegator :self, :enqueue, :conjoin
-
-    def dequeue
-      front = @front
-      rear = @rear
-      if front.empty?
-        return EmptyQueue if rear.empty?
-        front = rear.reverse
-        rear = EmptyList
-      end
-
-      transform do
-        @front = front.tail
-        @rear = rear
-      end
-    end
-    def_delegator :self, :dequeue, :tail
-
-    def clear
-      EmptyQueue
-    end
-
-    def eql?(other)
-      instance_of?(other.class) &&
-        to_list.eql?(other.to_list)
-    end
-    def_delegator :self, :eql?, :==
-
-    def to_a
-      @front.to_a.concat(@rear.to_a.tap { |a| a.reverse! })
-    end
-    def_delegator :self, :to_a, :entries
-    def_delegator :self, :to_a, :to_ary
-
-    def to_list
-      @front.append(@rear.reverse)
-    end
-
-    def inspect
-      to_a.inspect
-    end
-  end
-
-  EmptyQueue = Hamster::Queue.new
-end

data/lib/hamster/sorter.rb

@@ -1,25 +0,0 @@
-require "forwardable"
-require "hamster/immutable"
-require "hamster/core_ext/enumerator"
-
-module Hamster
-  class Sorter
-    include ::Enumerable
-    extend Forwardable
-    include Immutable
-
-    def initialize(collection)
-      @collection = collection
-    end
-
-    def_delegator :@collection, :each
-
-    def sort(&comparator)
-      super.to_enum.to_list
-    end
-
-    def sort_by(&transformer)
-      super.to_enum.to_list
-    end
-  end
-end

data/lib/hamster/stack.rb

@@ -1,77 +0,0 @@
-require "forwardable"
-require "hamster/immutable"
-require "hamster/list"
-
-module Hamster
-  def self.stack(*items)
-    items.reduce(EmptyStack) { |stack, item| stack.push(item) }
-  end
-
-  class Stack
-    extend Forwardable
-    include Immutable
-
-    attr_reader :list
-    def_delegator :self, :list, :to_list
-
-    def initialize
-      @list = EmptyList
-    end
-
-    def empty?
-      @list.empty?
-    end
-
-    def size
-      @list.size
-    end
-    def_delegator :self, :size, :length
-
-    def peek
-      @list.head
-    end
-    def_delegator :self, :peek, :top
-
-    def push(item)
-      transform { @list = @list.cons(item) }
-    end
-    def_delegator :self, :push, :<<
-    def_delegator :self, :push, :enqueue
-    def_delegator :self, :push, :conj
-    def_delegator :self, :push, :conjoin
-
-    def pop
-      list = @list.tail
-      if list.empty?
-        EmptyStack
-      else
-        transform { @list = list }
-      end
-    end
-    def_delegator :self, :pop, :dequeue
-
-    def clear
-      EmptyStack
-    end
-
-    def eql?(other)
-      instance_of?(other.class) && @list.eql?(other.instance_variable_get(:@list))
-    end
-    def_delegator :self, :eql?, :==
-
-    def to_a
-      @list.to_a
-    end
-    def_delegator :self, :to_a, :entries
-
-    def to_ary
-      @list.to_ary
-    end
-
-    def inspect
-      @list.inspect
-    end
-  end
-
-  EmptyStack = Hamster::Stack.new
-end

data/lib/hamster/tuple.rb

@@ -1,24 +0,0 @@
-require "hamster/immutable"
-
-module Hamster
-  def self.tuple(*items)
-    Hamster::Tuple.new(*items)
-  end
-  class Tuple < Array
-    include Immutable
-
-    def initialize(*items)
-      super(items)
-    end
-
-    def eql?(other)
-      other.is_a?(Tuple) && super
-    end
-
-    def inspect
-      "(#{super[1..-2]})"
-    end
-
-    undef :<<, :[]=, :collect!, :compact!, :delete, :delete_at, :delete_if, :flatten!, :map!, :reject!, :reverse!, :rotate!, :select!, :shuffle!, :slice!, :sort!, :sort_by!, :uniq!
-  end
-end

data/spec/hamster/core_ext/enumerator_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-require "hamster/core_ext/enumerator"
-
-describe Enumerator do
-  let(:enumerator) { %w[A B C].to_enum }
-
-  describe "#to_list" do
-    let(:to_list) { enumerator.to_list }
-
-    it "returns an equivalent list" do
-      expect(to_list).to eq(Hamster.list("A", "B", "C"))
-    end
-
-    it "is lazy" do
-      expect(to_list.head).to eq("A")
-      expect(enumerator.next).to eq("B")
-    end
-  end
-end

data/spec/hamster/experimental/mutable_stack/pop_spec.rb

@@ -1,35 +0,0 @@
-require "spec_helper"
-require "hamster/experimental/mutable_stack"
-
-describe Hamster::MutableStack do
-  let(:mutable_stack) { Hamster.mutable_stack(*values) }
-
-  describe "#pop" do
-    let(:pop) { mutable_stack.pop }
-
-    context "with values" do
-      let(:values) { %w[A B C] }
-      it "returns the last value" do
-        expect(pop).to eq("C")
-      end
-
-      it "modifies the original collection" do
-        pop
-        expect(mutable_stack).to eq(Hamster.mutable_stack("A", "B"))
-      end
-    end
-
-    context "without values" do
-      let(:values) { [] }
-
-      it "returns nil" do
-        expect(pop).to be(nil)
-      end
-
-      it "doesn't change the original stack" do
-        pop
-        expect(mutable_stack).to eq(Hamster.mutable_stack(*values))
-      end
-    end
-  end
-end

data/spec/hamster/experimental/mutable_stack/push_spec.rb

@@ -1,21 +0,0 @@
-require "spec_helper"
-require "hamster/experimental/mutable_stack"
-
-describe Hamster::MutableStack do
-  let(:mutable_stack) { Hamster.mutable_stack(*values) }
-
-  describe "#push" do
-    let(:values) { %w[A B C] }
-    let(:value) { "Z" }
-    let(:push) { mutable_stack.push(value) }
-
-    it "returns the stack" do
-      expect(push).to eq(mutable_stack)
-    end
-
-    it "modifies the stack to include the new value" do
-      push
-      expect(mutable_stack).to eq(Hamster.mutable_stack("A", "B", "C", "Z"))
-    end
-  end
-end

data/spec/hamster/hash/any_spec.rb

@@ -1,52 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  [:any?, :exist?, :exists?].each do |method|
-    describe "##{method}" do
-      describe "when empty" do
-        before do
-          @hash = Hamster.hash
-        end
-
-        it "with a block returns false" do
-          @hash.send(method) {}.should == false
-        end
-
-        it "with no block returns false" do
-          @hash.send(method).should == false
-        end
-      end
-
-      describe "when not empty" do
-        before do
-          @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL")
-        end
-
-        describe "with a block" do
-          [
-            %w[A aye],
-            %w[B bee],
-            %w[C see],
-            [nil, "NIL"],
-          ].each do |pair|
-
-            it "returns true if the block ever returns true (#{pair.inspect})" do
-              @hash.send(method) { |key, value| key == pair.first && value == pair.last }.should == true
-            end
-
-            it "returns false if the block always returns false" do
-              @hash.send(method) { |key, value| key == "D" && value == "dee" }.should == false
-            end
-          end
-        end
-
-        describe "with no block" do
-          it "returns true" do
-            @hash.send(method).should == true
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hamster/hash/clear_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  describe "#clear" do
-
-    [
-      [],
-      ["A" => "aye"],
-      ["A" => "aye", "B" => "bee", "C" => "see"],
-    ].each do |values|
-
-      describe "on #{values}" do
-        before do
-          @original = Hamster.hash(*values)
-          @result = @original.clear
-        end
-
-        it "preserves the original" do
-          @original.should == Hamster.hash(*values)
-        end
-
-        it "returns an empty hash" do
-          @result.should equal(Hamster.hash)
-        end
-      end
-    end
-  end
-end

data/spec/hamster/hash/construction_spec.rb

@@ -1,27 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  describe ".hash" do
-    describe "with nothing" do
-      before do
-        @hash = Hamster.hash
-      end
-
-      it "returns the canonical empty hash" do
-        @hash.should be_empty
-        @hash.should equal(Hamster::EmptyHash)
-      end
-    end
-
-    describe "with an implicit hash" do
-      before do
-        @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      end
-
-      it "is equivalent to repeatedly using #put" do
-        @hash.should == Hamster.hash.put("A", "aye").put("B", "bee").put("C", "see")
-      end
-    end
-  end
-end