immutable 0.3.1 → 0.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b88830d271351b2eb0b7580fc69e71beb7233165
+  data.tar.gz: ea7083277f60f1c54ae3bb41d9661f7d78186050
+SHA512:
+  metadata.gz: c407518f109f1fc47c2ee3ce6370e762a2207516007117f15877d8038d2ef8fdcb3c9dff0afd53f89271ba640a6ed738c064ccce62b30d75fa073041bef379b1
+  data.tar.gz: c082da1cddcbdb9a72161f9f7750df331f7794953feca638b7ed928ba3617d20a8eec5dba837dc6d6efaa0074ee5ced23c6d8e3937c392c283189e6e18d18376

data/README.md

@@ -3,18 +3,22 @@ immutable - immutable data structures for Ruby
 
 This project aims to provide immutable data structures for Ruby.
 
+[![Build Status](https://secure.travis-ci.org/shugo/immutable.png)](http://travis-ci.org/shugo/immutable)
+
 Install
-========================
+-------
 
-	$ gem install immutable
+```bash
+$ gem install immutable
+```
 
 Documentation
-========================
+-------------
 
 * [API Reference](http://rubydoc.info/github/shugo/immutable/frames)
 
 License
-========================
+-------
 
 (The MIT License)
 

data/lib/immutable.rb

@@ -2,11 +2,13 @@
 module Immutable
 end
 
-old_compile_option = RubyVM::InstructionSequence.compile_option
-RubyVM::InstructionSequence.compile_option = {
-  :tailcall_optimization => true,
-  :trace_instruction => false
-}
+if defined?(RubyVM)
+  old_compile_option = RubyVM::InstructionSequence.compile_option
+  RubyVM::InstructionSequence.compile_option = {
+    :tailcall_optimization => true,
+    :trace_instruction => false
+  }
+end
 begin
   require_relative "immutable/list"
   require_relative "immutable/map"
@@ -16,5 +18,7 @@ begin
   require_relative "immutable/output_restricted_deque"
   require_relative "immutable/deque"
 ensure
-  RubyVM::InstructionSequence.compile_option = old_compile_option
+  if defined?(RubyVM)
+    RubyVM::InstructionSequence.compile_option = old_compile_option
+  end
 end

data/lib/immutable/consable.rb

@@ -180,7 +180,7 @@ module Immutable
     #
     # @return [Consable] the concatenated +Consable+ object.
     def flatten
-      foldr(empty) { |x, xs| x + xs }
+      foldr(empty) { |x, xs| safe_append(x, xs) }
     end
 
     alias concat flatten
@@ -190,7 +190,7 @@ module Immutable
     #
     # @return [Consable] the obtained +Consable+ object.
     def flat_map
-      foldr(empty) { |x, xs| yield(x) + xs }
+      foldr(empty) { |x, xs| safe_append(yield(x), xs) }
     end
 
     alias concat_map flat_map
@@ -340,5 +340,11 @@ module Immutable
     def Cons(x, y)
       y.cons(x)
     end
+
+    def safe_append(xs, ys)
+      xs.foldr(ys) { |z, zs| Cons(z, zs) }
+    rescue NoMethodError
+      Cons(xs, ys)
+    end
   end
 end

data/lib/immutable/foldable.rb

@@ -26,14 +26,14 @@ module Immutable
     #
     # @return [#+] the sum of the numbers.
     def sum
-      foldl(0, &:+)
+      foldl(0) { |x, y| x + y }
     end
 
     # Computes the product of the numbers in +self+.
     #
     # @return [#*] the product of the numbers.
     def product
-      foldl(1, &:*)
+      foldl(1) { |x, y| x * y }
     end
   end
 end

data/lib/immutable/headable.rb

@@ -70,6 +70,8 @@ module Immutable
       end
     end
 
+    alias to_s inspect
+
     # Returns whether +self+ equals to +x+.
     #
     # @param [Object] x the object to compare.
@@ -119,10 +121,21 @@ module Immutable
       self
     end
 
+    # Calls +block+ once for each index in +self+.
+    # @yield [index]
+    # @yieldparam [Integer] index
+    # @yieldreturn [self]
+    # @return [Enumerator]
+    def each_index
+      return to_enum(__callee__) unless block_given?
+  
+      each_with_index{ |_, idx| yield(idx) }
+    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
+    #   List[1, 2, 3].foldr(9) { |x, y| x - y } #=> 1 - (2 - (3 - 9)) = -7
     #
     # @param [Object] e the start value.
     # @return [Object] the reduced value.
@@ -153,7 +166,7 @@ module Immutable
     # 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
+    #   List[1, 2, 3].foldl(9) { |x, y| x - y } #=> ((9 - 1) - 2) - 3 = 3
     #
     # @param [Object] e the start value.
     # @return [Object] the reduced value.
@@ -208,15 +221,127 @@ module Immutable
     # Returns the +n+th element of +self+. If +n+ is out of range, +nil+ is
     # returned.
     #
+    # @param [Integer, #to_int] n
     # @return [Object] the +n+th element.
     def [](n)
-      if n < 0 || empty?
+      raise TypeError unless n.respond_to?(:to_int)
+      int = n.to_int
+
+      if int < 0 || empty?
         nil
-      elsif n == 0
+      elsif int == 0
         head
       else
-        tail[n - 1]
+        tail[int - 1]
+      end
+    end
+
+    alias at []
+
+    # Returns the +n+th element of +self+. If +n+ is out of range, +IndexError+
+    # returned.
+    #
+    # @overload fetch(n)
+    #   @param [Integer, #to_int] n
+    #   @return [Object] the +n+th element.
+    #   @raise [IndexError] if n is out of rage
+    # @overload fetch(n, ifnone)
+    #   @param [Integer, #to_int] n
+    #   @return ifnone
+    # @overload fetch(n) {|n|}
+    #   @param [Integer, #to_int] n
+    #   @yield [n]
+    #   @yieldparam [Integer, #to_int] n
+    def fetch(*args)
+      alen = args.length
+      n, ifnone = *args
+      
+      unless (1..2).cover?(alen)
+        raise ArgumentError, "wrong number of arguments (#{alen} for 1..2)"
       end
+
+      raise TypeError unless n.respond_to?(:to_int)
+      int = n.to_int
+
+      return at(int) if int >= 0 && int < length
+
+      if block_given?
+        if alen == 2
+          warn "#{__LINE__}:warning: block supersedes default value argument"
+        end
+
+        yield n
+      else
+        if alen == 2
+          ifnone
+        else
+          raise IndexError, "index #{int} outside of list bounds"
+        end
+      end
+    end
+
+    # @overload index(val)
+    #   @return [Integer, nil] index
+    # @overload index
+    #   @return [Enumerator]
+    # @overload index {}
+    #   @yieldreturn [Integer, nil] index
+    def index(*args)
+      alen = args.length
+      val = args.first
+
+      raise ArgumentError unless (0..1).cover?(alen)
+      return to_enum(__callee__) if !block_given? && alen == 0
+
+      if alen == 1
+        if block_given?
+          warn "#{__LINE__}:warning: given block not used"
+        end
+
+        each_with_index { |e, idx|
+          return idx if e == val
+        }
+      else
+        if block_given?
+          each_with_index { |e, idx|
+            return idx if yield(e)
+          }
+        end
+      end
+
+      nil
+    end
+
+    # @overload rindex(val)
+    #   @return [Integer, nil] index
+    # @overload rindex
+    #   @return [Enumerator]
+    # @overload rindex {}
+    #   @yieldreturn [Integer, nil] index
+    def rindex(*args)
+      alen = args.length
+      val = args.first
+
+      raise ArgumentError unless (0..1).cover?(alen)
+      return to_enum(__callee__) if !block_given? && alen == 0
+
+      if alen == 1
+        if block_given?
+          warn "#{__LINE__}:warning: given block not used"
+        end
+
+        reverse_each.with_index { |e, idx|
+          return length - (idx + 1) if e == val
+        }
+      else
+        if block_given?
+          reverse_each.with_index { |e, idx|
+            return length - (idx + 1) if yield(e)
+          }
+        end
+      end
+
+      nil
     end
 
     # Converts +self+ to a list.

data/lib/immutable/map.rb

@@ -66,6 +66,7 @@ module Immutable
       end
     end
 
+    # @return [String]
     def inspect
       "Map[" + foldr_with_key("") { |k, v, s|
         x = k.inspect + " => " + v.inspect
@@ -77,6 +78,8 @@ module Immutable
       } + "]"
     end
 
+    alias to_s inspect
+
     # Calls +block+ once for each key/value in +self+.
     def each(&block)
       foldl_with_key(nil) { |x, k, v| yield([k, v]) }

data/lib/immutable/stream.rb

@@ -193,6 +193,8 @@ module Immutable
       "Stream[" + inspect_i + "]"
     end
 
+    alias to_s inspect
+
     def inspect_i(s = nil)
       if eager?
         if empty?

data/test/immutable/test_list.rb

@@ -14,7 +14,7 @@ module Immutable
     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))
+      assert_equal(List["a", "b", "c"], List.from_enum("abc".each_char))
     end
 
     def test_head
@@ -76,6 +76,84 @@ module Immutable
       end
     end
 
+    def test_each_index
+      list = List[]
+      a = []
+      assert_same(list, list.each_index { |x| a << x })
+      assert_equal([], a)
+      
+      list = List[1, 2, 3]
+      a = []
+      assert_same(list, list.each_index { |x| a << x })
+      assert_equal([0, 1, 2], a)
+      
+      enum = List[1, 2, 3].each_index
+      assert_instance_of(Enumerator, enum)
+      assert_equal(0, enum.next)
+      assert_equal(1, enum.next)
+      assert_equal(2, enum.next)
+      assert_raise(StopIteration) do
+        enum.next
+      end
+    end
+
+    def test_index
+      list = List[]
+      assert_equal(nil, list.index(1))
+
+      list = List[1, 2, 1]
+      assert_equal(0, list.index(1))
+      assert_equal(1, list.index(2))
+      assert_equal(nil, list.index(3))
+
+      verbose = $VERBOSE
+      $VERBOSE = nil
+      list = List[1, 2, 1]
+      assert_equal(0, list.index(1) {|e| e * 2 == 4 })
+      assert_equal(1, list.index(2) {|e| e * 2 == 4 })
+      assert_equal(nil, list.index(3) {|e| e * 2 == 4 })
+      $VERBOSE = verbose
+
+      list = List[1, 2, 1]
+      assert_equal(0, list.index {|e| e * 2 == 2 })
+      assert_equal(1, list.index {|e| e * 2 == 4 })
+      assert_equal(nil, list.index {|e| e * 2 == 6 })
+
+      enum = List[1, 2, 1].index
+      assert_instance_of(Enumerator, enum)
+      assert_equal(0, enum.each {|v|v == 1})
+      assert_equal(1, enum.each {|v|v == 2})
+      assert_equal(nil, enum.each {|v|v == 3})
+    end
+
+    def test_rindex
+      list = List[]
+      assert_equal(nil, list.rindex(1))
+
+      list = List[1, 2, 1]
+      assert_equal(2, list.rindex(1))
+      assert_equal(1, list.rindex(2))
+      assert_equal(nil, list.rindex(3))
+
+      verbose = $VERBOSE
+      $VERBOSE = nil
+      list = List[1, 2, 1]
+      assert_equal(2, list.rindex(1) {|e| e * 2 == 4 })
+      assert_equal(1, list.rindex(2) {|e| e * 2 == 4 })
+      assert_equal(nil, list.rindex(3) {|e| e * 2 == 4 })
+      $VERBOSE = verbose
+
+      list = List[1, 2, 1]
+      assert_equal(2, list.rindex {|e| e * 2 == 2 })
+      assert_equal(1, list.rindex {|e| e * 2 == 4 })
+      assert_equal(nil, list.rindex {|e| e * 2 == 6 })
+
+      enum = List[1, 2, 1].rindex
+      assert_instance_of(Enumerator, enum)
+      assert_equal(2, enum.each {|v|v == 1})
+      assert_equal(nil, enum.each {|v|v == 3})
+    end
+
     def test_foldr
       assert_equal(0, List[].foldr(0, &:+))
       assert_equal(123, List[].foldr(123, &:+))
@@ -154,6 +232,15 @@ module Immutable
                    List[List[1, 2], List[3, 4]].inspect)
     end
 
+    def test_to_s
+      assert_equal('List[]', List[].to_s)
+      assert_equal('List[1]', List[1].to_s)
+      assert_equal('List["foo"]', List["foo"].to_s)
+      assert_equal('List[1, 2, 3]', List[1, 2, 3].to_s)
+      assert_equal('List[List[1, 2], List[3, 4]]',
+                   List[List[1, 2], List[3, 4]].to_s)
+    end
+
     def test_length
       assert_equal(0, List[].length)
       assert_equal(1, List[1].length)
@@ -184,6 +271,10 @@ module Immutable
       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)
+      assert_equal(List[1, 2, 3], List[List[1], 2, List[3]].flatten)
+      assert_equal(List[1, [2], 3], List[List[1], [2], List[3]].flatten)
+      obj = Object.new
+      assert_equal(List[obj, 'str', obj], List[obj, 'str', obj].flatten)
     end
 
     def test_map
@@ -198,7 +289,9 @@ module Immutable
 
     def test_flat_map
       assert_equal(List[], List[].flat_map {})
-      assert_equal(List["1", "2", "3"], List[1, 2, 3].map(&:to_s))
+      xs = List["foo", "bar"].flat_map {|s| List.from_enum(s.each_char)}
+      assert_equal(List["f", "o", "o", "b", "a", "r"], xs)
+      xs = List["FOO", "BAR"].flat_map {|s| s.upcase}
     end
 
     def test_find
@@ -228,6 +321,67 @@ module Immutable
       assert_equal(2, List[1, 2, 3][1])
       assert_equal(3, List[1, 2, 3][2])
       assert_equal(nil, List[1, 2, 3][3])
+      assert_equal(2, List[1, 2, 3][1.1])
+      assert_raise TypeError do
+        List[1, 2, 3]['1']
+      end
+    end
+
+    def test_at
+      assert_equal(nil, List[].at(0))
+      assert_equal(1, List[1, 2, 3].at(0))
+      assert_equal(nil, List[1, 2, 3].at(-1))
+      assert_equal(2, List[1, 2, 3].at(1))
+      assert_equal(3, List[1, 2, 3].at(2))
+      assert_equal(nil, List[1, 2, 3].at(3))
+      assert_equal(2, List[1, 2, 3].at(1.1))
+      assert_raise TypeError do
+        List[1, 2, 3].at('1')
+      end
+    end
+
+    def test_fetch
+      assert_raise ArgumentError do
+        List[].fetch
+      end
+
+      assert_raise IndexError do
+        List[].fetch(0)
+      end
+
+      assert_equal(1, List[1, 2, 3].fetch(0))
+
+      assert_raise IndexError do
+        List[1, 2, 3].fetch(-1)
+      end
+
+      assert_equal(2, List[1, 2, 3].fetch(1))
+      assert_equal(3, List[1, 2, 3].fetch(2))
+
+      assert_raise IndexError do
+        List[1, 2, 3].fetch(3)
+      end
+
+      assert_equal(2, List[1, 2, 3].fetch(1.1))
+
+      assert_raise TypeError do
+        List[1, 2, 3].fetch('1')
+      end
+
+      assert_equal(9, List[].fetch(0, 9))
+      assert_equal(2, List[1, 2, 3].fetch(1, 9))
+      assert_equal(9, List[1, 2, 3].fetch(4, 9))
+
+      assert_equal(5, List[].fetch(0) {|n| n + 5 })
+      assert_equal(2, List[1, 2, 3].fetch(1) {|n| n + 5 })
+      assert_equal(8, List[1, 2, 3].fetch(4) {|n| n * 2 })
+
+      verbose = $VERBOSE
+      $VERBOSE = nil
+      assert_equal(5, List[].fetch(0, 9) {|n| n + 5 })
+      assert_equal(2, List[1, 2, 3].fetch(1, 9) {|n| n + 5 })
+      assert_equal(8, List[1, 2, 3].fetch(4, 9) {|n| n * 2 })
+      $VERBOSE = verbose
     end
 
     def test_take

data/test/immutable/test_map.rb

@@ -18,6 +18,11 @@ module Immutable
       assert_equal("Map[:a => 1, :b => 2]", Map[a: 1, b: 2].inspect)
     end
 
+    def test_to_s
+      assert_equal("Map[]", Map.empty.to_s)
+      assert_equal("Map[:a => 1, :b => 2]", Map[a: 1, b: 2].to_s)
+    end
+
     def test_insert
       5.times do
         map = (1..100).to_a.shuffle.inject(Map.empty) { |m, k|

data/test/immutable/test_stream.rb

@@ -196,6 +196,43 @@ module Immutable
                    s.inspect)
     end
 
+    def test_to_s
+      s = Stream[]
+      assert_equal('Stream[...]', s.to_s)
+      assert_equal(nil, s[0])
+      assert_equal('Stream[]', s.to_s)
+      s = Stream[1]
+      assert_equal('Stream[...]', s.to_s)
+      assert_equal(1, s[0])
+      assert_equal('Stream[1, ...]', s.to_s)
+      assert_equal(nil, s[1])
+      assert_equal('Stream[1]', s.to_s)
+      s = Stream["foo"]
+      assert_equal("foo", s[0])
+      assert_equal('Stream["foo", ...]', s.to_s)
+      assert_equal(nil, s[1])
+      assert_equal('Stream["foo"]', s.to_s)
+      s = Stream[1, 2, 3]
+      assert_equal('Stream[...]', s.to_s)
+      assert_equal(1, s[0])
+      assert_equal('Stream[1, ...]', s.to_s)
+      assert_equal(2, s[1])
+      assert_equal('Stream[1, 2, ...]', s.to_s)
+      assert_equal(3, s[2])
+      assert_equal('Stream[1, 2, 3, ...]', s.to_s)
+      assert_equal(nil, s[3])
+      assert_equal('Stream[1, 2, 3]', s.to_s)
+      s = Stream[1, 2, 3]
+      assert_equal(2, s[1])
+      assert_equal('Stream[?, 2, ...]', s.to_s)
+      s = Stream[Stream[1, 2], Stream[3, 4]]
+      assert_equal(Stream[1, 2], s[0])
+      assert_equal(Stream[3, 4], s[1])
+      assert_equal(nil, s[2])
+      assert_equal('Stream[Stream[1, 2], Stream[3, 4]]',
+                   s.to_s)
+    end
+
     def test_length
       assert_equal(0, Stream[].length)
       assert_equal(1, Stream[1].length)

data/test/test_helper.rb

@@ -3,14 +3,18 @@ $VERBOSE = true
 require "test/unit"
 
 def with_tailcall_optimization
-  old_compile_option = RubyVM::InstructionSequence.compile_option
-  RubyVM::InstructionSequence.compile_option = {
-    :tailcall_optimization => true,
-    :trace_instruction => false
-  }
-  begin
+  if defined?(RubyVM)
+    old_compile_option = RubyVM::InstructionSequence.compile_option
+    RubyVM::InstructionSequence.compile_option = {
+      :tailcall_optimization => true,
+      :trace_instruction => false
+    }
+    begin
+      yield
+    ensure
+      RubyVM::InstructionSequence.compile_option = old_compile_option
+    end
+  else
     yield
-  ensure
-    RubyVM::InstructionSequence.compile_option = old_compile_option
   end
 end

metadata

@@ -1,76 +1,66 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: immutable
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.3.1
+version: !ruby/object:Gem::Version
+  version: 0.3.2
 platform: ruby
-authors: 
-  - Shugo Maeda
+authors:
+- Shugo Maeda
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-09-07 00:00:00 Z
+date: 2016-07-08 00:00:00.000000000 Z
 dependencies: []
-
 description: 
 email: shugo@ruby-lang.org
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-  - lib/immutable.rb
-  - lib/immutable/map.rb
-  - lib/immutable/queue.rb
-  - lib/immutable/headable.rb
-  - lib/immutable/consable.rb
-  - lib/immutable/stream.rb
-  - lib/immutable/output_restricted_deque.rb
-  - lib/immutable/foldable.rb
-  - lib/immutable/deque.rb
-  - lib/immutable/list.rb
-  - lib/immutable/promise.rb
-  - benchmark/benchmark_deque.rb
-  - benchmark/benchmark_queue.rb
-  - benchmark/benchmark_parallel_fib.rb
-  - benchmark/benchmark_map.rb
-  - test/test_helper.rb
-  - test/immutable/test_list.rb
-  - test/immutable/test_stream.rb
-  - test/immutable/test_deque.rb
-  - test/immutable/test_map.rb
-  - test/immutable/test_promise.rb
-  - test/immutable/test_queue.rb
-  - README.md
+files:
+- README.md
+- benchmark/benchmark_deque.rb
+- benchmark/benchmark_map.rb
+- benchmark/benchmark_parallel_fib.rb
+- benchmark/benchmark_queue.rb
+- lib/immutable.rb
+- lib/immutable/consable.rb
+- lib/immutable/deque.rb
+- lib/immutable/foldable.rb
+- lib/immutable/headable.rb
+- lib/immutable/list.rb
+- lib/immutable/map.rb
+- lib/immutable/output_restricted_deque.rb
+- lib/immutable/promise.rb
+- lib/immutable/queue.rb
+- lib/immutable/stream.rb
+- test/immutable/test_deque.rb
+- test/immutable/test_list.rb
+- test/immutable/test_map.rb
+- test/immutable/test_promise.rb
+- test/immutable/test_queue.rb
+- test/immutable/test_stream.rb
+- test/test_helper.rb
 homepage: http://github.com/shugo/immutable
 licenses: []
-
+metadata: {}
 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"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 2.5.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Immutable data structures for Ruby
 test_files: []
-
+has_rdoc: