immutable-ruby 0.0.1 → 0.1.0

data/lib/immutable/list.rb

@@ -1,11 +1,11 @@
-require "thread"
-require "set"
-require "concurrent/atomics"
+require 'thread'
+require 'set'
+require 'concurrent'
 
-require "immutable/undefined"
-require "immutable/enumerable"
-require "immutable/hash"
-require "immutable/set"
+require 'immutable/undefined'
+require 'immutable/enumerable'
+require 'immutable/hash'
+require 'immutable/set'
 
 module Immutable
   class << self
@@ -175,7 +175,7 @@ module Immutable
       end
       result
     end
-    alias :length :size
+    alias length size
 
     # Create a new `List` with `item` added at the front. This is a constant
     # time operation.
@@ -189,7 +189,7 @@ module Immutable
     def add(item)
       Cons.new(item, self)
     end
-    alias :cons :add
+    alias cons add
 
     # Create a new `List` with `item` added at the end. This is much less efficient
     # than adding items at the front.
@@ -235,7 +235,7 @@ module Immutable
         Cons.new(yield(head), tail.map(&block))
       end
     end
-    alias :collect :map
+    alias collect map
 
     # Return a `List` which is realized by transforming each item into a `List`,
     # and flattening the resulting lists.
@@ -268,15 +268,15 @@ module Immutable
       return enum_for(:select) unless block_given?
       LazyList.new do
         list = self
-        while true
+        loop do
           break list if list.empty?
           break Cons.new(list.head, list.tail.select(&block)) if yield(list.head)
           list = list.tail
         end
       end
     end
-    alias :find_all :select
-    alias :keep_if  :select
+    alias find_all select
+    alias keep_if  select
 
     # Return a `List` which contains all elements up to, but not including, the
     # first element for which the block returns `nil` or `false`.
@@ -380,8 +380,8 @@ module Immutable
         Cons.new(head, tail.append(other))
       end
     end
-    alias :concat :append
-    alias :+ :append
+    alias concat append
+    alias + append
 
     # Return a `List` with the same items, but in reverse order.
     #
@@ -440,7 +440,7 @@ module Immutable
     def transpose
       return EmptyList if empty?
       LazyList.new do
-        next EmptyList if any? { |list| list.empty? }
+        next EmptyList if any?(&:empty?)
         heads, tails = EmptyList, EmptyList
         reverse_each { |list| heads, tails = heads.cons(list.head), tails.cons(list.tail) }
         Cons.new(heads, tails.transpose)
@@ -477,7 +477,7 @@ module Immutable
     # @return [Vector]
     # @raise [TypeError] if count is not an integer.
     def rotate(count = 1)
-      raise TypeError, "expected Integer" if not count.is_a?(Integer)
+      raise TypeError, 'expected Integer' if not count.is_a?(Integer)
       return self if empty? || (count % size) == 0
       count = (count >= 0) ? count % size : (size - (~count % size) - 1)
       drop(count).append(take(count))
@@ -640,7 +640,7 @@ module Immutable
         Cons.new(head, tail.union(other, items.add(head)))
       end
     end
-    alias :| :union
+    alias | union
 
     # Return a `List` with all elements except the last one.
     #
@@ -742,7 +742,7 @@ module Immutable
       chunk(number).each(&block)
       self
     end
-    alias :each_slice :each_chunk
+    alias each_slice each_chunk
 
     # Return a new `List` with all nested lists recursively "flattened out",
     # that is, their elements inserted into the new `List` in the place where
@@ -776,7 +776,7 @@ module Immutable
     def group_by(&block)
       group_by_with(EmptyList, &block)
     end
-    alias :group :group_by
+    alias group group_by
 
     # Retrieve the item at `index`. Negative indices count back from the end of
     # the list (-1 is the last item). If `index` is invalid (either too high or
@@ -868,7 +868,7 @@ module Immutable
         list.take(length)
       end
     end
-    alias :[] :slice
+    alias [] slice
 
     # Return a `List` of indices of matching objects.
     #
@@ -895,7 +895,7 @@ module Immutable
       return EmptyList if empty?
       LazyList.new do
         node = self
-        while true
+        loop do
           break Cons.new(i, node.tail.indices(Undefined, i + 1, &block)) if yield(node.head)
           node = node.tail
           break EmptyList if node.empty?
@@ -1187,7 +1187,7 @@ module Immutable
     def dup
       self
     end
-    alias :clone :dup
+    alias clone dup
 
     # Return `self`.
     # @return [List]
@@ -1201,9 +1201,9 @@ module Immutable
     #
     # @return [String]
     def inspect
-      result = "Immutable::List["
+      result = 'Immutable::List['
       each_with_index { |obj, i| result << ', ' if i > 0; result << obj.inspect }
-      result << "]"
+      result << ']'
     end
 
     # Allows this `List` to be printed at the `pry` console, or using `pp` (from the
@@ -1213,7 +1213,7 @@ module Immutable
     #
     # @private
     def pretty_print(pp)
-      pp.group(1, "Immutable::List[", "]") do
+      pp.group(1, 'Immutable::List[', ']') do
         pp.breakable ''
         pp.seplist(self) { |obj| obj.pretty_print(pp) }
       end
@@ -1290,7 +1290,7 @@ module Immutable
     def size
       @size ||= super
     end
-    alias :length :size
+    alias length size
 
     def cached_size?
       @size != nil
@@ -1311,30 +1311,30 @@ module Immutable
     def initialize(&block)
       @head   = block # doubles as storage for block while yet unrealized
       @tail   = nil
-      @atomic = Concurrent::Atomic.new(0) # haven't yet run block
+      @atomic = Concurrent::Atom.new(0) # haven't yet run block
       @size   = nil
     end
 
     def head
-      realize if @atomic.get != 2
+      realize if @atomic.value != 2
       @head
     end
-    alias :first :head
+    alias first head
 
     def tail
-      realize if @atomic.get != 2
+      realize if @atomic.value != 2
       @tail
     end
 
     def empty?
-      realize if @atomic.get != 2
+      realize if @atomic.value != 2
       @size == 0
     end
 
     def size
       @size ||= super
     end
-    alias :length :size
+    alias length size
 
     def cached_size?
       @size != nil
@@ -1346,9 +1346,9 @@ module Immutable
     MUTEX = Mutex.new
 
     def realize
-      while true
+      loop do
         # try to "claim" the right to run the block which realizes target
-        if @atomic.compare_and_swap(0,1) # full memory barrier here
+        if @atomic.compare_and_set(0,1) # full memory barrier here
           begin
             list = @head.call
             if list.empty?
@@ -1357,22 +1357,22 @@ module Immutable
               @head, @tail = list.head, list.tail
             end
           rescue
-            @atomic.set(0)
+            @atomic.reset(0)
             MUTEX.synchronize { QUEUE.broadcast }
             raise
           end
-          @atomic.set(2)
+          @atomic.reset(2)
           MUTEX.synchronize { QUEUE.broadcast }
           return
         end
         # we failed to "claim" it, another thread must be running it
-        if @atomic.get == 1 # another thread is running the block
+        if @atomic.value == 1 # another thread is running the block
           MUTEX.synchronize do
             # check value of @atomic again, in case another thread already changed it
             #   *and* went past the call to QUEUE.broadcast before we got here
-            QUEUE.wait(MUTEX) if @atomic.get == 1
+            QUEUE.wait(MUTEX) if @atomic.value == 1
           end
-        elsif @atomic.get == 2 # another thread finished the block
+        elsif @atomic.value == 2 # another thread finished the block
           return
         end
       end
@@ -1392,7 +1392,7 @@ module Immutable
       realize if @head == Undefined
       @head
     end
-    alias :first :head
+    alias first head
 
     def tail
       realize if @tail == Undefined
@@ -1407,7 +1407,7 @@ module Immutable
     def size
       @size ||= super
     end
-    alias :length :size
+    alias length size
 
     def cached_size?
       @size != nil
@@ -1455,7 +1455,7 @@ module Immutable
       mutex = @mutex
       mutex && mutex.synchronize do
         return if @head != Undefined # another thread got ahead of us
-        while true
+        loop do
           if !@buffer.empty?
             @head = @buffer.shift
             @tail = Partitioned.new(@partitioner, @buffer, @mutex)
@@ -1516,7 +1516,7 @@ module Immutable
         mutex = @mutex
         mutex && mutex.synchronize do
           return if @head != Undefined # another thread got ahead of us
-          while true
+          loop do
             if !@buffer.empty?
               @head = @buffer.shift
               @tail = Left.new(@splitter, @buffer, @mutex)
@@ -1568,7 +1568,7 @@ module Immutable
       def head
         nil
       end
-      alias :first :head
+      alias first head
 
       # There are no subsequent elements, so return an empty list.
       # @return [self]
@@ -1585,11 +1585,11 @@ module Immutable
       def size
         0
       end
-      alias :length :size
+      alias length size
 
       def cached_size?
         true
       end
     end
-  end
-end.freeze
+  end.freeze
+end

data/lib/immutable/nested.rb

@@ -1,10 +1,11 @@
-require "set"
-require "immutable/hash"
-require "immutable/set"
-require "immutable/vector"
-require "immutable/sorted_set"
-require "immutable/list"
-require "immutable/deque"
+require 'set'
+require 'sorted_set'
+require 'immutable/hash'
+require 'immutable/set'
+require 'immutable/vector'
+require 'immutable/sorted_set'
+require 'immutable/list'
+require 'immutable/deque'
 
 module Immutable
   class << self
@@ -30,6 +31,8 @@ module Immutable
       when ::Array
         res = obj.map { |element| from(element) }
         Immutable::Vector.new(res)
+      when ::Struct
+        from(obj.to_h)
       when ::SortedSet
         # This clause must go before ::Set clause, since ::SortedSet is a ::Set.
         res = obj.map { |element| from(element) }

data/lib/immutable/set.rb

@@ -1,9 +1,9 @@
-require "immutable/undefined"
-require "immutable/enumerable"
-require "immutable/hash"
-require "immutable/trie"
-require "immutable/sorted_set"
-require "set"
+require 'immutable/undefined'
+require 'immutable/enumerable'
+require 'immutable/hash'
+require 'immutable/trie'
+require 'immutable/sorted_set'
+require 'set'
 
 module Immutable
 
@@ -61,7 +61,7 @@ module Immutable
       #
       # @return [Set]
       def empty
-        @empty ||= self.new
+        @empty ||= new
       end
 
       # "Raw" allocation of a new `Set`. Used internally to create a new
@@ -91,7 +91,7 @@ module Immutable
     def size
       @trie.size
     end
-    alias :length :size
+    alias length size
 
     # Return a new `Set` with `item` added. If `item` is already in the set,
     # return `self`.
@@ -105,7 +105,7 @@ module Immutable
     def add(item)
       include?(item) ? self : self.class.alloc(@trie.put(item, nil))
     end
-    alias :<< :add
+    alias << add
 
     # If `item` is not a member of this `Set`, return a new `Set` with `item` added.
     # Otherwise, return `false`.
@@ -197,8 +197,8 @@ module Immutable
       trie = @trie.select { |key, _| yield(key) }
       new_trie(trie)
     end
-    alias :find_all :select
-    alias :keep_if  :select
+    alias find_all select
+    alias keep_if  select
 
     # Call the block once for each item in this `Set`. All the values returned
     # from the block will be gathered into a new `Set`. If no block is given,
@@ -215,7 +215,7 @@ module Immutable
       return self if empty?
       self.class.new(super)
     end
-    alias :collect :map
+    alias collect map
 
     # Return `true` if the given item is present in this `Set`. More precisely,
     # return `true` if an object with the same `#hash` code, and which is also `#eql?`
@@ -230,7 +230,7 @@ module Immutable
     def include?(object)
       @trie.key?(object)
     end
-    alias :member? :include?
+    alias member? include?
 
     # Return a member of this `Set`. The member chosen will be the first one which
     # would be yielded by {#each}. If the set is empty, return `nil`.
@@ -258,7 +258,7 @@ module Immutable
     #                        equal.
     # @return [SortedSet]
     def sort(&comparator)
-      SortedSet.new(self.to_a, &comparator)
+      SortedSet.new(to_a, &comparator)
     end
 
     # Return a {SortedSet} which contains the same items as this `Set`, ordered
@@ -276,7 +276,7 @@ module Immutable
     # @yieldreturn [Object] sort key for the item
     # @return [SortedSet]
     def sort_by(&mapper)
-      SortedSet.new(self.to_a, &mapper)
+      SortedSet.new(to_a, &mapper)
     end
 
     # Return a new `Set` which contains all the members of both this `Set` and `other`.
@@ -308,9 +308,9 @@ module Immutable
       trie = large_set_trie.bulk_put(small_set_pairs)
       new_trie(trie)
     end
-    alias :| :union
-    alias :+ :union
-    alias :merge :union
+    alias | union
+    alias + union
+    alias merge union
 
     # Return a new `Set` which contains all the items which are members of both
     # this `Set` and `other`. `other` can be any `Enumerable` object.
@@ -333,7 +333,7 @@ module Immutable
       end
       new_trie(trie)
     end
-    alias :& :intersection
+    alias & intersection
 
     # Return a new `Set` with all the items in `other` removed. `other` can be
     # any `Enumerable` object.
@@ -351,8 +351,8 @@ module Immutable
       end
       new_trie(trie)
     end
-    alias :subtract :difference
-    alias :- :difference
+    alias subtract difference
+    alias - difference
 
     # Return a new `Set` which contains all the items which are members of this
     # `Set` or of `other`, but not both. `other` can be any `Enumerable` object.
@@ -365,7 +365,7 @@ module Immutable
     def exclusion(other)
       ((self | other) - (self & other))
     end
-    alias :^ :exclusion
+    alias ^ exclusion
 
     # Return `true` if all items in this `Set` are also in `other`.
     #
@@ -391,7 +391,7 @@ module Immutable
       end
       all? { |item| other.include?(item) }
     end
-    alias :<= :subset?
+    alias <= subset?
 
     # Return `true` if all items in `other` are also in this `Set`.
     #
@@ -403,7 +403,7 @@ module Immutable
     def superset?(other)
       other.subset?(self)
     end
-    alias :>= :superset?
+    alias >= superset?
 
     # Returns `true` if `other` contains all the items in this `Set`, plus at least
     # one item which is not in this set.
@@ -422,7 +422,7 @@ module Immutable
       end
       all? { |item| other.include?(item) }
     end
-    alias :< :proper_subset?
+    alias < proper_subset?
 
     # Returns `true` if this `Set` contains all the items in `other`, plus at least
     # one item which is not in `other`.
@@ -436,7 +436,7 @@ module Immutable
     def proper_superset?(other)
       other.proper_subset?(self)
     end
-    alias :> :proper_superset?
+    alias > proper_superset?
 
     # Return `true` if this `Set` and `other` do not share any items.
     #
@@ -484,8 +484,8 @@ module Immutable
       end
     end
 
-    alias :group :group_by
-    alias :classify :group_by
+    alias group group_by
+    alias classify group_by
 
     # Return a randomly chosen item from this `Set`. If the set is empty, return `nil`.
     #
@@ -519,7 +519,7 @@ module Immutable
       end
       true
     end
-    alias :== :eql?
+    alias == eql?
 
     # See `Object#hash`.
     # @return [Integer]
@@ -533,7 +533,7 @@ module Immutable
     def dup
       self
     end
-    alias :clone :dup
+    alias clone dup
 
     undef :"<=>" # Sets are not ordered, so Enumerable#<=> will give a meaningless result
     undef :each_index # Set members cannot be accessed by 'index', so #each_index is not meaningful