mll 1.2.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce709bc99f6cbd85ca763a4752346b0b5e4112cb
-  data.tar.gz: 0e6ba411ce044ecffbc476fcbefcb61a8cf18926
+  metadata.gz: 1bfa93d983183ee395ce32f023a9536220884f0d
+  data.tar.gz: fd3504c892015ccf15a5f451c7877115186a138b
 SHA512:
-  metadata.gz: 6464f5860f02778245155c5f7ec98b61bde188482ef2fb90593baf1cf72fbede13ddd47654288745684d0fdc314cbe3e2609284fcb53cd329c6175b288686845
-  data.tar.gz: 00014f6f4d963c1512f844703b39888f084ebe1495e2fedffc3abe0bc29db2af3f78b40618c3280560414b6729c6d490cd2923faf6397fb26645a891f7f7b657
+  metadata.gz: 38fd3e00c764eae431fa980369b2f7deff86908529343a3fb07fe37ad6c02e354b87e9ebdfd13a1581f9af8b4e3ce7cd00547840b78132a43c2ecede1ffa135d
+  data.tar.gz: f4f393855791bf20d726cecef3d6858a7f9cde8267b91abd59a413d689b0a3e613113958bab3c3b33205771eec42f56cd8fe7dca8cb9170f737ee2dd69f7a5fe

data/README.md

@@ -2,13 +2,13 @@
 
 [![Gem Version](https://badge.fury.io/rb/mll.svg)](http://badge.fury.io/rb/mll)
 
-## What
+### What
 
 This gem isn't supposed to mimic all data types, exact syntax of Wolfram Mathematica or make Ruby able to make the same visualisations.
 
 The main goal is to make Ruby more powerful by including the most used functions, that Ruby lacks, such as `Table[]`, `FoldList[]`, etc. Visualisations are possible later by using additional gems.
 
-## Why
+### Why
 
 0. `::map` can map Arrays at specified depth!
 1. One of the most useful things is automatic zipping vectors (`Array`s) when you apply scalar functions to them. https://reference.wolfram.com/language/ref/Listable.html
@@ -18,7 +18,7 @@ The main goal is to make Ruby more powerful by including the most used functions
 5. `::nest` (n times) and `::nest_list` for repetitive applying the same function -- `::nest_while` and `::nest_while_list` are going to be implemented later
 6. `::tally` -- shortcut to a probably the most common usage of `#group_by` -- calculating total occurences.
 
-## How
+### How
 
     MLL::range[ 2, 3 ] # => 2..3
     MLL::range[[2, 3]] # => [1..2, 1..3]
@@ -77,11 +77,11 @@ The main goal is to make Ruby more powerful by including the most used functions
 
 Note that to see some of above examples working in the same way you need `.to_a`, `.map(&:to_a)` or even `.to_a.map(&:to_a)` since lazyness is intensively used.
 
-## Installation
+### Installation
 
     $ gem install mll
 
-## Testing with RSpec before contributing
+### Testing with RSpec before contributing
 
     rspec
 
@@ -89,15 +89,22 @@ or
 
     rake spec
 
-## TODO (this section is filled automatically by `rake todo` task -- do not remove)
+### TODO (this section is filled automatically by `rake todo` task -- do not remove)
 
 #### lib/mll.rb
 
 ```
 module MLL
   class << self
+    def dimensions
+      lambda do |list, limit = nil|
+        enumerator = Enumerator.new do |e|
+          while list.map(&:class).uniq == [Array] &&
+            # TODO refactor into depth-first yielding
+    def nest_while
+      # TODO finish me
     def fold_list
-      lambda do |f, x, list = nil|
+      lambda do |x, list, f = nil|
         # TODO use Ruby#inject ?
     def map
       # TODO validate depths
@@ -118,6 +125,8 @@ module MLL
 # TODO @fraggedICE wishes using Rational -- would also allow implementing more examples
 # TODO elegantly get rid of repetitive type checks
 # TODO ? let(:fake_lambda){ ->(*args){fail} }
+# TODO rewrite all Lazy#to_a into Lazy#force (it's not recursive and not documented)
+# TODO maybe make indexes count from 0 not 1
 describe MLL do
   describe "List Manipulation" do
     describe "Constructing Lists" do
@@ -134,7 +143,7 @@ describe MLL do
         # TODO we'll need less nested mappings when we implement stop on depths depletion
         describe "Details and Options:" do
           example "levels n1 though n2" do
-            expect(map[->(i){ [i] }, [1,[2,[3,[4,[5,6]]]]], [2,4]].
+            expect(map[[1,[2,[3,[4,[5,6]]]]], [2,4], ->(i){ [i] }].
               # TODO smth _<>
           # TODO "Level corresponds to the whole expression"
           # TODO currying "Map[f][expr] is equivalent to Map[f,expr]"
@@ -145,14 +154,27 @@ describe MLL do
           # TODO #mapthread ?
           # TODO #mapindexed ?
           # TODO "negative levels"
-    # TODO http://reference.wolfram.com/language/guide/ElementsOfLists.html
     # TODO http://reference.wolfram.com/language/guide/RearrangingAndRestructuringLists.html
     # TODO http://reference.wolfram.com/language/guide/MathematicalAndCountingOperationsOnLists.html
   describe "Functional Programming" do
     describe "Iteratively Applying Functions" do
       # TODO move #nest_list and #fold_list and others here?
-      describe "#nest" do
-        # TODO neat graphic examples
+      # TODO examples in README.rb
+      describe "#nest_while" do
+        describe "Details:" do
+          # TODO a lot
+        describe "Scope:" do
+          # TODO "always compare all values generated" do
+          # TODO "compare the last two values generated" do
+          # TODO "start comparisons after 4 iterations, and compare using the 4 last values" do
+          # TODO "start comparisons after 4 iterations, and compare using the 6 last values" do
+          # TODO example "stop after at most 4 iterations, even if the test is still true" do
+        describe "Generalizations & Extensions:" do
+          # TODO "return the last value for which the condition was still true" do
+        describe "Applications:" do
+          # TODO example "find the next twin prime after 888" do
+        describe "Properties & Relations:" do
+          # TODO "#nest_while can be expressed in terms of a while loop" do
 # TODO http://reference.wolfram.com/language/guide/HandlingArraysOfData.html
 # TODO http://reference.wolfram.com/language/guide/ComputationWithStructuredDatasets.html
 ```

data/Rakefile

@@ -6,32 +6,29 @@ task :todo do |t|
   fail unless File.exist? "README.md"
   File.open("README.md", "r+") do |readme_file|
     # begin readme_file.gets end until $_[/^## TODO/]
-    readme_file.gets "## TODO"
+    readme_file.gets "### TODO"
     readme_file.gets
     %w{ lib/mll.rb spec/_spec.rb }.each do |file|
       readme_file.puts "", "#### #{file}", "", "```"
       stack = []
-      lines = []
-      File.foreach(file).with_index do |line, i|
+      File.foreach(file) do |line|
         next unless shift = /\S/ =~ line
         depth = shift / 2
-        stack[depth] = i
-        lines |= stack.take(depth + 1) if line[/^\s*# TODO/]
-      end
-      next_line_to_print = lines.shift
-      File.foreach(file).with_index do |line, i|
-        next unless i == next_line_to_print
-        readme_file.puts line
-        next_line_to_print = lines.shift
+        stack[depth] = line
+        if line[/^\s*# TODO/]
+          readme_file.puts stack.take(depth + 1).compact
+          stack.clear
+        end
       end
       readme_file.puts "```"
     end
     readme_file.truncate readme_file.pos
   end
+  puts `md5 README.md`
 end
 
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.verbose = false
 end
 
-task :default => %w{ todo spec }
+task :default => %w{ spec todo }

data/lib/mll.rb

@@ -2,25 +2,44 @@ module MLL
 
   class << self
 
+    def dimensions
+      lambda do |list, limit = nil|
+        list = [list]
+        enumerator = Enumerator.new do |e|
+          # String.size shall not pass
+          while list.map(&:class).uniq == [Array] &&
+                list.map(&:size).uniq.size == 1
+            # TODO refactor into depth-first yielding
+            e << list.first.size
+            list.flatten! 1
+          end
+        end
+        limit ? enumerator.lazy.take(limit) : enumerator
+      end
+    end
+
     def tally
-      lambda do |list, test = ->(i,j){ i == j } | # TODO implement #sameq ?
-        h = Hash.new{ 0 }
-        keys = []
-        list.each do |item|
-          h[item] += 1 if keys.each do |key|
-            if test[key, item]
-              h[key] += 1
-              break
-            end
+      lambda do |list, test = nil| # implement #sameq ?
+        return Hash[ list.group_by{ |i| i }.map{ |k, v| [k, v.size] } ] unless test
+        Hash.new{ 0 }.tap do |result|
+          list.each do |item|
+            result[
+              list.find{ |key| test[key, item] }
+            ] += 1
           end
-          keys << item
         end
-        h
+      end
+    end
+
+    def nest
+      lambda do |expr, n, f|
+        n.times{ expr = f.call expr }
+        expr
       end
     end
 
     def nest_list
-      lambda do |f, expr, n|
+      lambda do |expr, n, f|
         Enumerator.new do |e|
           e << expr
           n.times do
@@ -29,19 +48,21 @@ module MLL
         end
       end
     end
-    # def self.nest *args
-    #   nest_list(*args).last
-    # end
-    def nest
-      lambda do |f, expr, n|
-        n.times{ expr = f.call expr }
+
+    def nest_while
+      # TODO finish me
+      lambda do |expr, f, test|
+        expr = f[expr] while test[expr]
         expr
       end
     end
 
     def fold_list
-      lambda do |f, x, list = nil|
-        x, *list = x.to_a unless list
+      lambda do |x, list, f = nil|
+        unless f
+          f = list
+          x, *list = x.to_a
+        end
         # TODO use Ruby#inject ?
         Enumerator.new do |e|
           e << x
@@ -55,13 +76,14 @@ module MLL
     def map
       # TODO validate depths
       # TODO break on passing all depths
-      lambda do |f, list, depths = [1]|
+      lambda do |list, depths, f = nil|
+        depths, f = [1], depths unless f
         depths = Range.new(*depths) if depths.size == 2
         depths = Range.new(1,depths) if depths.is_a? Integer
         g = lambda do |list, depth|
-          next list unless list.respond_to? :map
+          next list unless list.is_a? Array
           temp = list.lazy.map{ |i| g[i, depth + 1] }
-          temp = temp.map &f if depths.include? depth
+          temp = temp.lazy.map &f if depths.include? depth
           temp
         end
         g[list, 1]
@@ -170,5 +192,11 @@ module MLL
 
   define_orderless_function(:plus,  0) { |a, b| _plus.call  a, b }
   define_orderless_function(:times, 1) { |a, b| _times.call a, b }
+  
+  def self.mean
+    lambda do |list|
+      divide[times[plus[*list], 1.0], list.size]
+    end
+  end
 
 end

data/mll.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "mll"
-  spec.version       = "1.2.0"
+  spec.version       = "2.1.0"
   spec.authors       = ["Victor Maslov"]
   spec.email         = ["nakilon@gmail.com"]
   spec.summary       = "Mathematica Language Library in Ruby"

data/spec/_spec.rb

@@ -14,6 +14,9 @@ require_relative File.join "..", "lib", "mll"
 # TODO elegantly get rid of repetitive type checks
 # TODO ? let(:fake_lambda){ ->(*args){fail} }
 
+# TODO rewrite all Lazy#to_a into Lazy#force (it's not recursive and not documented)
+
+# TODO maybe make indexes count from 0 not 1
 
 # http://reference.wolfram.com/language/guide/LanguageOverview.html
 describe MLL do
@@ -168,8 +171,8 @@ describe MLL do
 
           # idk why not in 'Properties & Relations'
           example "accumulate makes a cumulative sum" do
-            expect(fold_list[plus, 0, [1,2,3]]).to be_a Enumerator
-            expect(fold_list[plus, 0, [1,2,3]].to_a).to eq [0,1,3,6]
+            expect(fold_list[0, [1,2,3], plus]).to be_a Enumerator
+            expect(fold_list[0, [1,2,3], plus].to_a).to eq [0,1,3,6]
           end
           
         end
@@ -464,8 +467,8 @@ describe MLL do
       describe "#nest_list" do
 
         example "gives a list of length n+1" do
-          expect(nest_list[->{}, 0, 5]).to be_a Enumerator
-          expect(nest_list[->(*args){}, 0, 5].to_a.size).to eq 6
+          expect(nest_list[0, 5, ->(*){}]).to be_a Enumerator
+          expect(nest_list[0, 5, ->(*){}].to_a.size).to eq 6
         end
 
         describe "Basic Examples:" do
@@ -487,24 +490,24 @@ describe MLL do
         describe "Applications:" do
 
           example "powers of 2" do
-            expect(nest_list[->(i){ 2*i }, 1, 10]).to be_a Enumerator
-            expect(nest_list[->(i){ 2*i }, 1, 10].to_a).to eq [1,2,4,8,16,32,64,128,256,512,1024]
+            expect(nest_list[1, 10, ->(i){ 2*i }]).to be_a Enumerator
+            expect(nest_list[1, 10, ->(i){ 2*i }].to_a).to eq [1,2,4,8,16,32,64,128,256,512,1024]
           end
           example "iterates in the  problem" do
-            expect(nest_list[->(i){ i.even? ? i/2 : (i*3+1)/2 }, 100, 20]).to be_a Enumerator
-            expect(nest_list[->(i){ i.even? ? i/2 : (i*3+1)/2 }, 100, 20].to_a).to eq [100,50,25,38,19,29,44,22,11,17,26,13,20,10,5,8,4,2,1,2,1]
+            expect(nest_list[100, 20, ->(i){ i.even? ? i/2 : (i*3+1)/2 }]).to be_a Enumerator
+            expect(nest_list[100, 20, ->(i){ i.even? ? i/2 : (i*3+1)/2 }].to_a).to eq [100,50,25,38,19,29,44,22,11,17,26,13,20,10,5,8,4,2,1,2,1]
           end
           example "linear congruential pseudorandom generator" do
-            expect(nest_list[->(i){ (i*59)%101 }, 1, 15]).to be_a Enumerator
-            expect(nest_list[->(i){ (i*59)%101 }, 1, 15].to_a).to eq [1,59,47,46,88,41,96,8,68,73,65,98,25,61,64,39]
+            expect(nest_list[1, 15, ->(i){ (i*59)%101 }]).to be_a Enumerator
+            expect(nest_list[1, 15, ->(i){ (i*59)%101 }].to_a).to eq [1,59,47,46,88,41,96,8,68,73,65,98,25,61,64,39]
           end
           example "random walk" do
-            expect(( r = Random.new(0); nest_list[->(i){ i+[-1,1][r.rand(2)] }, 0, 20] )).to be_a Enumerator
-            expect(( r = Random.new(0); nest_list[->(i){ i+[-1,1][r.rand(2)] }, 0, 20] ).to_a).to eq [0,-1,0,1,0,1,2,3,4,5,6,7,6,5,6,5,4,3,2,1,2]
+            expect(( r = Random.new(0); nest_list[0, 20, ->(i){ i+[-1,1][r.rand(2)] }] )).to be_a Enumerator
+            expect(( r = Random.new(0); nest_list[0, 20, ->(i){ i+[-1,1][r.rand(2)] }] ).to_a).to eq [0,-1,0,1,0,1,2,3,4,5,6,7,6,5,6,5,4,3,2,1,2]
           end
           example "successively rotate a list" do
-            expect(nest_list[->(i){ i.rotate 1 }, [1,2,3,4], 4]).to be_a Enumerator
-            expect(nest_list[->(i){ i.rotate 1 }, [1,2,3,4], 4].to_a).to eq [[1,2,3,4],[2,3,4,1],[3,4,1,2],[4,1,2,3],[1,2,3,4]]
+            expect(nest_list[[1,2,3,4], 4, ->(i){ i.rotate 1 }]).to be_a Enumerator
+            expect(nest_list[[1,2,3,4], 4, ->(i){ i.rotate 1 }].to_a).to eq [[1,2,3,4],[2,3,4,1],[3,4,1,2],[4,1,2,3],[1,2,3,4]]
           end
 
         end
@@ -512,16 +515,15 @@ describe MLL do
         describe "Properties & Relations:" do
 
           example "#nest gives the last element of #nest_list" do
-            expect(nest_list[->(i){ i*2 }, 3, 4].to_a.last).to eq nest[->(i){ i*2 }, 3, 4]
+            expect(nest_list[3, 4, ->(i){ i*2 }].to_a.last).to eq nest[3, 4, ->(i){ i*2 }]
           end
-
           example "nesting zero times simply returns to the original argument" do
-            expect(nest_list[->{fail}, 5, 0]).to be_a Enumerator
-            expect(nest_list[->(*args){fail}, 5, 0].to_a).to eq [5]
+            expect(nest_list[5, 0, ->(*){fail}]).to be_a Enumerator
+            expect(nest_list[5, 0, ->(*){fail}].to_a).to eq [5]
           end
           example "#fold_list automatically inserts second arguments from a list" do
-            expect(nest_list[->(i  ){ i*2 }, 3,     4].to_a).to eq \
-                   fold_list[->(i,j){ i*j }, 3, [2]*4].to_a
+            expect(nest_list[3,     4, ->(i  ){ i*2 }].to_a).to eq \
+                   fold_list[3, [2]*4, ->(i,j){ i*j }].to_a
           end
 
         end
@@ -542,8 +544,8 @@ describe MLL do
             skip "waiting got Wolfram team to fix the reported bug"
           end
           example "#fold_list[f,list] is equivalent to #fold_list[f,[list][0],list[1..-1]]" do
-            expect(fold_list[plus,[1,2,3]]).to be_a Enumerator
-            expect(fold_list[plus,[1,2,3]].to_a).to eq fold_list[plus,1,[2,3]].to_a
+            expect(fold_list[[1,2,3], plus]).to be_a Enumerator
+            expect(fold_list[[1,2,3], plus].to_a).to eq fold_list[1, [2,3], plus].to_a
           end
 
         end
@@ -551,16 +553,16 @@ describe MLL do
         describe "Basic Examples:" do
 
           example "cumulative sums of the elements of the list" do
-            expect(fold_list[plus,5,[1,2,3,4]]).to be_a Enumerator
-            expect(fold_list[plus,5,[1,2,3,4]].to_a).to eq [5,6,8,11,15]
+            expect(fold_list[5, [1,2,3,4], plus]).to be_a Enumerator
+            expect(fold_list[5, [1,2,3,4], plus].to_a).to eq [5,6,8,11,15]
           end
           example "cumulative powers" do
-            expect(fold_list[->(base, power){ base ** power },2,[3,2,1]]).to be_a Enumerator
-            expect(fold_list[->(base, power){ base ** power },2,[3,2,1]].to_a).to eq [2,8,64,64]
+            expect(fold_list[2, [3,2,1], ->(base, power){ base ** power }]).to be_a Enumerator
+            expect(fold_list[2, [3,2,1], ->(base, power){ base ** power }].to_a).to eq [2,8,64,64]
           end
           example "start from the first element of the list" do
-            expect(fold_list[plus,[1,2,3,4]]).to be_a Enumerator
-            expect(fold_list[plus,[1,2,3,4]].to_a).to eq [1,3,6,10]
+            expect(fold_list[[1,2,3,4], plus]).to be_a Enumerator
+            expect(fold_list[[1,2,3,4], plus].to_a).to eq [1,3,6,10]
           end
 
         end
@@ -569,13 +571,13 @@ describe MLL do
 
           # TODO maybe move it to README.md
           example "generate a random walk" do
-            expect(( r = Random.new(0); fold_list[plus, 0, Array.new(20){ [-1,1][r.rand(2)] }] )).to be_a Enumerator
-            expect(( r = Random.new(0); fold_list[plus, 0, Array.new(20){ [-1,1][r.rand(2)] }] ).to_a).to eq [0,-1,0,1,0,1,2,3,4,5,6,7,6,5,6,5,4,3,2,1,2]
+            expect(( r = Random.new(0); fold_list[0, Array.new(20){ [-1,1][r.rand(2)] }, plus] )).to be_a Enumerator
+            expect(( r = Random.new(0); fold_list[0, Array.new(20){ [-1,1][r.rand(2)] }, plus] ).to_a).to eq [0,-1,0,1,0,1,2,3,4,5,6,7,6,5,6,5,4,3,2,1,2]
           end
 
           example "find successively deeper parts in an expression" do
-            expect(fold_list[->(list,index){ list[index] }, [[1,2],[3,[4,5],6,7],8], [1,1,0]]).to be_a Enumerator
-            expect(fold_list[->(list,index){ list[index] }, [[1,2],[3,[4,5],6,7],8], [1,1,0]].to_a).to eq [[[1,2],[3,[4,5],6,7],8],[3,[4,5],6,7],[4,5],4]
+            expect(fold_list[[[1,2],[3,[4,5],6,7],8], [1,1,0], ->(list,index){ list[index] }]).to be_a Enumerator
+            expect(fold_list[[[1,2],[3,[4,5],6,7],8], [1,1,0], ->(list,index){ list[index] }].to_a).to eq [[[1,2],[3,[4,5],6,7],8],[3,[4,5],6,7],[4,5],4]
           end
 
         end
@@ -583,20 +585,20 @@ describe MLL do
         describe "Properties & Relations:" do
 
           example "makes a list of length n+1" do
-            expect(fold_list[->{}, 0, [*1..10]]).to be_a Enumerator
-            expect(fold_list[->(*args){}, 0, [*1..10]].to_a.size).to eq 11
+            expect(fold_list[0, [*1..10], ->(*){}]).to be_a Enumerator
+            expect(fold_list[0, [*1..10], ->(*){}].to_a.size).to eq 11
           end
           example "folding with an empty list does not apply the function at all" do
-            expect(fold_list[->{}, 0, []]).to be_a Enumerator
-            expect(fold_list[->(*args){}, 0, []].to_a).to eq [0]
+            expect(fold_list[0, [], ->(*){}]).to be_a Enumerator
+            expect(fold_list[0, [], ->(*){}].to_a).to eq [0]
           end
           example "Ruby#inject gives the last element of #fold_list" do
             f = ->(i,j){ i+j }
-            expect(fold_list[f, [1,2,3]]).to be_a Enumerator
-            expect(fold_list[f, [1,2,3]].to_a.last).to eq [1,2,3].inject(&f)
+            expect(fold_list[[1,2,3], f]).to be_a Enumerator
+            expect(fold_list[[1,2,3], f].to_a.last).to eq [1,2,3].inject(&f)
           end
           example "functions that ignore their second argument give the same result as in #nest_list" do
-            expect(fold_list[->(i,_){ [i] }, 0, range[5]].to_a).to eq nest_list[->(i){ [i] }, 0, 5].to_a
+            expect(fold_list[0, range[5], ->(i,_){ [i] }].to_a).to eq nest_list[0, 5, ->(i){ [i] }].to_a
           end
 
         end
@@ -619,8 +621,8 @@ describe MLL do
         describe "Details and Options:" do
 
           example "levels n1 though n2" do
-            expect(map[->(i){ [i] }, [1,[2,[3,[4,[5,6]]]]], [2,4]]).to be_a Enumerator
-            expect(map[->(i){ [i] }, [1,[2,[3,[4,[5,6]]]]], [2,4]].
+            expect(map[[1,[2,[3,[4,[5,6]]]]], [2,4], ->(i){ [i] }]).to be_a Enumerator
+            expect(map[[1,[2,[3,[4,[5,6]]]]], [2,4], ->(i){ [i] }].
               to_a.map{ |i| i.respond_to?(:to_a) ? i.
               to_a.map{ |i| i.respond_to?(:to_a) ? i.
               to_a.map{ |i| i.respond_to?(:to_a) ? i.
@@ -640,24 +642,24 @@ describe MLL do
         describe "Basic Examples:" do
 
           example "???" do
-            expect(map[range, [1,2,3]]).to be_a Enumerator
-            expect(map[range, [1,2,3]].to_a.map(&:to_a)).to eq [[1],[1,2],[1,2,3]]
+            expect(map[[1,2,3], range]).to be_a Enumerator
+            expect(map[[1,2,3], range].to_a.map(&:to_a)).to eq [[1],[1,2],[1,2,3]]
           end
           example "use explicit pure functions" do
-            expect(map[->(i){ i**2 }, [1,2,3,4]]).to be_a Enumerator
-            expect(map[->(i){ i**2 }, [1,2,3,4]].to_a).to eq [1,4,9,16]
+            expect(map[[1,2,3,4], ->(i){ i**2 }]).to be_a Enumerator
+            expect(map[[1,2,3,4], ->(i){ i**2 }].to_a).to eq [1,4,9,16]
           end
           example "map at top level" do
-            expect(map[->(i){ [i] }, [[1,2],[3,4,5]]]).to be_a Enumerator
-            expect(map[->(i){ [i] }, [[1,2],[3,4,5]]].to_a.map{ |i| i.to_a.map &:to_a }).to eq [[[1,2]],[[3,4,5]]]
+            expect(map[[[1,2],[3,4,5]], ->(i){ [i] }]).to be_a Enumerator
+            expect(map[[[1,2],[3,4,5]], ->(i){ [i] }].to_a.map{ |i| i.to_a.map &:to_a }).to eq [[[1,2]],[[3,4,5]]]
           end
           example "map at level 2" do
-            expect(map[->(i){ [i] }, [[1,2],[3,4,5]], [2]]).to be_a Enumerator
-            expect(map[->(i){ [i] }, [[1,2],[3,4,5]], [2]].to_a.map(&:to_a)).to eq [[[1],[2]],[[3],[4],[5]]]
+            expect(map[[[1,2],[3,4,5]], [2], ->(i){ [i] }]).to be_a Enumerator
+            expect(map[[[1,2],[3,4,5]], [2], ->(i){ [i] }].to_a.map(&:to_a)).to eq [[[1],[2]],[[3],[4],[5]]]
           end
           example "map at levels 1 and 2" do
-            expect(map[->(i){ [i] }, [[1,2],[3,4,5]], 2]).to be_a Enumerator
-            expect(map[->(i){ [i] }, [[1,2],[3,4,5]], 2].to_a.map{ |i| i.to_a.map(&:to_a) }).to eq [[[[1],[2]]],[[[3],[4],[5]]]]
+            expect(map[[[1,2],[3,4,5]], 2, ->(i){ [i] }]).to be_a Enumerator
+            expect(map[[[1,2],[3,4,5]], 2, ->(i){ [i] }].to_a.map{ |i| i.to_a.map(&:to_a) }).to eq [[[[1],[2]]],[[[3],[4],[5]]]]
           end
 
         end
@@ -692,7 +694,45 @@ describe MLL do
 
     end
 
-    # TODO http://reference.wolfram.com/language/guide/ElementsOfLists.html
+    # http://reference.wolfram.com/language/guide/ElementsOfLists.html
+    describe "Elements of Lists" do
+
+      describe "#dimensions" do
+
+        describe "Basic Examples:" do
+
+          example "dimensions of a matrix" do
+            expect(dimensions[[[1,2,3],[4,5,6]]]).to be_a Enumerator
+            expect(dimensions[[[1,2,3],[4,5,6]]].to_a).to eq [2,3]
+          end
+          example "#dimensions counts only dimensions at which an expression is not 'ragged'" do
+            expect(dimensions[[[1,2,3],[4,5],[]]]).to be_a Enumerator
+            expect(dimensions[[[1,2,3],[4,5],[]]].to_a).to eq [3]
+          end
+          example "works with arrays of any depth" do
+            expect(dimensions[[[[[1,2]]]]]).to be_a Enumerator
+            expect(dimensions[[[[[1,2]]]]].to_a).to eq [1,1,1,2]
+          end
+          example "give dimensions only down to level 2" do
+            expect(dimensions[[[[[1,2]]]], 2]).to be_a Enumerator
+            expect(dimensions[[[[[1,2]]]], 2].to_a).to eq [1,1]
+          end
+
+        end
+
+        describe "Properties & Relations" do
+
+          example "???" do
+            expect(dimensions[table[->(*){ 0 }, 2,1,4,3]]).to be_a Enumerator
+            expect(dimensions[table[->(*){ 0 }, 2,1,4,3]].to_a).to eq [2,1,4,3]
+          end
+
+        end
+
+      end
+
+    end
+
     # TODO http://reference.wolfram.com/language/guide/RearrangingAndRestructuringLists.html
     # TODO http://reference.wolfram.com/language/guide/MathematicalAndCountingOperationsOnLists.html
 
@@ -706,13 +746,15 @@ describe MLL do
 
       # TODO move #nest_list and #fold_list and others here?
 
+      # TODO examples in README.rb
+
       # http://reference.wolfram.com/language/ref/Nest.html
       describe "#nest" do
 
         describe "Basic Examples:" do
 
           example "the function to nest can be a pure function" do
-            expect(nest[->(i){ (1+i)**2 }, 1, 3]).to eq 676
+            expect(nest[1, 3, ->(i){ (1+i)**2 }]).to eq 676
           end
 
         end
@@ -720,7 +762,7 @@ describe MLL do
         describe "Scope:" do
 
           example "nesting can return a single number" do
-            skip "#sqrt is yet to be implemented"
+            skip "#sqrt is yet to be implemented" # maybe use Array#zip instead?
           end
 
         end
@@ -739,12 +781,67 @@ describe MLL do
         describe "Properties & Relations:" do
 
           example "Ruby#inject automatically inserts second arguments from a list" do
-            expect(nest[->(i){ i*2 }, 3, 4]).to eq ([2]*4).inject(3){ |i,j| i*j }
+            expect(nest[3, 4, ->(i){ i*2 }]).to eq ([2]*4).inject(3){ |i,j| i*j }
           end
 
         end
 
-        # TODO neat graphic examples
+      end
+
+      # http://reference.wolfram.com/language/ref/NestWhile.html
+      describe "#nest_while" do
+
+        describe "Details:" do
+          # TODO a lot
+        end
+
+        describe "Basic Examples:" do
+
+          example "keep dividing by 2 until the result is no longer an even number" do
+            expect(nest_while[123456, ->(i){ i / 2 }, ->(i){ i.even? }]).to eq 1929
+          end
+
+        end
+
+        describe "Scope:" do
+
+          # TODO "always compare all values generated" do
+          # TODO "compare the last two values generated" do
+          # TODO "start comparisons after 4 iterations, and compare using the 4 last values" do
+          # TODO "start comparisons after 4 iterations, and compare using the 6 last values" do
+          # TODO example "stop after at most 4 iterations, even if the test is still true" do
+          #   expect(nest_while[123456, 1, 4, ->(i){ i / 2 }, ->(i){ i.even? }]).to eq 7716
+          # end
+
+        end
+
+        describe "Generalizations & Extensions:" do
+
+          # TODO "return the last value for which the condition was still true" do
+
+        end
+
+        describe "Applications:" do
+
+          example "find the next prime after 888" do
+            require "prime"
+            expect(nest_while[888, ->(i){ i+1 }, ->(i){ !i.prime? }]).to eq 907
+          end
+          # TODO example "find the next twin prime after 888" do
+          #   require "prime"
+          #   expect(nest_while[888, 3, ->(i){ i+1 }, ->(i,_,k){ !i.prime? || !k.prime? }]).to eq 1021
+          # end
+
+        end
+
+        describe "Properties & Relations:" do
+
+          example "#fixed_point always compares the last two values" do
+            skip "#fixed_point is yet to be implemented"
+          end
+          # TODO "#nest_while can be expressed in terms of a while loop" do
+
+        end
 
       end
 
@@ -799,6 +896,39 @@ describe MLL do
 
     end
 
+    # http://reference.wolfram.com/language/ref/Mean.html
+    describe "#mean" do
+
+      describe "Basic Examples" do
+
+        example "mean of numeric values" do
+          expect(mean[[1.21, 3.4, 2.15, 4, 1.55]]).to eq 2.462
+        end
+        example "means of elements in each column" do
+          expect(mean[[[1, 2], [3, 4], [5, 6]]]).to be_a Enumerator
+          expect(mean[[[1, 2], [3, 4], [8, 9]]].to_a).to eq [4, 5]
+        end
+
+      end
+
+      describe "Applications" do
+
+        example "a 90-day moving mean" do
+          skip "#moving_map is yet to be implemented"
+        end
+
+      end
+
+      describe "Properties & Relations" do
+
+        example "#moving_average is a sequence of means" do
+          skip "#moving_average is yet to be implemented"
+        end
+
+      end
+
+    end
+
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mll
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Victor Maslov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-11 00:00:00.000000000 Z
+date: 2015-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler