mll 0.4.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1826ae5ecd9c663432d75b8d35387762e7d3ce85
-  data.tar.gz: 1387511b30a66d4331ab6fe978682dfc0e4607af
+  metadata.gz: 812325964160837ba11226c5585e372463dd9fd7
+  data.tar.gz: fb060b7f5a405a230b21a20c9cc8426e5bd7e19b
 SHA512:
-  metadata.gz: 3e791cfab9e6f9e979b3c68a6364a2e8fd362696ae7592083f934165a543a525828f9b7504d137a32984988490c22b9e2bc891df7542f94bbcc1c3241b9c3e94
-  data.tar.gz: 71d9d47ec39472b8666db934b34fb33042a18b64e5543f0e8c19c1a39982e035335bf1075521069732014529b49ae59f298cb88f6ed10daea28c3f1dd13b255a
+  metadata.gz: 5fe15ad50531a0b9740847b01c27ed76e598d0345a0158b22474715a7fbb8bc917479c406ef1cac3580b167dd19b30bca820665888792657e8be6bc2a1f67b81
+  data.tar.gz: dd3547ff6b62c5ecd29d91529aee42e1552cb0d90bde926e7d8e090cdcf1df7ca1792aa110835a82133127f2f33d2c56a6421ab2ca56e778acbead64537c7380

data/README.md

@@ -2,39 +2,62 @@
 
 ## What
 
-Этот гем не ставит перед собой цель полностью имитировать типы данных, синтаксис Wolfram Mathematica Language, или научить Ruby крутым визуализациям. Целью является вложить в Ruby мощь стандартной библиотеки. В перспективе визуализация возможна при помощи других гемов.
+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
 
-1. Важной является реализация https://reference.wolfram.com/language/ref/Listable.html: автоматическое применение функции ко всем элементам аргумента, если тот является List-ом (Array-ем в среде Ruby).
-2. `::range`, в отличие от рубишного, может иметь отрицательный step.
-3. `::table`, в отличие от рубишного `.map`, может создавать многомерные массивы одним вызовом, а не только вложенными.
+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
+2. unlike Ruby's `Range` class, `::range` can handle negative `step` and even have `float` starting value
+3. unlike Ruby's `Array#map`, `::table` can create multidimensional arrays with a single call, not nested
+4. `#fold_list` was wanted [here](http://stackoverflow.com/q/1475808/322020) in Ruby while being already implemented as [FoldList[]](http://reference.wolfram.com/language/ref/FoldList.html) in Mathematica and [scanl](http://hackage.haskell.org/package/base-4.8.0.0/docs/Prelude.html#v:scanl) in Haskell
+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
 
 ## How
 
-    MLL::range(2, 3)   #=> 2..3
-    MLL::range([2, 3]) #=> [1..2, 1..3]
-    MLL::range(1..3)   #=> [1..1, 1..2, 1..3]
-
-    MLL::table ->(i,j){ i+j }, [[1, 0, 1]], [[0, 2, 0]]
-    #=> [[1, 3, 1],
-         [0, 2, 0],
-         [1, 3, 1]]
-    MLL::table ->(i,j,k){ 100*i + 10*j + k }, 2, 3, 4
-    # => [[[111, 112, 113, 114], [121, 122, 123, 124], [131, 132, 133, 134]],
-          [[211, 212, 213, 214], [221, 222, 223, 224], [231, 232, 233, 234]]]
-
-    MLL::table MLL.method(:times), 9, 9
-    # => [[1,  2,  3,  4,  5,  6,  7,  8,  9],
-          [2,  4,  6,  8, 10, 12, 14, 16, 18],
-          [3,  6,  9, 12, 15, 18, 21, 24, 27],
-          [4,  8, 12, 16, 20, 24, 28, 32, 36],
-          [5, 10, 15, 20, 25, 30, 35, 40, 45],
-          [6, 12, 18, 24, 30, 36, 42, 48, 54],
-          [7, 14, 21, 28, 35, 42, 49, 56, 63],
-          [8, 16, 24, 32, 40, 48, 56, 64, 72],
-          [9, 18, 27, 36, 45, 54, 63, 72, 81]]
-
+    MLL::range[ 2, 3 ] # => 2..3
+    MLL::range[[2, 3]] # => [1..2, 1..3]
+    MLL::range[ 1..3 ] # => [1..1, 1..2, 1..3]
+
+    MLL::table[ ->(i,j){ i+j }, [[1, 0, 1]], [[0, 2, 0]] ]
+                       # => [[1, 3, 1],
+                             [0, 2, 0],
+                             [1, 3, 1]]
+    MLL::table[ MLL.method(:times), 9, 9 ]
+                       # => [[1,  2,  3,  4,  5,  6,  7,  8,  9],
+                             [2,  4,  6,  8, 10, 12, 14, 16, 18],
+                             [3,  6,  9, 12, 15, 18, 21, 24, 27],
+                             [4,  8, 12, 16, 20, 24, 28, 32, 36],
+                             [5, 10, 15, 20, 25, 30, 35, 40, 45],
+                             [6, 12, 18, 24, 30, 36, 42, 48, 54],
+                             [7, 14, 21, 28, 35, 42, 49, 56, 63],
+                             [8, 16, 24, 32, 40, 48, 56, 64, 72],
+                             [9, 18, 27, 36, 45, 54, 63, 72, 81]]
+
+    MLL::fold_list[ MLL::times, MLL::range[10] ]
+                       # => [1,2,6,24,120,720,5040,40320,362880,3628800]
+
+    # here is `Listable' magic, allowing to zip arrays
+    #   even of different dimensions with basic operations
+    MLL::times[ [[1,2],[3,4]], [5,6] ]
+                       # => [[5,10], [18,24]]
+    # ::times     means  *
+    # ::divide    means  /
+    # ::subtract  means  -
+    # ::plus      means  +
+    
+    # http://en.wikipedia.org/wiki/Collatz_conjecture
+    MLL::nest_list[ ->(i){ i.even? ? i/2 : (i*3+1)/2 }, 20, 10 ]
+                       # => [20, 10, 5, 8, 4, 2, 1, 2, 1, 2, 1]
+
+    MLL::fold_list[ ->(a,b){ 10*a + b }, 0, [4,5,1,6,7,8] ]
+                       # => [0,4,45,451,4516,45167,451678]
+
+    MLL::subdivide[ 5, 10, 4 ]
+                       # => [5.0, 6.25, 7.5, 8.75, 10.0]
+    
+Note that to see some of above examples working you need `.to_a`, `.map(&:to_a)` or even `.to_a.map(&:to_a)` since lazyness is intensively used.
 
 ## Installation
 
@@ -46,5 +69,53 @@
 
 or
 
-    rake
-
+    rake spec
+
+## TODO (this section is filled automatically by `rake todo` task -- do not remove)
+
+#### lib/mll.rb
+
+```
+module MLL
+  def self.fold_list
+    lambda do |f, x, list = nil|
+      # TODO use Ruby#inject ?
+  def self.table
+    lambda do |f, *args|
+      [].tap do |result|
+        }]].tap do |stack|
+          stack.each do |ai, ri|
+            # TODO try to make #table lazy (Enumerator instead of Array)
+  # TODO not sure if we need any other kind of Listability except of #range[[Array]]
+```
+
+#### spec/_spec.rb
+
+```
+# TODO move Properties & Relations to some separate contexts maybe
+# 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} }
+describe MLL do
+  describe "List Manipulation" do
+    describe "Constructing Lists" do
+      describe "#table" do
+        describe "Scope" do
+          # TODO: "Make a triangular array:"
+      describe "#range" do
+        # TODO take from docs more examples that involve other functions
+    describe "Applying Functions to Lists" do
+      describe "#fold_list" do
+        describe "Applications" do
+          # TODO maybe move it to README.md
+    # 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 http://reference.wolfram.com/language/guide/HandlingArraysOfData.html
+# TODO http://reference.wolfram.com/language/guide/ComputationWithStructuredDatasets.html
+```

data/Rakefile

@@ -1,9 +1,36 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
+desc "Append TODO-list to README.md"
+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
+    %w{ lib/mll.rb spec/_spec.rb }.each do |file|
+      readme_file.puts "", "#### #{file}", "", "```"
+      stack = []
+      lines = []
+      File.foreach(file).with_index do |line, i|
+        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
+      end
+      readme_file.puts "```"
+    end
+  end
+end
+
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.verbose = false
 end
 
-task :default => :spec
-
+task :default => %w{ todo spec }

data/lib/mll.rb

@@ -1,74 +1,83 @@
 module MLL
 
-  def self.nest_list f, expr, n
-    Enumerator.new do |e|
-      e << expr
-      n.times do
-        e << expr = f.call(expr)
+  def self.nest_list
+    lambda do |f, expr, n|
+      Enumerator.new do |e|
+        e << expr
+        n.times do
+          e << expr = f.call(expr)
+        end
       end
     end
   end
   # def self.nest *args
   #   nest_list(*args).last
   # end
-  def self.nest f, expr, n
-    n.times{ expr = f.call expr }
-    expr
+  def self.nest
+    lambda do |f, expr, n|
+      n.times{ expr = f.call expr }
+      expr
+    end
   end
 
-  def self.fold_list f, x, list = nil
-    # TODO teach it to accept Range ?
-    x, *list = x unless list
-    # use Ruby#inject ?
-    Enumerator.new do |e|
-      e << x
-      list.each do |i|
-        e << x = f.call(x, i)
+  def self.fold_list
+    lambda do |f, x, list = nil|
+      x, *list = x.to_a unless list
+      # TODO use Ruby#inject ?
+      Enumerator.new do |e|
+        e << x
+        list.each do |i|
+          e << x = f.call(x, i)
+        end
       end
     end
   end
 
-  def self.table f, *args
-    [].tap do |result|
-      [[result, args.map{ |r| # add lazy?
-        r.respond_to?(:map) && r.first.respond_to?(:map) ?
-          r.first : range(*r)
-      }]].tap do |stack|
-        stack.each do |ai, ri|
-          # TODO try to make #table lazy (Enumerator instead of Array)
-          # "no implicit conversion of Enumerator::Lazy into Array"
-          # "undefined method `replace' for #<Enumerator::Lazy: []>"
-          ai.replace ri.first.map{ |i|
-            if ri.size == 1
-              f.call(*ai, i)
-            else
-              [*ai.dup, i].tap{ |t| stack << [t, ri.drop(1)] }
-            end
-          }#.to_a # WTF
+  def self.table
+    lambda do |f, *args|
+      [].tap do |result|
+        [[result, args.map{ |r| # add lazy?
+          r.respond_to?(:map) && r.first.respond_to?(:map) ?
+            r.first : range[*r]
+        }]].tap do |stack|
+          stack.each do |ai, ri|
+            # TODO try to make #table lazy (Enumerator instead of Array)
+            # "no implicit conversion of Enumerator::Lazy into Array"
+            # "undefined method `replace' for #<Enumerator::Lazy: []>"
+            ai.replace ri.first.map{ |i|
+              if ri.size == 1
+                f.call(*ai, i)
+              else
+                [*ai.dup, i].tap{ |t| stack << [t, ri.drop(1)] }
+              end
+            }
+          end
         end
       end
     end
   end
 
-  # http://reference.wolfram.com/language/ref/Listable.html
   def self.define_listable_function name, &block
-    (class << self; self end).class_eval do # http://stackoverflow.com/a/12792313/322020
-      define_method name do |*args|
-        case args.map{ |i| i.respond_to? :map }
-          when [true] ; args.first.lazy.map &method(name)
-          when [true, true] ; args.first.lazy.zip(args.last).map{ |i, j| send name, i, j }
-          when [true, false] ; args.first.lazy.map{ |i| send name, i, args.last }
-          when [false, true] ; args.last.lazy.map{ |i| send name, args.first, i }
-        else
-          block.call *args
+    (class << self; self end).class_eval do
+      define_method name do
+        lambda do |*args|
+          case args.map{ |i| i.respond_to? :map }
+            when [true] ; args.first.lazy.map &method(name).call
+            when [true, true] ; args.first.lazy.zip(args.last).map{ |i, j| send(name)[i, j] }
+            when [true, false] ; args.first.lazy.map{ |i| send(name)[i, args.last] }
+            when [false, true] ; args.last.lazy.map{ |i| send(name)[args.first, i] }
+          else
+            block.call *args
+          end
         end
       end
     end
   end
 
+  # TODO not sure if we need any other kind of Listability except of #range[[Array]]
   define_listable_function :range do |*args|
     case args.size
-    when 1 ; range 1, args[0] # TODO do smth with #table(-n)
+    when 1 ; range[1, args[0]] # TODO do smth with #table(-n)
     when 2 ; Range.new(args[0], args[1]).step
     when 3
       case args[2] <=> 0
@@ -89,34 +98,39 @@ module MLL
     end
   end
 
-  define_listable_function (:subtract) { |a, b| a - b }
-  define_listable_function (:divide) { |a, b| a / b }
-  define_listable_function (:_plus) { |a, b| a + b }
-  define_listable_function (:_times) { |a, b| a * b }
+  define_listable_function(:subtract) { |*args| raise ArgumentError.new("need two arguments") unless args.size == 2 ; args[0] - args[1] }
+  define_listable_function(:divide)   { |*args| raise ArgumentError.new("need two arguments") unless args.size == 2 ; args[0] / args[1] }
+  define_listable_function(:_plus)    { |*args| raise ArgumentError.new("need two arguments") unless args.size == 2 ; args[0] + args[1] }
+  define_listable_function(:_times)   { |*args| raise ArgumentError.new("need two arguments") unless args.size == 2 ; args[0] * args[1] }
+  # define_listable_function (:power)   { |*args| raise ArgumentError.new("need two arguments") unless args.size == 2 ; args[0] ** args[1] }
 
   # http://reference.wolfram.com/language/ref/Orderless.html
-  def self.define_orderless_function name, &block
+  def self.define_orderless_function name, start, &block
     (class << self; self end).class_eval do # http://stackoverflow.com/a/12792313/322020
-      define_method name do |*args|
-        args.inject do |memo, obj|
-          block.call memo, obj
+      define_method name do
+       lambda do |*args|
+          args.inject(start) do |memo, obj|
+            block.call memo, obj
+          end
         end
       end
     end
   end
 
-  define_orderless_function (:plus) { |a, b| _plus a, b }
-  define_orderless_function (:times) { |a, b| _times a, b }
+  define_orderless_function(:plus,  0) { |a, b| _plus.call  a, b }
+  define_orderless_function(:times, 1) { |a, b| _times.call a, b }
 
-  def self.subdivide *args
-    case args.size
-      when 1 ; subdivide 1, args[0]
-      when 2 ; subdivide 0, args[0], args[1]
-      when 3 ; range(args[0], args[1], (args[1] - args[0]) * 1.0 / args[2])
-      ## using only pure Ruby methods makes unittests more reliable
-      # when 3 ; plus args[0], divide(times(1.0, args[1] - args[0], range(0, args[2])), args[2])
-    else
-      raise ArgumentError.new("wrong number of arguments (#{args.size} for 1..3)")
+  def self.subdivide
+    lambda do |*args|
+      case args.size
+        when 1 ; subdivide[1, args[0]]
+        when 2 ; subdivide[0, args[0], args[1]]
+        when 3
+          # raise ArgumentError.new("can't divide into 0 parts") if args[2].zero?
+          range[args[0], args[1], (args[1] - args[0]) * 1.0 / args[2]]
+      else
+        raise ArgumentError.new("wrong number of arguments (#{args.size} for 1..3)")
+      end
     end
   end
 

data/mll.gemspec

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

data/spec/_spec.rb

@@ -5,26 +5,23 @@ require_relative File.join "..", "lib", "mll"
 # PERMATODO test all types returned (not actually all but about lazyness)
 # PERMATODO check for "Details" paragraphs to make more trivial examples
 # PERMATODO leave here only useful tests, not demostrations -- move them to README.rb
-# PERMATODO single element Arrays tests
+# PERMATODO polymorphic functions should have ArgumentError-s and tests about that
 # PERMATODO move Properties & Relations to some separate contexts maybe
 
-# TODO test all implemented exceptions
-# TODO test all types returned (not actually all but about lazyness)
-# TODO check for "Details" paragraphs to make more trivial examples
-# TODO leave here only useful tests, not demostrations -- move them to README.rb
-# TODO single element Arrays tests
 # TODO move Properties & Relations to some separate contexts maybe
 
 # TODO @fraggedICE wishes using Rational -- would also allow implementing more examples
-# TODO rake task for appending TODOs and pendings to README.rb
-# TODO rename examples according to their description not content
 # TODO elegantly get rid of repetitive type checks
-# TODO implement #power for use in unittests
-# TODO let(:fake_lambda){ ->(*args){fail} } ?
+# TODO ? let(:fake_lambda){ ->(*args){fail} }
+
 
 # http://reference.wolfram.com/language/guide/LanguageOverview.html
 describe MLL do
 
+  def method_missing *args
+    described_class.send *args
+  end
+
   # http://reference.wolfram.com/language/guide/Syntax.html
   describe "Syntax" do
 
@@ -34,19 +31,38 @@ describe MLL do
       # http://reference.wolfram.com/language/ref/Subtract.html
       describe "#subtract" do
 
+        example "less than 2 args raise ArgumentError" do
+          expect{ subtract[0    ] }.to raise_error ArgumentError
+        end
+        example "more than 2 args raise ArgumentError" do
+          expect{ subtract[0,0,0] }.to raise_error ArgumentError
+        end
+
         describe "Basic Examples" do
 
-          example "subtract(n1, n2)" do
-            expect(MLL::subtract(10,3)).to eq 7
+          example "subtract numbers" do
+            expect(subtract[10,3]).to eq 7
           end
 
         end
 
         describe "Scope" do
 
-          example "subtract(list, n)" do
-            expect(MLL::subtract([1,2,3,4],0.5)).to be_a Enumerator
-            expect(MLL::subtract([1,2,3,4],0.5).to_a).to eq [0.5,1.5,2.5,3.5]
+          example "threads element‐wise over lists" do
+            expect(subtract[[1,2,3,4],0.5]).to be_a Enumerator
+            expect(subtract[[1,2,3,4],0.5].to_a).to eq [0.5,1.5,2.5,3.5]
+            expect(subtract[6,[3,2]]).to be_a Enumerator
+            expect(subtract[6,[3,2]].to_a).to eq [3,4]
+            expect(subtract[[[1,2],[3,4]],1]).to be_a Enumerator
+            expect(subtract[[[1,2],[3,4]],1].to_a.map(&:to_a)).to eq [[0,1],[2,3]]
+            expect(subtract[[3,4],[2,1]]).to be_a Enumerator
+            expect(subtract[[3,4],[2,1]].to_a).to eq [1,3]
+            expect(subtract[[[1,3],[2,4]],[1,2]]).to be_a Enumerator
+            expect(subtract[[[1,3],[2,4]],[1,2]].to_a.map(&:to_a)).to eq [[0,2],[0,2]]
+          end
+          example "matrices subtract element-wise" do
+            expect(subtract[[[5,6],[7,8]],[[4,3],[2,1]]]).to be_a Enumerator
+            expect(subtract[[[5,6],[7,8]],[[4,3],[2,1]]].to_a.map(&:to_a)).to eq [[1,3],[5,7]]
           end
 
         end
@@ -56,110 +72,151 @@ describe MLL do
       # http://reference.wolfram.com/language/ref/Divide.html
       describe "#divide" do
 
+        example "less than 2 args raise ArgumentError" do
+          expect{ divide[0    ] }.to raise_error ArgumentError
+        end
+        example "more than 2 args raise ArgumentError" do
+          expect{ divide[0,0,0] }.to raise_error ArgumentError
+        end
+
         describe "Basic Examples" do
 
-          example "divide(n1, n2)" do
-            # expect(MLL::divide(77,11)).to be_a Fixnum
-            expect(MLL::divide(77,11)).to eq 7
+          example "divide numbers" do
+            expect(divide[77,11]).to eq 7
           end
 
         end
 
         describe "Scope" do
 
-          example "divide(list, n)" do
-            expect(MLL::divide([2,3,4,5],2.0)).to be_a Enumerator
-            expect(MLL::divide([2,3,4,5],2.0).to_a).to eq [1,1.5,2,2.5]
+          example "threads element‐wise over lists" do
+            expect(divide[[2,3,4,5],2.0]).to be_a Enumerator
+            expect(divide[[2,3,4,5],2.0].to_a).to eq [1,1.5,2,2.5]
+            expect(divide[6,[3,2]]).to be_a Enumerator
+            expect(divide[6,[3,2]].to_a).to eq [2,3]
+            expect(divide[[[4,2],[6,8]],2]).to be_a Enumerator
+            expect(divide[[[4,2],[6,8]],2].to_a.map(&:to_a)).to eq [[2,1],[3,4]]
+            expect(divide[[2,3,4],[2,1,4]]).to be_a Enumerator
+            expect(divide[[2,3,4],[2,1,4]].to_a).to eq [1,3,1]
+            expect(divide[[[1,3],[2,4]],[1,2]]).to be_a Enumerator
+            expect(divide[[[1,3],[2,4]],[1,2]].to_a.map(&:to_a)).to eq [[1,3],[1,2]]
           end
-          example "divide(list, list)" do
-            expect(MLL::divide([2,3,4],[2,1,4])).to be_a Enumerator
-            expect(MLL::divide([2,3,4],[2,1,4]).to_a).to eq [1,3,1]
+          example "matrices divide element-wise" do
+            expect(divide[[[5,8],[9,8]],[[1,2],[3,4]]]).to be_a Enumerator
+            expect(divide[[[5,8],[9,8]],[[1,2],[3,4]]].to_a.map(&:to_a)).to eq [[5,4],[3,2]]
           end
 
         end
 
         describe "Applications" do
 
-          # TODO: "Successive ratios in a list:"
-
-        end
-
-        describe "Neat Examples" do
-
-          example "nest_list(lambda_with_divide), n" do
-            pending "#nestlist is yet to be implemented"
-            fail
-          end
-          example "table(function, n1, n2)" do
-            expect(MLL::table(MLL.method(:divide), [[3,6]], 4.0)).to be_a Array
-            expect(MLL::table(MLL.method(:divide), [[6]], 4.0)).to eq [[6.0,3.0,2.0,1.5]]
+          example "successive ratios in a list" do
+            skip "waiting for Rationals to be used"
           end
 
         end
 
       end
 
-      # TODO common tests for threading functions like times, plus, etc.
-
       # http://reference.wolfram.com/language/ref/Plus.html
       describe "#plus" do
 
-        describe "Basic Examples" do
+        describe "Details" do
 
-          example "plus(n1, n2, n3)" do
-            expect(MLL::plus(2,3,4)).to eq 9
+          example "#plus[] is taken to be 0" do
+            expect(plus[]).to eq 0
           end
-          example "plus([n1, n2, n3], n)" do
-            expect(MLL::plus([3,4,5],2)).to be_a Enumerator
-            expect(MLL::plus([3,4,5],2).to_a).to eq [5,6,7]
+          example "#plus[x] is x" do
+            expect(plus[5]).to eq 5
           end
-          example "plus(n1, n2, [n3, n4])" do
-            expect(MLL::plus(2,3,[4,5])).to be_a Enumerator
-            expect(MLL::plus(2,3,[4,5]).to_a).to eq [9,10]
-          end
-          example "plus(list, list)" do
-            expect(MLL::plus([10,20,30],[1,2,3])).to be_a Enumerator
-            expect(MLL::plus([10,20,30],[1,2,3]).to_a).to eq [11,22,33]
+
+        end
+
+        describe "Basic Examples" do
+
+          example "sums numbers" do
+            expect(plus[2,3,4]).to eq 9
           end
-          example "plus(list_of_lists, n)" do
-            expect(MLL::plus([[1,2],[3,4]],5)).to be_a Enumerator
-            expect(MLL::plus([[1,2],[3,4]],5).to_a.map(&:to_a)).to eq [[6,7],[8,9]]
+          example "threads element‐wise over lists" do
+            # idk why not in Scope
+            expect(plus[[3,4,5],2]).to be_a Enumerator
+            expect(plus[[3,4,5],2].to_a).to eq [5,6,7]
+            expect(plus[2,3,[4,5]]).to be_a Enumerator
+            expect(plus[2,3,[4,5]].to_a).to eq [9,10]
+            expect(plus[[[1,2],[3,4]],[5,6]]).to be_a Enumerator
+            expect(plus[[[1,2],[3,4]],[5,6]].to_a.map(&:to_a)).to eq [[6,7],[9,10]]
           end
-          example "plus(list_of_lists, list_of_lists)" do
-            expect(MLL::plus([[1,2],[3,4]],[[5,6],[7,8]])).to be_a Enumerator
-            expect(MLL::plus([[1,2],[3,4]],[[5,6],[7,8]]).to_a.map(&:to_a)).to eq [[6,8],[10,12]]
+
+        end
+
+        describe "Scope" do
+
+          example "threads element‐wise over lists" do
+            expect(plus[[10,20,30],[1,2,3]]).to be_a Enumerator
+            expect(plus[[10,20,30],[1,2,3]].to_a).to eq [11,22,33]
+            expect(plus[[[1,2],[3,4]],5]).to be_a Enumerator
+            expect(plus[[[1,2],[3,4]],5].to_a.map(&:to_a)).to eq [[6,7],[8,9]]
           end
-          example "plus([[n1, n2], [n3, n4]], [n5, n6])" do
-            expect(MLL::plus([[1,2],[3,4]],[5,6])).to be_a Enumerator
-            expect(MLL::plus([[1,2],[3,4]],[5,6]).to_a.map(&:to_a)).to eq [[6,7],[9,10]]
+          example "matrices add element-wise" do
+            expect(plus[[[1,2],[3,4]],[[5,6],[7,8]]]).to be_a Enumerator
+            expect(plus[[[1,2],[3,4]],[[5,6],[7,8]]].to_a.map(&:to_a)).to eq [[6,8],[10,12]]
           end
 
         end
 
-        # TODO "Accumulate makes a cumulative sum:"
+        describe "Possible Issues" 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]
+          end
+          
+        end
 
       end
 
       # http://reference.wolfram.com/language/ref/Times.html
       describe "#times" do
 
+        describe "Details" do
+
+          example "#times[] is taken to be 1" do
+            expect(times[]).to eq 1
+          end
+          example "#times[x] is x" do
+            expect(times[5]).to eq 5
+          end
+
+        end
+
         describe "Basic Examples" do
 
-          example "times(n1, n2, n3)" do
-            # expect(MLL::times(2,3,4)).to be_a Fixnum
-            expect(MLL::times(2,3,4)).to eq 24
+          example "multiplies numbers" do
+            expect(times[2,3,4]).to eq 24
           end
-          example "times(n, [n1, n2, n3])" do
-            expect(MLL::times(2,[3,4,5])).to be_a Enumerator
-            expect(MLL::times(2,[3,4,5]).to_a).to eq [6,8,10]
+          example "threads element‐wise over lists" do
+            expect(times[[3,4,5],2]).to be_a Enumerator
+            expect(times[[3,4,5],2].to_a).to eq [6,8,10]
+            expect(times[2,3,[4,5]]).to be_a Enumerator
+            expect(times[2,3,[4,5]].to_a).to eq [24,30]
+            expect(times[[[1,2],[3,4]],[5,6]]).to be_a Enumerator
+            expect(times[[[1,2],[3,4]],[5,6]].to_a.map(&:to_a)).to eq [[5,10],[18,24]]
           end
-          example "times(n1, n2, [n3, n4])" do
-            expect(MLL::times(2,3,[4,5])).to be_a Enumerator
-            expect(MLL::times(2,3,[4,5]).to_a).to eq [24,30]
+
+        end
+
+        describe "Scope" do
+
+          example "threads element‐wise over lists" do
+            expect(times[[2,3],[4,5]]).to be_a Enumerator
+            expect(times[[2,3],[4,5]].to_a).to eq [8,15]
+            expect(times[[[1,2],[3,4]],5]).to be_a Enumerator
+            expect(times[[[1,2],[3,4]],5].to_a.map(&:to_a)).to eq [[5,10],[15,20]]
           end
-          example "times([[n1, n2], [n3, n4]], [n5, n6])" do
-            expect(MLL::times([[1,2],[3,4]],[5,6])).to be_a Enumerator
-            expect(MLL::times([[1,2],[3,4]],[5,6]).to_a.map(&:to_a)).to eq [[5,10],[18,24]]
+          example "matrices multiply element-wise" do
+            expect(times[[[4,3],[2,1]],[[5,6],[7,8]]]).to be_a Enumerator
+            expect(times[[[4,3],[2,1]],[[5,6],[7,8]]].to_a.map(&:to_a)).to eq [[20,18],[14,8]]
           end
 
         end
@@ -179,48 +236,50 @@ describe MLL do
       # http://reference.wolfram.com/language/ref/Table.html
       describe "#table" do
 
-        describe "Basic Examples" do
+        describe "Details" do
 
-          example "table(lambda, n)" do
-            expect(MLL::table(->(i){ i**2 }, 10)).to be_a Array
-            expect(MLL::table(->(i){ i**2 }, 10)).to eq [1,4,9,16,25,36,49,64,81,100]
+          example "#table[expr,spec1,spec2] is effectively equivalent to #table[#table[expr,spec2],spec1]" do
+            expect(table[->(i,j){ [i,j] }, 2, 3]).to eq table[->(i){ table[->(j){ [i,j] }, 3] }, 2]
           end
-          example "table(lambda, [min, max, step])" do
-            expect(MLL::table(->(i){ i+2 }, [0, 20, 2])).to be_a Array
-            expect(MLL::table(->(i){ i+2 }, [0, 20, 2])).to eq [2,4,6,8,10,12,14,16,18,20,22]
+
+        end
+
+        describe "Basic Examples" do
+
+          example "a table of the first 10 squares" do
+            expect(table[->(i){ i**2 }, 10]).to be_a Array
+            expect(table[->(i){ i**2 }, 10]).to eq [1,4,9,16,25,36,49,64,81,100]
           end
-          example "table(lambda, n1, n2)" do
-            # TODO example to README.rb about multiplication table
-            expect(MLL::table(->(i,j){ 10*i + j }, 4, 3)).to be_a Array
-            expect(MLL::table(->(i,j){ 10*i + j }, 4, 3)).to eq [[11,12,13],[21,22,23],[31,32,33],[41,42,43]]
+          example "a table with running from 0 to 20 in steps of 2" do
+            expect(table[->(i){ i+2 }, [0, 20, 2]]).to be_a Array
+            expect(table[->(i){ i+2 }, [0, 20, 2]]).to eq [2,4,6,8,10,12,14,16,18,20,22]
           end
-          example "table(lambda, n1, min..max, [max, min, -step])" do
-            expect(MLL::table(->(i,j,k){ [i,j,k] }, 3, 2..3, [5, 1, -2])).to be_a Array
-            expect(MLL::table(->(i,j,k){ [i,j,k] }, 3, 2..3, [5, 1, -2])).to eq \
-            [
-             [[[1, 2, 5], [1, 2, 3], [1, 2, 1]], [[1, 3, 5], [1, 3, 3], [1, 3, 1]]],
-             [[[2, 2, 5], [2, 2, 3], [2, 2, 1]], [[2, 3, 5], [2, 3, 3], [2, 3, 1]]],
-             [[[3, 2, 5], [3, 2, 3], [3, 2, 1]], [[3, 3, 5], [3, 3, 3], [3, 3, 1]]]
-            ]
+          example "make a 4×3 matrix" do
+            expect(table[->(i,j){ 10*i + j }, 4, 3]).to be_a Array
+            expect(table[->(i,j){ 10*i + j }, 4, 3]).to eq [[11,12,13],[21,22,23],[31,32,33],[41,42,43]]
           end
 
-          example "matrix_form table(lambda, n1, n2)" do
-            pending "#matrix_form is yet to be implemented"
-            expect(MLL::matrix_form MLL::table(->(i,j){ 10*i + j }, 4, 3)).to eq "
-            "
-          end
+        end
 
+        example "table(lambda, n1, min..max, [max, min, -step])" do
+          expect(table[->(i,j,k){ [i,j,k] }, 3, 2..3, [5, 1, -2]]).to be_a Array
+          expect(table[->(i,j,k){ [i,j,k] }, 3, 2..3, [5, 1, -2]]).to eq \
+          [
+           [[[1, 2, 5], [1, 2, 3], [1, 2, 1]], [[1, 3, 5], [1, 3, 3], [1, 3, 1]]],
+           [[[2, 2, 5], [2, 2, 3], [2, 2, 1]], [[2, 3, 5], [2, 3, 3], [2, 3, 1]]],
+           [[[3, 2, 5], [3, 2, 3], [3, 2, 1]], [[3, 3, 5], [3, 3, 3], [3, 3, 1]]]
+          ]
         end
 
         describe "Scope" do
 
           # TODO: "Make a triangular array:"
 
-          example "table(lambda, [list1], [list2])" do
-            expect(MLL::table(->(base, power){ base ** power }, [[1,2,4]], [[1,3,4]])).to be_a Array
-            expect(MLL::table(->(base, power){ base ** power }, [[1,2,4]], [[1,3,4]])).to eq [[1,1,1],[2,8,16],[4,64,256]]
-            expect(MLL::table(MLL::method(:plus), [[1]], [[2]])).to be_a Array
-            expect(MLL::table(MLL::method(:plus), [[1]], [[2]])).to eq [[3]]
+          example "make an array from existing lists" do
+            expect(table[->(base, power){ base ** power }, [[1,2,4]], [[1,3,4]]]).to be_a Array
+            expect(table[->(base, power){ base ** power }, [[1,2,4]], [[1,3,4]]]).to eq [[1,1,1],[2,8,16],[4,64,256]]
+            expect(table[plus, [[1]], [[2]]]).to be_a Array
+            expect(table[plus, [[1]], [[2]]]).to eq [[3]]
           end
 
         end
@@ -228,8 +287,7 @@ describe MLL do
         describe "Applications" do
 
           example "column table(binomial, )" do
-            pending "#binomial and #column are yet to be implemented"
-            fail
+            skip "#binomial and #column are yet to be implemented"
           end
 
         end
@@ -241,66 +299,97 @@ describe MLL do
 
         # TODO take from docs more examples that involve other functions
 
-        example "range( >3 args )" do
-          expect{ MLL::range(1,2,3,4) }.to raise_error ArgumentError
+        example "no args raise ArgumentError" do
+          expect{ range[] }.to raise_error ArgumentError
+        end
+        example "more than 3 args raise ArgumentError" do
+          expect{ range[1,2,3,4] }.to raise_error ArgumentError
+        end
+        example "step equal to 0 raise ArgumentError" do
+          expect{ range[1,2,0] }.to raise_error ArgumentError
+        end
+
+        describe "Details" do
+
+          example "the arguments need not be integers" do
+            expect(range[0.25,2.9,1.25]).to be_a Enumerator
+            expect(range[0.25,2.9,1.25].to_a).to eq [0.25,1.5,2.75]
+          end
+
         end
 
         describe "Basic Examples" do
 
           example "range(n)" do
-            expect(MLL::range(4)).to be_a Enumerator
-            expect(MLL::range(4).to_a).to eq [1,2,3,4]
+            expect(range[4]).to be_a Enumerator
+            expect(range[4].to_a).to eq [1,2,3,4]
           end
-          example "range(min, max)" do
-            expect(MLL::range(2,5)).to be_a Enumerator
-            expect(MLL::range(2,5).to_a).to eq [2,3,4,5]
+          example "range(n1, n2)" do
+            expect(range[2,5]).to be_a Enumerator
+            expect(range[2,5].to_a).to eq [2,3,4,5]
           end
           example "range(min, max, step)" do
-            expect(MLL::range(1,2,3)).to be_a Enumerator
-            expect(MLL::range(1,2,0.5).to_a).to eq [1,1.5,2] # can be precision problems
-            expect(MLL::range(2,6,2).to_a).to eq [2,4,6]
-            expect(MLL::range(-4,9,3).to_a).to eq [-4,-1,2,5,8]
-          end
-          example "range(max, min, -step)" do
-            expect(MLL::range(10,-5,-2).to_a).to eq [10,8,6,4,2,0,-2,-4]
-            expect(MLL::range(3,1,-1).to_a).to eq [3,2,1]
+            expect(range[1,2,0.5]).to be_a Enumerator
+            expect(range[1,2,0.5].to_a).to eq [1,1.5,2] # can be precision problems
+            expect(range[2,6,2].to_a).to eq [2,4,6]
+            expect(range[-4,9,3].to_a).to eq [-4,-1,2,5,8]
           end
 
         end
 
+        # NOTE: Wolfram Mathematica can't do this
+        example "range(max, min, -step)" do
+          expect(range[10,-5,-2]).to be_a Enumerator
+          expect(range[10,-5,-2].to_a).to eq [10,8,6,4,2,0,-2,-4]
+          expect(range[3,1,-1].to_a).to eq [3,2,1]
+        end
+
         describe "Generalizations & Extensions" do
 
-          example "range([n1, n2, n3, n4])" do
-            expect(MLL::range([5,2,6,3])).to be_a Enumerator
-            MLL::range([5,2,6,3]).each do |i|
+          example "use a list of range specifications" do
+            expect(range[[5,2,6,3]]).to be_a Enumerator
+            range[[5,2,6,3]].each do |i|
               expect(i).to be_a Enumerator
             end
-            expect(MLL::range([5,2,6,3]).to_a.map(&:to_a)).to eq [[1,2,3,4,5],[1,2],[1,2,3,4,5,6],[1,2,3]]
+            expect(range[[5,2,6,3]].to_a.map(&:to_a)).to eq [[1,2,3,4,5],[1,2],[1,2,3,4,5,6],[1,2,3]]
           end
 
         end
 
         describe "Applications" do
 
-          example "power(n1, range(n2))" do
-            pending "#power is yet to be implemented"
-            expect(power(2, range(5))).to eq [2,4,8,16,32]
+          example "produce a geometric sequence" do
+            skip "#power is yet to be implemented"
+            expect(power[2, range[5]]).to be_a Enumerator
+            expect(power[2, range[5]].to_a).to eq [2,4,8,16,32]
           end
 
         end
 
-        describe "Neat Examples" do
+        describe "Properties & Relations" do
 
-          example "range(min..max)" do
-            expect(MLL::range(1..3)).to be_a Enumerator
-            MLL::range(1..3).each do |i|
-              expect(i).to be_a Enumerator
-            end
-            expect(MLL::range(1..3).to_a.map(&:to_a)).to eq [[1],[1,2],[1,2,3]]
+          example "#range[imin,imax,di] is equivalent to #table[i,[imin,imax,di]]" do
+            expect(range[2,8,3].to_a).to eq table[->(i){ i }, [2,8,3]]
           end
-          example "range(range(range(n)))" do
-            # TODO do the same .tap thing in other type tests
-            MLL::range(MLL::range(MLL::range(3))).tap do |o|
+
+          example "use #range or #span (;;) as #part specification" do
+            skip "#span and #part are yet to be implemented"
+          end
+
+        end
+
+        example "range(min..max)" do
+          expect(range[1..3]).to be_a Enumerator
+          range[1..3].each do |i|
+            expect(i).to be_a Enumerator
+          end
+          expect(range[1..3].to_a.map(&:to_a)).to eq [[1],[1,2],[1,2,3]]
+        end
+
+        describe "Neat Examples" do
+
+          example "make nested ranges" do
+            range[range[range[3]]].tap do |o|
               expect(o).to be_a Enumerator
               o.each do |i|
                 expect(i).to be_a Enumerator
@@ -309,36 +398,64 @@ describe MLL do
                 end
               end
             end
-            expect(MLL::range(MLL::range(MLL::range(3))).to_a.map{ |i| i.to_a.map(&:to_a) }).to eq [[[1]],[[1],[1,2]],[[1],[1,2],[1,2,3]]]
+            expect(range[range[range[3]]].to_a.map{ |i| i.to_a.map(&:to_a) }).to eq [[[1]],[[1],[1,2]],[[1],[1,2],[1,2,3]]]
           end
 
-          # TODO Nest[Range,3,6]
-
         end
 
-        # TODO "Find an inverse permutation:"
-        # TODO "Use Range or Span (;;) as Part specification:"
-
       end
 
       # http://reference.wolfram.com/language/ref/Subdivide.html
       describe "#subdivide" do
 
-        example "subdivide(n)" do
-          expect(MLL::subdivide(4)).to be_a Enumerator
-          expect(MLL::subdivide(4).to_a).to eq [0,0.25,0.5,0.75,1]
+        example "no args raise ArgumentError" do
+          expect{ subdivide[] }.to raise_error ArgumentError
         end
-        example "subdivide(max, n)" do
-          expect(MLL::subdivide(10,5)).to be_a Enumerator
-          expect(MLL::subdivide(10,5).to_a).to eq [0,2,4,6,8,10]
+        example "more than 3 args raise ArgumentError" do
+          expect{ subdivide[1,2,3,4] }.to raise_error ArgumentError
         end
-        example "subdivide(min, max, n)" do
-          expect(MLL::subdivide(-1,1,8)).to be_a Enumerator
-          expect(MLL::subdivide(-1,1,8).to_a).to eq [-1,-0.75,-0.5,-0.25,0,0.25,0.5,0.75,1]
+        # example "division into 0 parts raises ArgumentError" do
+        #   expect{ subdivide[0] }.to raise_error ArgumentError
+        # end
+
+        describe "Details" do
+
+          example "generates a list of length n+1" do
+            expect(subdivide[5]).to be_a Enumerator
+            expect(subdivide[5].size).to eq 6
+          end
+
         end
-        example "subdivide(max, min, n)" do
-          expect(MLL::subdivide(1,-1,8)).to be_a Enumerator
-          expect(MLL::subdivide(1,-1,8).to_a).to eq [1,0.75,0.5,0.25,0,-0.25,-0.5,-0.75,-1]
+
+        describe "Basic Examples" do
+
+          example "subdivide the unit interval into 4 equal parts" do
+            expect(subdivide[4]).to be_a Enumerator
+            expect(subdivide[4].to_a).to eq [0,0.25,0.5,0.75,1]
+          end
+          example "subdivide the interval 0 to 10 into 5 equal parts" do
+            expect(subdivide[10,5]).to be_a Enumerator
+            expect(subdivide[10,5].to_a).to eq [0,2,4,6,8,10]
+          end
+          example "subdivide the interval -1 to 1 into 8 equal parts using machine precision" do
+            expect(subdivide[-1,1,8]).to be_a Enumerator
+            expect(subdivide[-1,1,8].to_a).to eq [-1,-0.75,-0.5,-0.25,0,0.25,0.5,0.75,1]
+          end
+
+          # NOTE: Wolfram Mathematica can't do this
+          example "subdivide(max, min, n)" do
+            expect(subdivide[1,-1,8]).to be_a Enumerator
+            expect(subdivide[1,-1,8].to_a).to eq [1,0.75,0.5,0.25,0,-0.25,-0.5,-0.75,-1]
+          end
+
+        end
+
+        describe "Properties & Relations" do
+
+          example "subdivide[xmin,xmax,n] is equivalent to xmin+(xmax-xmin)Range[0,n]/n" do
+            expect(subdivide[2,10,4].to_a).to eq plus[2,divide[times[10-2,range[0,4]],4]].to_a
+          end
+
         end
 
       end
@@ -346,16 +463,15 @@ describe MLL do
       # http://reference.wolfram.com/language/ref/NestList.html
       describe "#nest_list" do
 
-        example "#nest_list  gives a list of length n+1" do
-          expect(MLL::nest_list(->{}, 0, 5)).to be_a Enumerator
-          expect(MLL::nest_list(->(*args){}, 0, 5).to_a.size).to eq 6
+        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
         end
 
         describe "Basic Examples" do
 
-          example "'nest_list with #cos starting with 1.0)'" do
-            pending "#cos is yet to be implemented"
-            fail
+          example "???" do
+            skip "#cos (or #sqrt or anything unar is yet to be implemented"
           end
 
         end
@@ -363,8 +479,7 @@ describe MLL do
         describe "Scope" do
 
           example "nesting can return a single number" do
-            pending "#sqrt is yet to be implemented"
-            fail
+            skip "#sqrt is yet to be implemented"
           end
 
         end
@@ -372,39 +487,41 @@ describe MLL do
         describe "Applications" do
 
           example "powers of 2" do
-            expect(MLL::nest_list(->(i){ 2*i }, 1, 10)).to be_a Enumerator
-            expect(MLL::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[->(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]
           end
           example "iterates in the  problem" do
-            expect(MLL::nest_list(->(i){ i.even? ? i/2 : (i*3+1)/2 }, 100, 20)).to be_a Enumerator
-            expect(MLL::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[->(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]
           end
           example "linear congruential pseudorandom generator" do
-            expect(MLL::nest_list(->(i){ (i*59)%101 }, 1, 15)).to be_a Enumerator
-            expect(MLL::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[->(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]
           end
           example "random walk" do
-            expect(( r = Random.new(0); MLL::nest_list(->(i){ i+[-1,1][r.rand(2)] }, 0, 20) )).to be_a Enumerator
-            expect(( r = Random.new(0); MLL::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[->(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]
           end
           example "successively rotate a list" do
-            expect(MLL::nest_list(->(i){ i.rotate 1 }, [1,2,3,4], 4)).to be_a Enumerator
-            expect(MLL::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[->(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]]
           end
 
         end
 
         describe "Properties & Relations" do
 
-          # TODO "Nest gives the last element of NestList:"
+          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]
+          end
 
           example "nesting zero times simply returns to the original argument" do
-            expect(MLL::nest_list(->{fail}, 5, 0)).to be_a Enumerator
-            expect(MLL::nest_list(->(*args){fail}, 5, 0).to_a).to eq [5]
+            expect(nest_list[->{fail}, 5, 0]).to be_a Enumerator
+            expect(nest_list[->(*args){fail}, 5, 0].to_a).to eq [5]
           end
           example "#fold_list automatically inserts second arguments from a list" do
-            expect(MLL::nest_list(->(i  ){ i*2 }, 3,     4).to_a).to eq \
-                   MLL::fold_list(->(i,j){ i*j }, 3, [2]*4).to_a
+            expect(nest_list[->(i  ){ i*2 }, 3,     4].to_a).to eq \
+                   fold_list[->(i,j){ i*j }, 3, [2]*4].to_a
           end
 
         end
@@ -416,69 +533,78 @@ describe MLL do
     # http://reference.wolfram.com/language/guide/ApplyingFunctionsToLists.html
     describe "Applying Functions to Lists" do
 
+      # http://reference.wolfram.com/language/ref/FoldList.html
       describe "#fold_list" do
 
+        describe "Details" do
+
+          example "with a length n list, #fold_list generates a list of length n+1" 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
+          end
+
+        end
+
         describe "Basic Examples" do
 
-          example "fold_list(function, list)" do
-            expect(MLL::fold_list(MLL.method(:plus),[1,2,3,4])).to be_a Enumerator
-            expect(MLL::fold_list(MLL.method(:plus),[1,2,3,4]).to_a).to eq [1,3,6,10]
+          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]
           end
-          example "fold_list(function, n, list)" do
-            expect(MLL::fold_list(MLL.method(:plus),5,[1,2,3,4])).to be_a Enumerator
-            expect(MLL::fold_list(MLL.method(:plus),5,[1,2,3,4]).to_a).to eq [5,6,8,11,15]
+          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]
           end
-          example "fold_list(lambda, n, list)" do
-            expect(MLL::fold_list(->(base, power){ base ** power },2,[3,2,1])).to be_a Enumerator
-            expect(MLL::fold_list(->(base, power){ base ** power },2,[3,2,1]).to_a).to eq [2,8,64,64]
+          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]
           end
 
         end
 
         describe "Applications" do
 
-          example "fold_list(function, n, list)" do
-            expect(MLL::fold_list(MLL.method(:times), [*1..10])).to be_a Enumerator
-            expect(MLL::fold_list(MLL.method(:times), [*1..10]).to_a).to eq [1,2,6,24,120,720,5040,40320,362880,3628800]
-          end
-          example "fold_list(lambda, n, list)" do
-            expect(MLL::fold_list(->(a,b){ 10*a + b }, 0, [4,5,1,6,7,8])).to be_a Enumerator
-            expect(MLL::fold_list(->(a,b){ 10*a + b }, 0, [4,5,1,6,7,8]).to_a).to eq [0,4,45,451,4516,45167,451678]
-          end
-          example "fold_list(lambda, n, list)" do
-            expect(( r = Random.new(0); MLL::fold_list(MLL.method(:plus), 0, Array.new(20){ [-1,1][r.rand(2)] }) )).to be_a Enumerator
-            expect(( r = Random.new(0); MLL::fold_list(MLL.method(: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]
+          # 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]
           end
 
-          # TODO "Find successively deeper parts in an expression:"
+          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]
+          end
 
         end
 
         describe "Properties & Relations" do
 
-          example "#fold_list makes a list of length n+1" do
-            expect(MLL::fold_list(->{}, 0, [*1..10])).to be_a Enumerator
-            expect(MLL::fold_list(->(*args){}, 0, [*1..10]).to_a.size).to eq 11
+          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
           end
           example "folding with an empty list does not apply the function at all" do
-            expect(MLL::fold_list(->{}, 0, [])).to be_a Enumerator
-            expect(MLL::fold_list(->(*args){}, 0, []).to_a).to eq [0]
+            expect(fold_list[->{}, 0, []]).to be_a Enumerator
+            expect(fold_list[->(*args){}, 0, []].to_a).to eq [0]
           end
           example "Ruby#inject gives the last element of #fold_list" do
             f = ->(i,j){ i+j }
-            expect(MLL::fold_list(f, [1,2,3])).to be_a Enumerator
-            expect(MLL::fold_list(f, [1,2,3]).to_a.last).to eq [1,2,3].inject(&f)
+            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)
+          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
           end
-          # TODO "Functions that ignore their second argument give the same result as in NestList:"
-          # TODO "Accumulate is equivalent to FoldList with Plus:"
 
         end
 
         describe "Neat Examples" do
 
           example "compute the minimum number of coins of different value needed to make up an amount" do
-            pending "at least #mod is yet to be implemented"
-            fail
+            skip "at least #mod is yet to be implemented"
           end
 
         end
@@ -501,12 +627,13 @@ describe MLL do
 
       # TODO move #nest_list and #fold_list and others here?
 
+      # 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(MLL::nest(->(i){ (1+i)**2 }, 1, 3)).to eq 676
+            expect(nest[->(i){ (1+i)**2 }, 1, 3]).to eq 676
           end
 
         end
@@ -514,8 +641,7 @@ describe MLL do
         describe "Scope" do
 
           example "nesting can return a single number" do
-            pending "#sqrt is yet to be implemented"
-            fail
+            skip "#sqrt is yet to be implemented"
           end
 
         end
@@ -523,21 +649,18 @@ describe MLL do
         describe "Applications" do
 
           example "newton iterations for" do
-            pending "need to deal with Rationals first"
-            fail
+            skip "waiting for Rationals to be used"
           end
           example "consecutive pairs of Fibonacci numbers" do
-            pending "implement #dot ?"
-            fail
+            skip "#dot is yet to be implemented"
           end
 
         end
 
         describe "Properties & Relations" do
 
-          example "#fold automatically inserts second arguments from a list" do
-            expect(MLL::nest(->(i){       i*2 }, 3, 4)).to eq \
-                 ([2]*4).inject(3){ |i,j| i*j }
+          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 }
           end
 
         end
@@ -557,6 +680,7 @@ end
 
 __END__
 
-Table   Array
-Times   Product
-Plus    Total   Sum?
+Table     Array
+Times     Product
+Plus      Total   Sum?
+NestList  Accumulate