raskell 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe20c829bf17d4522fc5cb6359be0f2c4609e324
-  data.tar.gz: 13ea0fe6cc5e1568e89580cadb2b3d5a846a33a2
+  metadata.gz: 0e133ee451e2be310983090109ed99d82b8fa1ef
+  data.tar.gz: 9ce3847f6ebe54b79faf505f35f867c65a8e3ea3
 SHA512:
-  metadata.gz: 2af3ff60eadb54244f972c5f092c96a55e83a2641a0c0ea16974006a4a2945fff2a57ef0ad1ef6bc7dbf08722dadd619b611d413068e4c25f0e88a26e3957603
-  data.tar.gz: ea9dec9a5b3c8e16f72dc8382c4f74ed570727af0715586f662214129be9aead795a1736ba76eaead07fee4a1a729cc42d7abaf9d16d543d755f1bab5c67651a
+  metadata.gz: 66bef77ff5951dab5c044da8bedcea9b089ad883aa3391e3d6236cdf75b2aab21881895a90150b740211bc015d90682d3e957f1100ab4d8dfd0031a8d27fc5ee
+  data.tar.gz: d5321834069742a61bbcd293e1522922677da1b55ff7e2cba70d2d3b5b677907aebddaf1e030ee0974dde2d8846207ca9b2f553117916d376e3f25dd549e6860

data/README.md

@@ -1,5 +1,5 @@
 # raskell
-Making Ruby a Joy to Work With 
+Functional and Concatenative Stream Programming in Ruby
 =======
 
 
@@ -7,7 +7,7 @@ Usage:
 
 Reminder: Lambdas can be applied with [\*args] notation and .() is syntactic sugar for .call()
 ```f = ->(x) { x + 2 } ```
-```f[1]``` evaluates as ```3```
+```f[1]``` , ```f.(1)```, and ```f.call(1)``` all evaluate as ```3```
 
 
 Lambdas can be partially applied, yielding a new lambda, with call
@@ -24,7 +24,7 @@ Lambda Composition with \* (right-associative) ```( (f * g * h).(x) == f.(g.(h.(
 ```(double * minus3 * times10).(5)``` evaluates as ```94```
 
 
-Lambda Pipelining with \| (left-associative)  ``` (f | g | h).(x) == h.(g.(f.(x))) ```
+Lambda Pipelining with \| (left-associative)  ```(f | g | h).(x) == h.(g.(f.(x)))```
 ```(times10 | minus3 | double).(5)``` evaluates as ```94```
 ```(double | minus3 | times10).(5)``` evaluates as ```70```
 
@@ -32,20 +32,20 @@ Lambda Tupling with + (associative)
 ```(times10 + minus3 + double).(5)``` evaluates as ```[50, 2, 10]```
 
 Objects, when called, act like constant functions that throw away any values applied to them
-```5.call(1,2,3,[4,7])``` evaluates to ```5```
+```5.(1,2,3,[4,7])``` evaluates to ```5```
 
 Arrays, when called, map across themselves calling each element with the arguments it was called with
-```[times10, minus3, double].(5)``` evaluates to ```5```
+```[times10, minus3, double].(5)``` evaluates to ```[50, -15, 10]```
 ```[plus, times10, 3].(0,1)``` evaluates to ```[1, 0, 3]```
 Note that ```[plus,times10,3][0,1]``` evaluates to ```[plus]```, not ```[1, 0, 3]```, so be careful where you use ```func[]``` as shorthand ```func.()``` or ```func.call()```!
 
 Streams, when called, map across themselves calling each element with the arguments it was called with
-```[times10, minus3, double].to_stream.(5)``` evaluates to ```5```
+```[times10, minus3, double].to_stream.(5).to_a``` evaluates to ```[50, -15, 10]```
 ```[plus, times10, 3].to_stream.(0,1)``` evaluates to ```[1, 0, 3].to_stream```
 Note that ```[plus,times10,3].to_stream[0,1]``` evaluates to ```[plus].to_stream```, not ```[1, 0, 3].to_stream```, so be careful where you use ```func[]``` as shorthand ```func.()``` or ```func.call()```!
 
 Preface any collection function with F. to call that particular function
-```F.map(times10 * plus10).([1,2,3])``` evaluates as ```[100, 200, 300]```
+```F.map.(times10 * plus10).([1,2,3])``` evaluates as ```[100, 200, 300]```
 
 
 
@@ -65,7 +65,7 @@ Available Operators to Overload in Ruby
 Using in Raskell so far
 [], \*, \*\*, ^, \|, &, +, %, <<, >>
 
-=~ and !~ will be good for later when I have 'regular expressions' over arbitrary asterated semirings - then i can match if the data, path, whatever matches a regex of allowable types - and this gives us a powerful form of type constraint for free
+=~ and !~ will be good for later when I have 'regular expressions' over arbitrary asterated semirings - then i can match if the data, path, whatever matches a regex of allowable types - this gives us a powerful form of type constraint for free
 
 
 

data/ROADMAP.md

@@ -1,4 +1,4 @@
-Making Ruby a "Joy" to Work With In X (Easy?) Steps
+Making Ruby a Joy to Work With In X (Easy?) Steps
 
 \*I) partial application for lambdas, treat [] as .call() for lambdas, and add .call(\*args) to objects (a no-op) and arrays (map across calling element.call(\*args) for each element)
 \*II) function tupling, composition, and pipelining in the form of +,\*, and \|
@@ -6,10 +6,7 @@ Making Ruby a "Joy" to Work With In X (Easy?) Steps
 \*IV) a standard collections library based around fusable stream transducers - (flat)map, filter, fold\*, zip, append, scanl - Scala/Haskell eqv.
 \*V) add instances of from_stream(ClassName=Array) and to_stream for Dictionary, (Multi?)Set, Array, Range, String, Integer, Object, and Enumerable
 \*VI) add tupling for foldl, and (map / scanl with each other, really anything that produces as many outputs as it takes in - so might need a scanl1 and a foldl1, so we can combine any/all of them together and still succeed in only consuming a stream once) as well, so that multiple transducers can run in parallel across the same stream in a single pass
-\*VII) Implement Applicative instances for Array and Stream 
-VIII) organize code so that it is clear what consumes the entire stream strictly (foldl-based), what consumes the entire stream lazily (scanl, everything else pretty much), and what can be combined via + to avoid multiple passes over a single stream when computing multiple functions of the stream (foldl, scanl) - example, ```(F.length + F.sum + F.product + F.sum_of_squares).([1,2,3,4].to_stream)``` computes all of those statistics in a single pass, yielding ```[4, 10, 24, 30]```, and make sure that all functions are as optimized and elegantly defined as possible. -- probably need a specialized one for very large lists, one for infinite, and one for the rest
-IX) modularize for easy addition into other's projects, optimize automatically in the common cases (use array-based functions when possible instead of stream)
-X) Make everything that isn't a function a 'constant' function that implicitly pushes to an ArgumentStack once lifted, and then returns the ArgumentStack. Modify lambda calling to properly use argument stack if it is passed in, and to place unused arguments onto after calling - forking lambdas - i.e. a [fn, fn2,fn3,fn4].(), duplicate argument stacks and create unique new ones in their locations, rather than 'sharing' a common argument stack - turning Raskell into a concatenative language - a "Joy" to *work* with
-
-
-get rid of ^ for cartesian product, use for * instance instead
+\*VII) Implement Applicative instances for Proc, Array, and Stream 
+VII) modularize for easy addition into other's projects, organize code and test coverage (Procish), reduce code duplication
+IX) Document, let simmer with experience, and optimize
+X) Make everything that isn't a function a 'constant' function that implicitly pushes to an ArgumentStack once lifted, and then returns the ArgumentStack. Modify lambda calling to properly use argument stack if it is passed in, and to place unused arguments onto after calling - forking lambdas - i.e. a [fn, fn2,fn3,fn4].(), duplicate argument stacks and create unique new ones in their locations, rather than 'sharing' a common argument stack - turning Raskell into a concatenative language - a "Joy" to *work* with

data/lib/raskell/f.rb

@@ -1,1217 +1,1249 @@
-
-## module System 
-class F ## @@System||=:F to use 3;) --- or, you can just extend with System, and get the F for free.
-  # stream combinators
-  @@to_stream = ->(xs) { xs.to_stream }
-  
-  def self.to_stream
-    @@to_stream
-  end
-
-  def self.from_stream(*args)
-    if args.length > 0
-      FromStream.new().(*args)
-    else
-      FromStream.new()
+module System
+  module Collections
+    module ObjectLambdas
+      extend self
+    
+      def id
+        Identity.new # ->(x) { x }
+      end
+    
+      def equals
+        @@equals||= ->(x,y) { x == y }
+      end
+      
+      def equal
+        @@equal||= ->(x,y) { x == y }
+      end
+      
+      def eq
+        @@eq||= ->(x,y) { x === y }
+      end
+    
+      def list
+        @@list||= ->(*items) { items }
+      end
     end
-  end
-
-  def self.to_array
-    FromStream.new(Array)
-  end
-
-  def self.to_hash
-    FromStream.new(Hash)
-  end
-
-  def self.to_set
-    FromStream.new(Set)
-  end
-
-  def self.to_a
-    self.to_array
-  end
-
-  def self.to_h
-    self.to_hash
-  end
 
-  def self.infinity
-    Float::INFINITY
-  end
-  
-  def self.negative_infinity
-    -Float::INFINITY
-  end
-
-  def self.inf
-    Float::INFINITY
-  end
-
-  def self.ninf
-    -Float::INFINITY
-  end
     
-  def self.id
-    Identity.new # ->(x) { x }
-  end
-
-  def self.apply_with2
-    @@apply_with2||= ->(y, f, x) { f.(x,y)}
-  end
-
-  def self.apply
-    @@apply||= ->(f, *xs) { f.(*xs) }
-  end
-
-  def self.apply_with
-    @@apply_with||= ->(x,f) { f.(x) } # flip * apply
-  end
-
-  def self.compose
-    @@compose||= ->(f,g) { f * g }
-  end
-
-  def self.flip
-    @@flip||= -> (f,x,y) { f.(y,x) }
-  end
-
-  def self.slf
-    @@slf||= -> (f, x) { f.(x,x) } ## square = slf * times
-  end
-
-  def self.fix
-    @@fix||= ->(f, x) { 
-      result = x
-      next_result = f.(x)
-      while result != next_result
-        result = next_result
-        next_result = f.(result)
+    module ProcishLambdas
+      extend self
+    
+      def apply_with2
+        @@apply_with2||= ->(y, f, x) { f.(x,y)}
       end
-      result
-    }
-  end
-
-  ## next_stream_fn yields Nothing for stop, and the next stream to go to otherwise
-  ## yield_fn yields a Nothing for skip, and the next value to yield otherwise
-  def self.cstep
-    @@cstep||= ->(next_stream_fn, yield_fn) {
-    ## next_stream_fn :: state -> next_fn -> Maybe(stream)
-    ## yield_fn :: state -> Maybe(item)
-    next_fn = ->(state) {
-        next_stream = next_stream_fn.(state)
-        to_yield = yield_fn.(state) if to_skip != Nothing
-        if next_stream == Nothing
-          [:done]
-        elsif to_yield == Nothing
-          [:skip, next_stream]
-        else
-          [:yield, to_yield, next_stream]
-        end
-      }
-      next_fn
-    }
-  end
-
-  def self.step
-    @@step||= ->(transition_fn, yield_fn) {
-      ## transition_fn :: state -> Maybe(state)
-      ## yield_fn :: state -> Maybe(item)
-      next_fn = ->(state) {
-        next_state = transition_fn.(state)
-        to_yield = yield_fn.(state) if next_state != Nothing
-        if next_state == Nothing
-          [:done]
-        elsif to_yield == Nothing
-          [:skip, Stream.new(next_fn, next_state)]
-        else
-          [:yield, to_yield, Stream.new(next_fn, next_state)]
-        end
-      }
-      next_fn
-    }
-  end
-
-    ## booleans
-  def self.not
-    @@not||= ->(x) { !x }
-  end
     
-  def self.and
-    @@and||= ->(x,y) { x && y }
-  end
-
-  def self.nand
-    @@nand||= ->(x,y) { !(x && y) }
-  end
-
-  def self.or
-    @@or||= ->(x,y) { x || y }
-  end
-  
-  def self.nor
-    @@nor||= ->(x,y) { !x && !y }
-  end
-
-  def self.xor
-    @@xor||= ->(x,y) { !(x && y) && (x || y) }
-  end
-
-    ## numbers
-  def self.inc
-    @@inc||= ->(x) { x + 1 }
-  end
-
-  def self.dec
-    @@dec||= ->(x) { x - 1 }
-  end
+      def apply
+        @@apply||= ->(f, *xs) { f.(*xs) }
+      end
+    
+      def apply_fn
+        @@apply_fn||= -> (f, *args) { f.(*args)}
+      end
+    
+      def apply_with
+        @@apply_with||= ->(x,f) { f.(x) } # flip * apply
+      end
+    
+      def compose
+        @@compose||= ->(f,g) { f * g }
+      end
+    
+      def flip
+        @@flip||= -> (f,x,y) { f.(y,x) }
+      end
+    
+      def slf
+        @@slf||= -> (f, x) { f.(x,x) } ## square = slf * times
+      end
+    
+      def repeat
+        @@repeat||= ->(n, fn, x) {
+          result = x
+          count = n
+          while count > 0
+            result = fn.(result)
+          end
+          result
+        }
+      end
+    
+      def fix
+        @@fix||= ->(f, x) { 
+          result = x
+          next_result = f.(x)
+          while result != next_result
+            result = next_result
+            next_result = f.(result)
+          end
+          result
+        }
+      end
+    
+      ## next_stream_fn yields Nothing for stop, and the next stream to go to otherwise
+      ## yield_fn yields a Nothing for skip, and the next value to yield otherwise
+      def cstep
+        @@cstep||= ->(next_stream_fn, yield_fn) {
+        ## next_stream_fn :: state -> next_fn -> Maybe(stream)
+        ## yield_fn :: state -> Maybe(item)
+        next_fn = ->(state) {
+            next_stream = next_stream_fn.(state)
+            to_yield = yield_fn.(state)
+            if next_stream == Nothing
+              [:done]
+            elsif to_yield == Nothing
+              [:skip, next_stream]
+            else
+              [:yield, to_yield, next_stream]
+            end
+          }
+          next_fn
+        }
+      end
+    
+      def step
+        @@step||= ->(transition_fn, yield_fn) {
+          ## transition_fn :: state -> Maybe(state)
+          ## yield_fn :: state -> Maybe(item)
+          next_fn = ->(state) {
+            next_state = transition_fn.(state)
+            to_yield = yield_fn.(state) if next_state != Nothing
+            if next_state == Nothing
+              [:done]
+            elsif to_yield == Nothing
+              [:skip, Stream.new(next_fn, next_state)]
+            else
+              [:yield, to_yield, Stream.new(next_fn, next_state)]
+            end
+          }
+          next_fn
+        }
+      end
+    
+      def unfoldl
+        @@unfoldl||= -> (next_fn, stop_fn, seed) { 
+          Stream.new(step.(->(state) { stop_fn.(state) ? Nothing : next_fn.(state) }, next_fn ), seed)
+        }
+      end
+    end
 
-  def self.plus
-    @@plus||= ->(x,y) { x + y }
-  end
+    module BooleanLambdas
+      extend self
+    
+        ## booleans
+      def not
+        @@not||= ->(x) { !x }
+      end
+        
+      def and
+        @@and||= ->(x,y) { x && y }
+      end
+    
+      def nand
+        @@nand||= ->(x,y) { !(x && y) }
+      end
+    
+      def or
+        @@or||= ->(x,y) { x || y }
+      end
+      
+      def nor
+        @@nor||= ->(x,y) { !x && !y }
+      end
+    
+      def xor
+        @@xor||= ->(x,y) { !(x && y) && (x || y) }
+      end
+    
+      def ands
+        @@ands||= ->(x) { x == Nothing } * find_where.(F.equals.(false))
+      end
+    
+      def ors
+        @@ors||= ->(x) { x != Nothing } * find_where.(F.equals.(true))
+      end
+    
+    end
+    
+    module NumericLambdas
+      extend self
+    
+      def infinity
+        Float::INFINITY
+      end
+      
+      def negative_infinity
+        -Float::INFINITY
+      end
+    
+      def inf
+        Float::INFINITY
+      end
+    
+      def ninf
+        -Float::INFINITY
+      end
+    
+        ## numbers
+      def inc
+        @@inc||= ->(x) { x + 1 }
+      end
+    
+      def dec
+        @@dec||= ->(x) { x - 1 }
+      end
+    
+      def plus
+        @@plus||= ->(x,y) { x + y }
+      end
+    
+      def times
+        @@times||= ->(x,y) { x * y }
+      end
+    
+      def sub_from
+        @@sub_from||= ->(x,y) { x - y }
+      end
+    
+      def div_from
+        @@div_from||= ->(x,y) { x / y }
+      end
+      
+      def div_by
+        @@div_by||= ->(y,x) { x / y}
+      end
+    
+      def sub_by
+        @@sub_by||= ->(y,x) { x - y}
+      end
+      
+      def is_gt
+        @@is_gt||= ->(y,x) { x > y }
+      end
+      
+      def is_lt
+        @@is_lt||= ->(y,x) { x < y }
+      end
+      
+      def is_gte
+        @@is_gte||= ->(y,x) { x >= y }
+      end
+      
+      def is_lte
+        @@is_lte||= ->(y,x) { x <= y }
+      end
+      
+      def gt
+        @@gt||= ->(x,y) { x > y }
+      end
+      
+      def lt
+        @@lt||= ->(x,y) { x < y }
+      end
+      
+      def gte
+        @@gte||= ->(x,y) { x >= y }
+      end
+      
+      def lte
+        @@lte||= ->(x,y) { x <= y }
+      end
+      
+        #insert  ln, lg, log, log_base, e, pi, exp/pow, square, cube, nth_root, sqrt  here later
+      def max
+        @@max||= ->(x,y) { x >= y ? x : y}
+      end
+      
+      def min
+        @@min||= ->(x,y) { x <= y ? x : y}
+      end
+    
+      def double
+        @@double||= slf.(plus)
+      end
+    
+      def square
+        @@square||= slf.(times)
+      end
+    
+    
+    end
+    
+    module FoldableStreamLambdas
+      def foldleft
+        @@foldleft||= ->(f,u) { 
+        
+          ->(stream) {
+            next_item = stream.next_item
+            result = u
+            while next_item != [:done]
+              if next_item.first == :skip
+                
+              elsif next_item.first == :yield
+                result = f.(result, next_item[1])
+              else
+                raise "#{next_item} is a malformed stream response"
+              end
+              next_item = next_item.last.next_item
+            end
+            result  
+          } * to_stream
+        
+        }
+      end
 
-  def self.times
-    @@times||= ->(x,y) { x * y }
-  end
+      def foldr
+        @@foldr||= ->(f,u) { 
+          ->(stream) {
+            next_item = stream.next_item
+            if next_item == [:done]
+              u
+            elsif next_item.first == :skip 
+              foldr.(f, u, next_item.last)
+            elsif next_item.first == :yield
+              f.(next_item[1], foldr.(f, u, next_item.last))
+            else
+              raise "#{next_item} is improperly formed for a Stream"
+            end
+          } * to_stream
+            
+        }
+      end
 
-  def self.sub_from
-    @@sub_from||= ->(x,y) { x - y }
-  end
+      def partition_by
+        @@partition_by||= ->(fn) {
+          folded_filter = ->(f) { foldl.(->(acc, el) { f.(el) ?  acc << el : acc }, []) }
+          (folded_filter.(fn) + folded_filter.(->(x) { !fn.(x) })) * to_stream
+        }
+      end
+    
+      def bucket_by
+        @@bucket_by||= ->(fn, xs) {
+          foldl.(->(acc, el) { 
+              key = fn.(el)
+              acc[key] ||= []
+              acc[key] << el
+              acc 
+            }, {}).(to_stream.(xs))
+        }
+      end
+    
+      def bucket_by_and_summarize
+        @@bucket_by_and_summarize||= ->(group_fn, summary_fn) {
+          map.(summary_fn) * bucket_by.(group_fn)
+        }
+      end
 
-  def self.div_from
-    @@div_from||= ->(x,y) { x / y }
-  end
-  
-  def self.div_by
-    @@div_by||= ->(y,x) { x / y}
-  end
 
-  def self.sub_by
-    @@sub_by||= ->(y,x) { x - y}
-  end
-  
-  def self.equals
-    @@equals||= ->(x,y) { x == y }
-  end
-  
-  def self.equal
-    @@equal||= ->(x,y) { x == y }
-  end
-  
-  def self.eq
-    @@eq||= ->(x,y) { x === y }
-  end
-  
-  def self.is_gt
-    @@is_gt||= ->(y,x) { x > y }
-  end
-  
-  def self.is_lt
-    @@is_lt||= ->(y,x) { x < y }
-  end
-  
-  def self.is_gte
-    @@is_gte||= ->(y,x) { x >= y }
-  end
-  
-  def self.is_lte
-    @@is_lte||= ->(y,x) { x <= y }
-  end
-  
-  def self.gt
-    @@gt||= ->(x,y) { x > y }
-  end
-  
-  def self.lt
-    @@lt||= ->(x,y) { x < y }
-  end
-  
-  def self.gte
-    @@gte||= ->(x,y) { x >= y }
-  end
-  
-  def self.lte
-    @@lte||= ->(x,y) { x <= y }
-  end
-  
-    #insert  ln, lg, log, log_base, e, pi, exp/pow, square, cube, nth_root, sqrt  here later
-  def self.max
-    @@max||= ->(x,y) { x >= y ? x : y}
-  end
-  
-  def self.min
-    @@min||= ->(x,y) { x <= y ? x : y}
-  end
+    end
 
-    ## streams
-  def self.empty
-    @@empty||= Stream.new(->(x) { [:done] }, Nothing)
-  end
+    module OneForOneStreamLambdas
+      extend self
+
+      def mapleft
+        @@mapleft||= ->(fn) { 
+            ->(stream) {
+              next_fn = ->(state) {
+                next_el = state.next_item
+                if next_el == [:done]
+                  [:done]
+                elsif next_el.first == :skip
+                  [:skip, Stream.new(next_fn, next_el.last)]
+                elsif next_el.first == :yield
+                  [:yield, fn.(next_el[1]), Stream.new(next_fn, next_el.last)]
+                else
+                  raise "#{next_el.inspect} is not a valid stream state!"
+                end
+              } 
+              Stream.new(next_fn, stream) 
+            } * to_stream
+        }
+      end
 
-  def self.wrap
-    @@wrap||= ->(x) {
-      next_fn = ->(bool) { bool ? [:yield, x, Stream.new(next_fn, false)] : [:done]}
-      Stream.new(next_fn, true)
-    }
-  end
+      def scanleft
+        @@scanleft||= ->(f,u) { 
+          ->(stream) {
+            next_fn = ->(state) {
+              result_so_far = state.first
+              strm = state.last
+              next_item = strm.next_item
+              tag = next_item[0]
+              val = next_item[1]
+              next_stream = next_item.last
+              if tag == :done
+                [:done]
+              elsif tag == :skip
+                [:skip, Stream.new(next_fn, [result_so_far, next_stream])]
+              elsif tag == :yield
+                new_result = f.(result_so_far, val)
+                [:yield, new_result, Stream.new(next_fn, [new_result, next_stream]) ]
+              else
+                raise "#{next_item} is a malformed stream response"
+              end
+            }
+            Stream.new(next_fn, [u, stream])
+          } * to_stream
+        
+        }
+      end
 
-  def self.cons
-   @@cons||= ->(el) { 
-      ->(stream) {
-        Stream.new(->(x) { [:yield, el, stream] } , Nothing) 
-      } * to_stream
-    }
-  end
+      def zip_with
+        @@zip_with||= ->(fn) {
+          ->(left_stream, right_stream, *streams) {
+              streams = ([left_stream, right_stream] + streams).map(&:to_stream)
+              next_fn = ->(state) {
+                val_so_far = state.first
+                strms = state.drop(1)
+                next_stream = strms.first
+                next_item = next_stream.next_item
+                new_streams = strms.drop(1) + [next_stream.next_item.last == :done ? empty : next_item.last]
+                tag = next_item.first
+                val = tag == :done ? nil : next_item[1]
+                if tag == :done
+                  [:done]
+                elsif tag == :skip
+                  [:skip, Stream.new(next_fn, [val_so_far] +  new_streams)]
+                elsif tag == :yield && val_so_far.length == streams.length - 1
+                  [:yield, fn.(*(val_so_far + [val])), Stream.new(next_fn, [[]] + new_streams)]
+                elsif tag == :yield
+                  [:skip, Stream.new(next_fn, [val_so_far + [val]] + new_streams)]
+                else
+                  raise "#{next_item} is a malformed stream response!"
+                end
+              }
+        
+              Stream.new(next_fn, [[]] + streams)
+            }
+        }
+      end
 
+      def replace_with
+        @@replace_with||= ->(to_replace_with, to_replace) { map.(->(x) { x == to_replace ? to_replace_with : x }) }
+      end
 
-  def self.first
-    @@first||= -> (stream) { ## should offer an equivalent that returns a stream with a single element
-      next_item = stream.next_item
-      while next_item.first == :skip
-        next_item = next_item.last.next_item
+    end
+    
+    module HigherOrderStreamLambdas
+      extend self
+    
+      def flatmap
+        @@flatmap||= ->(fn) { 
+        
+           ->(stream) {
+            next_fn = ->(next_el) {
+              state = next_el.first
+              potential_stream = next_el.last
+              if potential_stream == Nothing
+                next_el = state.next_item
+                if next_el == [:done]
+                  [:done]
+                elsif next_el.first == :skip
+                  [:skip, Stream.new(next_fn, [next_el.last, Nothing])]
+                elsif next_el.first == :yield
+                  [:skip, Stream.new(next_fn, [next_el.last, fn.(next_el[1])])]
+                else
+                  raise "#{next_el.inspect} is not a valid stream state!"
+                end
+              else
+                next_el = potential_stream.next_item
+                if next_el == [:done]
+                  [:skip, Stream.new(next_fn, [state, Nothing])]
+                elsif next_el.first == :skip
+                  [:skip, Stream.new(next_fn, [state, next_el.last])]
+                elsif next_el.first == :yield
+                  [:yield, next_el[1], Stream.new(next_fn, [state, next_el.last])]
+                else
+                  raise "#{next_el.inspect} is not a valid stream state!"
+                end
+              end
+            }
+            Stream.new(next_fn, [stream, Nothing]) 
+          } * to_stream
+        
+        }
+      end
+    
+      def filter
+        @@filter||= ->(fn) { 
+          ->(stream) {
+            next_fn = ->(state) {
+              next_el = state.next_item
+              if next_el == [:done]
+                [:done]
+              elsif next_el.first == :skip || (next_el.first == :yield && !fn.(next_el[1]))
+                [:skip, Stream.new(next_fn, next_el.last)]
+              elsif next_el.first == :yield && fn.(next_el[1])
+                [next_el.first, next_el[1], Stream.new(next_fn, next_el.last)]
+              else
+                raise "#{next_el.inspect} is not a valid stream state!"
+              end
+            }
+            Stream.new(next_fn, stream) 
+          } * to_stream
+        }
+      end
+      
+      def find_where
+        @@find_where||= ->(fn){ first * filter.(fn) }
+      end
+      
+      def find_last_where
+        @@find_last_where||= ->(fn){ last * filter.(fn) }
+      end
+    
+      def first_index_where
+        @@first_index_where||= ->(fn) { first * find_where.( fn * last ) * zip_with_index }
+      end
+      
+      def last_index_where
+        @@last_index_where||= ->(fn) { first * find_last_where.( fn * last ) * zip_with_index }
+      end
+    
+      def all?
+        @@all_p||= ->(f) { ->(x) { x == Nothing } * find_where.(->(x) { !f.(x)})}
+      end ## this is going to become equal.(Nothing) * first * find_where.(F.not.(f))
+      
+      def any?
+        @@any_p||= ->(f) { ->(x) { x != Nothing } * find_where.(f)}
       end
-      next_item.first == :yield ? next_item[1] : Nothing
-    } * to_stream
-  end
-
-  def self.rest
-    @@rest||= -> (stream) { 
-      next_item = stream.next_item
-      next_item == [:done] ? Nothing : next_item.last
-    } * to_stream
-  end
-
-  def self.take
-    @@take||= ->(n) {
-      raise("#{n} must be a positive number") if n < 0
-      ->(stream) {
-        next_fn = step.(->(state){
-            if state.first == 0
-              Nothing
-            else
-              next_item = state.last.next_item
-              count = next_item.first == :skip ? state.first : state.first-1
-              next_item == [:done] ? Nothing : [count, next_item.last]
-            end
-          },
-      ->(state) { 
-            next_item = state.last.next_item
-            next_item.first == :yield ? next_item[1] : Nothing
-          })
-        Stream.new(next_fn, [n, stream])
-      } * to_stream
-    }
-  end 
-
-  def self.drop
-    @@drop||= ->(n) {
-      raise("#{n} must be a positive number") if n < 0
-      ->(stream) {
-        next_fn = step.(->(state){
-            next_item = state.last.next_item
-            count = next_item.first == :skip || state.first == 0 ? state.first : state.first-1
-            next_item == [:done] ? Nothing : [count, next_item.last]
-          },
-      ->(state) { 
-            count = state.first
-            next_item = state.last.next_item
-            next_item.first == :yield && count == 0 ? next_item[1] : Nothing
-          })
-        Stream.new(next_fn, [n, stream])
-      } * to_stream
-    }
-  end 
-
-  def self.drop_except
-    @@drop_except||= ->(n) {
-      raise("#{n} must be a positive number") if n < 0
-      ->(stream) {
-        next_fn = ->(strm) { 
-          potential_stream = take.(n+1) << strm
-          if (length.(potential_stream)) < n+1
-            [:skip, take.(n) << strm]
-          else
+      
+      def slice_by
+        @@slice_by||= ->(starts_with_fn, ends_with_fn) { take_until.(ends_with_fn) * drop_until.(starts_with_fn) }
+      end
+    
+      def split_by
+        @@split_by = ->(fn) { take_while.(fn) + drop_while.(fn) }
+      end
+    
+      def group_by
+        @@group_by||= ->(fn) { 
+          next_fn = ->(state) {
+            strm = state.last
+            group = state.first
             next_item = strm.next_item
             tag = next_item.first
             val = next_item[1]
-            next_strm = next_item.last
-            if tag == :done
+            next_stream = next_item.last
+            if tag == :done && group == []
               [:done]
+            elsif tag == :done
+              [:yield, group, empty]
             elsif tag == :skip
-              [:skip, next_strm]
+              [:skip, Stream.new(next_fn, [group, next_stream])]
+            elsif tag == :yield && (group.length == 0 || fn.(val) == fn.(group.last))
+              [:skip, Stream.new(next_fn, [group + [val], next_stream])]
             elsif tag == :yield
-              [:skip, next_strm]
+              [:yield, group, Stream.new([[], next_stream])]
             else
               raise "#{next_item} is a malformed stream response!"
             end
+          }
+          Stream.new(next_fn, [[], state])
+        } * to_stream
+      end
+    
+      def window_by
+        @@window_by||= self.group_by ## basically, window_by is group_by, but where you pass it a relation (a true/false function) instead of an arbitrary function
+      end
+    
+    end
+    
+    module StreamLambdas
+      extend self
+    
+    
+      def empty?
+        @@empty_p||= F.equal.(empty)
+      end
+      
+      def null?
+        @@null_p||= F.equal.(empty)
+      end
+    
+      def empty
+        @@empty||= Stream.new(->(x) { [:done] }, Nothing)
+      end
+    
+      def wrap
+        @@wrap||= ->(x) {
+          next_fn = ->(bool) { bool ? [:yield, x, Stream.new(next_fn, false)] : [:done]}
+          Stream.new(next_fn, true)
+        }
+      end
+    
+      def cons
+       @@cons||= ->(el) { 
+          ->(stream) {
+            Stream.new(->(x) { [:yield, el, stream] } , Nothing) 
+          } * to_stream
+        }
+      end
+    
+    
+      def first
+        @@first||= -> (stream) { ## should offer an equivalent that returns a stream with a single element
+          next_item = stream.next_item
+          while next_item.first == :skip
+            next_item = next_item.last.next_item
           end
+          next_item.first == :yield ? next_item[1] : Nothing
+        } * to_stream
+      end
+    
+      def rest
+        @@rest||= -> (stream) { 
+          next_item = stream.next_item
+          next_item == [:done] ? Nothing : next_item.last
+        } * to_stream
+      end
+    
+      def snoc
+        @@snoc||= ->(el) {
+    
+           ->(stream) { 
+            # next_fn = step.(->(stream) {
+            #     next_item = stream.next_item
+            #     next_item == [:done] ? wrap.(el) : next_item.last
+            #   },
+            #   ->(stream) {
+            #     next_item = stream.next_item
+            #     next_item.first == :skip ? Nothing : next_item[1]
+            # })
+            next_fn = ->(s) {
+              next_item = s.next_item
+              if next_item == [:done]
+                [:skip, wrap.(el)]
+              elsif next_item.first == :skip
+                [:skip, Stream.new(next_fn, next_item.last)]
+              elsif next_item.first == :yield
+                [:yield, next_item[1], Stream.new(next_fn, next_item.last)]
+              else 
+                raise "#{next_item} is a malformed stream result"
+              end
+            }
+            Stream.new(next_fn, stream)
+          } * to_stream
         }
-        Stream.new(next_fn, stream)
-      } * to_stream
-    }
-  end
-
-  def self.init
-    @@init||= ->(stream) { 
-      next_fn = ->(state) {
-        strm = state.last
-        next_item = strm.next_item
-        if next_item == [:done] && state.first == Nothing
-          raise "init requires a stream length of at least 1"
-        elsif next_item == [:done]
-          [:done]
-        elsif next_item.first == :skip 
-          [:skip, Stream.new(next_fn, [state.first, next_item.last])]
-        elsif next_item.first == :yield && state.first == Nothing
-          [:skip, Stream.new(next_fn, [next_item[1], next_item.last])]
-        elsif next_item.first == :yield
-          [:yield, state.first, Stream.new(next_fn, [next_item[1], next_item.last])]
-        else
-          raise "#{next_item} is a malformed stream response"
-        end
-      }
-      Stream.new(next_fn, [Nothing, stream])
-    } * to_stream
-  end
-
-  def self.take_while
-    @@take_while||= ->(fn) {
-      raise("take_while requires a function") unless fn.kind_of?(Proc)
-      ->(stream) {
-        next_fn = ->(state) {
-            next_item = state.next_item
-            tag = next_item.first
-            val = next_item[1]
-            next_stream = next_item.last
-            if tag == :done || (tag == :yield && !fn.(val))
+      end
+    
+      def init
+        @@init||= ->(stream) { 
+          next_fn = ->(state) {
+            strm = state.last
+            next_item = strm.next_item
+            if next_item == [:done] && state.first == Nothing
+              raise "init requires a stream length of at least 1"
+            elsif next_item == [:done]
               [:done]
-            elsif tag == :skip
-              [:skip, Stream.new(next_fn, next_stream)]
-            elsif tag == :yield
-              [:yield, val, Stream.new(next_fn, next_stream)]
+            elsif next_item.first == :skip 
+              [:skip, Stream.new(next_fn, [state.first, next_item.last])]
+            elsif next_item.first == :yield && state.first == Nothing
+              [:skip, Stream.new(next_fn, [next_item[1], next_item.last])]
+            elsif next_item.first == :yield
+              [:yield, state.first, Stream.new(next_fn, [next_item[1], next_item.last])]
             else
-              raise("#{next_item} is a malformed stream response!")
+              raise "#{next_item} is a malformed stream response"
             end
-        }
-        Stream.new(next_fn, stream)
-      } * to_stream
-    }
-  end 
-
-  def self.drop_while
-    @@drop_while||= ->(fn) {
-      raise("drop_while requires a function") unless fn.kind_of?(Proc)
-      ->(stream) {
-        next_fn = ->(state) {
-            next_item = state.next_item
-            tag = next_item.first
-            val = next_item[1]
-            next_strm = next_item.last
-            if tag == :done
-              [:done]
-            elsif tag == :skip || (tag == :yield && fn.(val))
-              [:skip, Stream.new(next_fn, next_strm)]
-            elsif tag == :yield
-              [:yield, val, next_strm]
+          }
+          Stream.new(next_fn, [Nothing, stream])
+        } * to_stream
+      end
+    
+      def append
+        @@append||= ->(left_stream) {
+          ->(right_stream) {
+            left_next_fn = ->(stream) {
+              next_el = stream.next_item
+              if next_el == [:done]
+                [:skip, right_stream]
+              elsif next_el.first == :skip
+                [:skip, Stream.new(left_next_fn, next_el.last)]
+              elsif next_el.first == :yield
+                [next_el.first, next_el[1], Stream.new(left_next_fn, next_el.last)]
+              else
+                raise "#{next_el.inspect} is not a valid stream state!"
+              end
+            }
+            
+            Stream.new(left_next_fn, left_stream)
+          } * to_stream
+          
+        } * to_stream
+      end
+    
+      def concat
+        @@concat||= flatmap.(to_stream)
+      end
+    
+      def enconcat
+        @@enconcat||= ->(left_stream, el) { append.(left_stream.to_stream) * cons.(el) * to_stream }
+      end
+    
+      def initial
+        @@initial||= ->(stream) {
+          next_fn = ->(strm) {
+            next_item = strm.next_item
+            if next_item.first == :done
+              raise "Must have at least one item inside of the stream!"
+            elsif next_item.first == :yield
+              [:yield, next_item[1], empty]
+            elsif next_item.first == :skip
+              [:skip, next_item.last]
             else
               raise("#{next_item} is a malformed stream response!")
             end
-        }
-        Stream.new(next_fn, stream)
-      } * to_stream
-    }
-  end 
-
-  def self.take_until
-    @@take_until||= ->(fn) {
-      raise("take_while requires a function") unless fn.kind_of?(Proc)
-      ->(stream) {
-        next_fn = ->(state) {
-            next_item = state.next_item
-            tag = next_item.first
-            val = next_item[1]
-            next_stream = next_item.last
-            if tag == :done || (tag == :yield && fn.(val))
-              [:done]
-            elsif tag == :skip
-              [:skip, Stream.new(next_fn, next_stream)]
-            elsif tag == :yield
-              [:yield, val, Stream.new(next_fn, next_stream)]
+          }
+          Stream.new(next_fn, stream)
+          }
+      end
+    
+      def final
+        @@final||= -> (stream) { 
+          next_fn = ->(state) {
+            prev_step = state.first
+            strm = state.last
+            raise("Must have at least one item inside of the stream!") if prev_step == [:done]
+            next_item = strm.next_item
+            if prev_step.first == :skip
+              [:skip, Stream.new(next_fn, [next_item, next_item.last])]
+            elsif next_item == [:done]
+              [:yield, prev_step[1], empty]
+            elsif next_item.first == :yield
+              [:skip, Stream.new(next_fn, [next_item, next_item.last])]
+            elsif next_item.first == :skip
+              [:skip, Stream.new(next_fn, [prev_step, next_item.last])]
             else
-              raise("#{next_item} is a malformed stream response!")
+              raise "#{next_item} is a malformed stream result"
             end
-        }
-        Stream.new(next_fn, stream)
-      } * to_stream
-    }
-  end 
-
-  def self.drop_until
-    @@drop_until||= ->(fn) {
-      raise("drop_while requires a function") unless fn.kind_of?(Proc)
-      ->(stream) {
-        next_fn = ->(state) {
-            next_item = state.next_item
-            tag = next_item.first
-            val = next_item[1]
-            next_strm = next_item.last
-            if tag == :done
-              [:done]
-            elsif tag == :skip || (tag == :yield && !fn.(val))
-              [:skip, Stream.new(next_fn, next_strm)]
-            elsif tag == :yield
-              [:yield, val, next_strm]
+          }
+          next_item = stream.next_item
+          Stream.new(next_fn, [next_item, next_item.last])
+        } * to_stream
+      end
+    
+    
+      def rotate
+        @@rotate||= ->(s) { append.(tail.(s), initial.(s)) }
+      end
+        
+    
+      def interleave
+        @@interleave||= ->(xs, *ys) { ys.length > 0 ? (concat * zip).(*([xs]+ys)) : ->(zs, *ys) { concat << zip.(*([xs,zs]+ys)) } }
+      end ## you can undo this with % n, where n is the number of streams
+      
+      def intercalate
+        @@intercalate||= ->(xs, xss) { concat.intersperse.(xs, xss) }
+      end
+    
+      def suffixes
+        @@suffixes||= ->(stream) {
+          next_fn = ->(strm) {
+            next_item = strm.next_item
+            if next_item.first == :done
+              [:yield, strm, empty]
+            elsif next_item.first == :yield
+              [:yield, strm, Stream.new(next_fn, next_item.last)]
+            elsif next_item.first == :skip
+              [:skip, Stream.new(next_fn, next_item.last)]
             else
               raise("#{next_item} is a malformed stream response!")
             end
-        }
-        Stream.new(next_fn, stream)
-      } * to_stream
-    }
-  end 
-
-  def self.zip_with
-    @@zip_with||= ->(fn) {
-      ->(left_stream, right_stream, *streams) {
-          streams = ([left_stream, right_stream] + streams).map(&:to_stream)
-          next_fn = ->(state) {
-            val_so_far = state.first
-            strms = state.drop(1)
-            next_stream = strms.first
-            next_item = next_stream.next_item
-            new_streams = strms.drop(1) + [next_stream.next_item.last == :done ? empty : next_item.last]
-            tag = next_item.first
-            val = tag == :done ? nil : next_item[1]
-            if tag == :done
-              [:done]
-            elsif tag == :skip
-              [:skip, Stream.new(next_fn, [val_so_far] +  new_streams)]
-            elsif tag == :yield && val_so_far.length == streams.length - 1
-              [:yield, fn.(*(val_so_far + [val])), Stream.new(next_fn, [[]] + new_streams)]
-            elsif tag == :yield
-              [:skip, Stream.new(next_fn, [val_so_far + [val]] + new_streams)]
-            else
-              raise "#{next_item} is a malformed stream response!"
-            end
           }
+          Stream.new(next_fn, stream)
+        } * to_stream
+      end
+    
+    
+      def prefixes
+        @@prefixes||= foldr.(->(el, acc) { cons.(empty, map.(cons.(el), acc)) }, wrap.(empty))
+      end
+    
+        ## stream functions
+      def last
+        @@last||= first * final
+      end
+    
+      def uncons
+        @@uncons||= ->(s) { append(first.(l), wrap(rest.(l)))  } * to_stream
+      end
+    
+      def unsnoc
+        @@unsnoc||= ->(s) { append(wrap(init.(s)), last.(s)) } * to_stream
+      end
+    
+      def reverse
+        @@reverse||= foldl.(->(acc, el) { cons.(el, acc) }, []) ## or foldr.(->(el,acc) { snoc.(acc, el) }
+      end
+      
+      def length
+        @@length||= foldl.(inc, 0)
+      end
+    
+      def length_at_least
+        @@length_at_least||= ->(n) { ->(x) { x != Nothing } * find_where.(equals.(n)) * scanl.(inc, 0) }
+      end
+        
+      def replace
+        @@replace||= ->(to_replace, to_replace_with) {map.(->(x) { x == to_replace ? to_replace_with : x })}
+      end
+    
+      def zip
+        @@zip||= zip_with.(list)
+      end
+    
+      def zip_with_index
+        @@zip_with_index||= F.zip_with.(F.list).(F.range.(0, F.infinity))
+      end
+    
+      def transpose
+        @@transpose||= ->(stream_of_streams) { zip.( *(stream_of_streams.to_stream) ) }
+      end
+      
+      def tail
+        @@tail||= rest
+      end
+    
+      def prefix
+        @@prefix||= init
+      end
+    
+      def suffix
+        @@suffix||= rest
+      end
+    
+      def head
+        @@head||= first
+      end
+    
+      def inits
+        @@inits||= prefixes
+      end
+    
+      def tails
+        @@tails||= suffixes
+      end
+    
+      def starts_with?
+        @@starts_with||= ->(prefix, stream) { F.ands << zip_with.(equals, prefix, stream) }
+      end
+    
+      def ends_with?
+        @@ends_with||= ->(slice) { F.equal.(slice) * drop_except.(length.(slice)) }
+      end
+      
+      def intersperse
+        @@intersperse||= ->(x, xs) { rest * flatmap.(->(y) { [x, y].to_stream }) << xs.to_stream }
+      end
+    
+      def contains?
+        @@contains_p||= ->(el) { F.not * F.equal.(Nothing) * find_where.(equals.(el)) }
+      end
+    
+      def does_not_contain?
+        @@does_not_contain_p||= ->(el) { F.equal.(Nothing) * find_where.(equals.(el)) }
+      end
+      
+      def contains_slice?
+        @@contains_slice_p||= ->(slice) { any?.(starts_with.(slice)) * tails }
+      end
+    
+      def partition_at
+        @@partition_at||= ->(n) { take.(n) + drop.(n) }
+      end
+      
+      def last_index_of
+        @@last_index_of||= ->(x) { last_index_where.(F.equal.(x)) }
+      end
+      
+      def first_index_of
+        @@first_index_of||= ->(x) { first_index_where.( F.equal.(x) ) }
+      end
+    
+      def union
+        @@union||= ->(xs) {
+          ->(ys) {
+              to_stream * to_set << append.(xs, ys)
+            } * to_stream
+        } * to_stream
+      end
     
-          Stream.new(next_fn, [[]] + streams)
+      def intersect
+        @@intersect||= ->(xs) {
+          ->(ys) {
+              to_stream << (to_set.(xs) & to_set.(ys))
+            } * to_stream
+        } * to_stream
+      end
+    
+      def difference
+        @@difference||= ->(xs) {
+          ->(ys) {
+              to_remove = to_set.(ys)
+              filter.(->(x) { !ys.include?(x)}) << xs
+            } * to_stream
+        } * to_stream
+      end
+    
+      def cartesian_product
+        @@cartesian_product||= ->(xs) {
+          ->(ys) {
+              flatmap.(->(x) { map.(->(y) { [x,y] }, ys) }, xs)
+            } * to_stream
+        } * to_stream
+      end
+    
+      def unzip
+        @@unzip||= ->(xs) {
+          map.(first) + map.(last) << xs
+        } * to_stream
+      end
+    
+      def window
+        @@window||= ->(n) {
+          map.(take.(n)) * suffixes
         }
-    }
-  end
-
-    ## lists
-  def self.list
-    @@list||= ->(*items) { items }
-  end
-
-  def self.empty?
-    @@empty_p||= F.equal.(empty)
-  end
-  
-  def self.null?
-    @@null_p||= F.equal.(empty)
-  end
-
-  def self.double
-    @@double||= slf.(plus)
-  end
-
-  def self.square
-    @@square||= slf.(times)
-  end
-
-  def self.app
-    @@app||= ->(*fs) { apply.(fs.first, fs.drop(1)) }
-  end
-  
-  def self.snoc
-    @@snoc||= ->(el) {
-
-       ->(stream) { 
-        # next_fn = step.(->(stream) {
-        #     next_item = stream.next_item
-        #     next_item == [:done] ? wrap.(el) : next_item.last
-        #   },
-        #   ->(stream) {
-        #     next_item = stream.next_item
-        #     next_item.first == :skip ? Nothing : next_item[1]
-        # })
-        next_fn = ->(s) {
-          next_item = s.next_item
-          if next_item == [:done]
-            [:skip, wrap.(el)]
-          elsif next_item.first == :skip
-            [:skip, Stream.new(next_fn, next_item.last)]
-          elsif next_item.first == :yield
-            [:yield, next_item[1], Stream.new(next_fn, next_item.last)]
-          else 
-            raise "#{next_item} is a malformed stream result"
+      end
+    
+      def subsequences
+        @@subsequences||= ->() { ## Using the applicative instance for <**>, which is ^ in Raskell
+          subs = ->(ys) { ys == empty ? wrap.(empty) : subs.(rest.(ys)) ^ [F.id, F.cons.(first.(ys))].to_stream }
+        }.() #wrap.(empty)
+      end
+        ## Using Control.Applicative
+        # subs [] = [[]]
+        # subs (@@x||=xs) = subs xs <**> [id, (x :)] 
+        ## subsequences is useful for fuzzy sequence matching style algorithms a la command tab in sublime, 
+        ### or figuring out if some melody or progressionis an elaboration of another (same thing), etc...
+        ## is there any way to do this with a left fold instead of a right one?
+    
+    
+      def continuous_subsequences
+        @@continuous_subsequences||= filter.(F.not * empty?) * flatmap.(prefixes) * suffixes
+      end
+      ## continuous subsequences is useful for exact inside sequence matching a la find in sublime
+        
+      def quicksort
+        ->(xs) {
+          if empty?.(xs)
+            empty
+          else
+            pivot = head.(xs)
+            partitions = (F.map.(self.quicksort) * partition_by.(F.is_lte.(pivot)) << tail.(xs)).to_a
+            append.(partitions[0],cons.(pivot, partitions[1]))
           end
+        } * to_stream ### if only this wasn't infinitely recursing...
+     end
+    
+     def group 
+        @@group||= ->(xs) { group_by.(id) }
+      end
+    
+    end
+    
+    module NumericStreamLambdas
+      extend self
+    
+      def range ## count from the first to the second by increments of one
+        @@range||= ->(begin_with, end_with) {
+          (if begin_with <= end_with
+            stream_next_fn = ->(n) { n > end_with  ?  [:done]  :  [:yield, n, Stream.new(stream_next_fn, n + 1)] }
+            Stream.new(stream_next_fn, begin_with)
+          else
+            stream_next_fn = ->(n) { n < end_with  ?  [:done]  :  [:yield, n, Stream.new(stream_next_fn, n - 1)] }
+            Stream.new(stream_next_fn, begin_with)
+          end)
         }
-        Stream.new(next_fn, stream)
-      } * to_stream
-    }
-  end
-
-  def self.zip
-    @@zip||= zip_with.(list)
-  end
-
-  def self.unfoldl
-    @@unfoldl||= -> (next_fn, stop_fn, seed) { 
-      stream_next_fn = ->x { x }
-      Stream.new(stream_next_fn, seed)
-    }
-  end
+      end
+    
+      def naturals
+        @@naturals||= range.(1, infinity)
+      end
+    
+      def maximum  
+        @@maximum||= foldl.(max, negative_infinity)
+      end
+    
+      def minimum
+        @@minimum||= foldl.(min, infinity)
+      end
+    
+      def maximum_by
+        @@maximum_by||= ->(fn) { foldl.(->(max_so_far, el) { max_so_far == Nothing || fn.(el) > fn.(max_so_far) ? el : max_so_far}, Nothing) }
+      end
+      
+      def minimum_by
+        @@minimum_by||=  ->(fn) { foldl.(->(min_so_far, el) { min_so_far == Nothing || fn.(el) < fn.(min_so_far) ? el : min_so_far}, Nothing) }
+      end
+    
+      def sum
+        @@sum||= foldl.(plus, 0)
+      end
+    
+      def product
+        @@product||= foldl.(times, 1)
+      end
+    
+      def mean
+        @@mean||= ->(l) { div_from.(*( (sum + length).(l) )) }
+      end ## this works because (sum + length).(l)== [sum.(l), length.(l)]
+      
+      def sum_of_squares  
+        @@sum_of_squares||= sum * map.(square)
+      end
+    
+      ## this is a one-pass algorithm, but only an estimate
+        #sum_of_squares_of_differences_from_mean_iterative
+        ## - need length, sum, sum_of_squares, M1,M2,M3, deltas, etc... see @@https||=//en.wikipedia.org/wiki/Algorithms_for_calculating_variance
+        ## population_variance
+        ## sample_variance
+        #->(l) { 
+        #  len, sm, sm_sqrs = (length + sum + sum_of_squares).(l)
+        #}
+    
+      ## this is a two-pass algorithm
+        
+      def sum_of_differences_from_estimated_mean_two_pass
+        @@sum_of_differences_from_estimated_mean||= ->(xs) { sum * map.(square * sub_by.(mean.(xs))) << xs }
+      end
 
+      ## one pass might involve a scanl for (length, sum, flip * const), which is then mapped across to produce (mean, difference_from_mean, square_difference_from_mean, M2, ....), which is then scanl'd to summarize in some way, doing it all in a single pass.... I wonder if grouping the data and then transposing, and concatenating, then running the same query against it after to see how the values change as a stability measure.
+    
+    #so to produce quicksort - foldl across the stream producing a tree, where inserting each element takes worst-case log(n), then call to_stream, which to produce all elements takes o(n)
 
-  def self.transducer
-    @@transducer||= ->(next_val_fn, next_state_fn, stop_fn) {
-      ->(stream) {
-        next_fn = ->(state) {
-          if stop_fn.(state)
-            [:done]
-          elsif (next_val = next_val_fn.(state)) == Nothing
-            [:skip, next_state_fn.(state)]
-          else
-            [:yield,  next_val_fn.(state), next_state_fn.(state)]
-          end
+    
+    end
+    
+    module StreamDropAndTakeLambdas
+      extend self
+    
+      ## there are so many of these I pulled them into their own
+      def drop
+        @@drop||= ->(n) {
+          raise("#{n} must be a positive number") if n < 0
+          ->(stream) {
+            next_fn = step.(->(state){
+                next_item = state.last.next_item
+                count = next_item.first == :skip || state.first == 0 ? state.first : state.first-1
+                next_item == [:done] ? Nothing : [count, next_item.last]
+              },
+          ->(state) { 
+                count = state.first
+                next_item = state.last.next_item
+                next_item.first == :yield && count == 0 ? next_item[1] : Nothing
+              })
+            Stream.new(next_fn, [n, stream])
+          } * to_stream
         }
-        Stream.new(next_fn, stream)
-      } * to_stream
-    }
-  end
-
-  def self.mapleft
-    @@mapleft||= ->(fn) { 
-        ->(stream) {
-          next_fn = ->(state) {
-            next_el = state.next_item
-            if next_el == [:done]
-              [:done]
-            elsif next_el.first == :skip
-              [:skip, Stream.new(next_fn, next_el.last)]
-            elsif next_el.first == :yield
-              [:yield, fn.(next_el[1]), Stream.new(next_fn, next_el.last)]
-            else
-              raise "#{next_el.inspect} is not a valid stream state!"
-            end
-          } 
-          Stream.new(next_fn, stream) 
-        } * to_stream
-    }
-  end
-
-  def self.foldleft
-    @@foldleft||= ->(f,u) { 
+      end 
     
-      ->(stream) {
-        next_item = stream.next_item
-        result = u
-        while next_item != [:done]
-          if next_item.first == :skip
-            
-          elsif next_item.first == :yield
-            result = f.(result, next_item[1])
-          else
-            raise "#{next_item} is a malformed stream response"
-          end
-          next_item = next_item.last.next_item
-        end
-        result  
-      } * to_stream
+      def take
+        @@take||= ->(n) {
+          raise("#{n} must be a positive number") if n < 0
+          ->(stream) {
+            next_fn = step.(->(state){
+                if state.first == 0
+                  Nothing
+                else
+                  next_item = state.last.next_item
+                  count = next_item.first == :skip ? state.first : state.first-1
+                  next_item == [:done] ? Nothing : [count, next_item.last]
+                end
+              },
+          ->(state) { 
+                next_item = state.last.next_item
+                next_item.first == :yield ? next_item[1] : Nothing
+              })
+            Stream.new(next_fn, [n, stream])
+          } * to_stream
+        }
+      end 
     
-    }
-  end
-
-  def self.scanleft
-    @@scanleft||= ->(f,u) { 
-      ->(stream) {
-        next_fn = ->(state) {
-          result_so_far = state.first
-          strm = state.last
-          next_item = strm.next_item
-          tag = next_item[0]
-          val = next_item[1]
-          next_stream = next_item.last
-          if tag == :done
-            [:done]
-          elsif tag == :skip
-            [:skip, Stream.new(next_fn, [result_so_far, next_stream])]
-          elsif tag == :yield
-            new_result = f.(result_so_far, val)
-            [:yield, new_result, Stream.new(next_fn, [new_result, next_stream]) ]
-          else
-            raise "#{next_item} is a malformed stream response"
-          end
+      def drop_except
+        @@drop_except||= ->(n) {
+          raise("#{n} must be a positive number") if n < 0
+          ->(stream) {
+            next_fn = cstep.(
+              ->(state) {
+                strm = state.last
+                accumulated_items = state.first
+                next_el = strm.next_item
+                accumulated_items = (state.first.length < n  ?  state.first  :  state.first[1..-1]) + [next_el[1]] if next_el.first == :yield
+                next_el == [:done]  ?  accumulated_items.to_stream  :  Stream.new(next_fn, [accumulated_items, next_el.last])
+              },
+              ->(state) { Nothing }
+            )
+            Stream.new(next_fn, [[], stream])
+          } * to_stream
         }
-        Stream.new(next_fn, [u, stream])
-      } * to_stream
+      end
     
-    }
-  end
-
-  def self.zip_with_index
-    @@zip_with_index||= F.zip_with.(F.list).(F.range.(0, F.infinity))
-  end
-
-  def self.apply_fn
-    @@apply_fn||= -> (f, *args) { f.(*args)}
-  end
-  
-    ## functional combinators - higher-order functions generic over their container
-
-    ## implement this and foldl instead as first implementing scanl and scanr, and then choosing the very last value of the stream
-    ## so that we can have an abort-fold-when that gives the value collected so far like a loop that terminates early
-  def self.foldr
-    @@foldr||= ->(f,u) { 
-      ->(stream) {
-        next_item = stream.next_item
-        if next_item == [:done]
-          u
-        elsif next_item.first == :skip 
-          foldr.(f, u, next_item.last)
-        elsif next_item.first == :yield
-          f.(next_item[1], foldr.(f, u, next_item.last))
-        else
-          raise "#{next_item} is improperly formed for a Stream"
-        end
-      } * to_stream
-        
-    }
-  end
-
-  def self.filter
-    @@filter||= ->(fn) { 
-      ->(stream) {
-        next_fn = ->(state) {
-          next_el = state.next_item
-          if next_el == [:done]
-            [:done]
-          elsif next_el.first == :skip || (next_el.first == :yield && !fn.(next_el[1]))
-            [:skip, Stream.new(next_fn, next_el.last)]
-          elsif next_el.first == :yield && fn.(next_el[1])
-            [next_el.first, next_el[1], Stream.new(next_fn, next_el.last)]
-          else
-            raise "#{next_el.inspect} is not a valid stream state!"
-          end
+      def take_while
+        @@take_while||= ->(fn) {
+          raise("take_while requires a function") unless fn.kind_of?(Proc)
+          ->(stream) {
+            next_fn = ->(state) {
+                next_item = state.next_item
+                tag = next_item.first
+                val = next_item[1]
+                next_stream = next_item.last
+                if tag == :done || (tag == :yield && !fn.(val))
+                  [:done]
+                elsif tag == :skip
+                  [:skip, Stream.new(next_fn, next_stream)]
+                elsif tag == :yield
+                  [:yield, val, Stream.new(next_fn, next_stream)]
+                else
+                  raise("#{next_item} is a malformed stream response!")
+                end
+            }
+            Stream.new(next_fn, stream)
+          } * to_stream
         }
-        Stream.new(next_fn, stream) 
-      } * to_stream
-    }
-  end
-  
-  def self.flatmap
-    @@flatmap||= ->(fn) { 
-    
-       ->(stream) {
-        next_fn = ->(next_el) {
-          state = next_el.first
-          potential_stream = next_el.last
-          if potential_stream == Nothing
-            next_el = state.next_item
-            if next_el == [:done]
-              [:done]
-            elsif next_el.first == :skip
-              [:skip, Stream.new(next_fn, [next_el.last, Nothing])]
-            elsif next_el.first == :yield
-              [:skip, Stream.new(next_fn, [next_el.last, fn.(next_el[1])])]
-            else
-              raise "#{next_el.inspect} is not a valid stream state!"
-            end
-          else
-            next_el = potential_stream.next_item
-            if next_el == [:done]
-              [:skip, Stream.new(next_fn, [state, Nothing])]
-            elsif next_el.first == :skip
-              [:skip, Stream.new(next_fn, [state, next_el.last])]
-            elsif next_el.first == :yield
-              [:yield, next_el[1], Stream.new(next_fn, [state, next_el.last])]
-            else
-              raise "#{next_el.inspect} is not a valid stream state!"
-            end
-          end
+      end 
+    
+      def drop_while
+        @@drop_while||= ->(fn) {
+          raise("drop_while requires a function") unless fn.kind_of?(Proc)
+          ->(stream) {
+            next_fn = ->(state) {
+                next_item = state.next_item
+                tag = next_item.first
+                val = next_item[1]
+                next_strm = next_item.last
+                if tag == :done
+                  [:done]
+                elsif tag == :skip || (tag == :yield && fn.(val))
+                  [:skip, Stream.new(next_fn, next_strm)]
+                elsif tag == :yield
+                  [:yield, val, next_strm]
+                else
+                  raise("#{next_item} is a malformed stream response!")
+                end
+            }
+            Stream.new(next_fn, stream)
+          } * to_stream
         }
-        Stream.new(next_fn, [stream, Nothing]) 
-      } * to_stream
+      end 
     
-    }
-  end
-
-  def self.range
-    @@range||= ->(begin_with, end_with) {
-      (if begin_with <= end_with
-        stream_next_fn = ->(n) { n > end_with  ?  [:done]  :  [:yield, n, Stream.new(stream_next_fn, n + 1)] }
-        Stream.new(stream_next_fn, begin_with)
-      else
-        stream_next_fn = ->(n) { n < end_with  ?  [:done]  :  [:yield, n, Stream.new(stream_next_fn, n - 1)] }
-        Stream.new(stream_next_fn, begin_with)
-      end)
-    }
-  end
-
-  def self.append
-    @@append||= ->(left_stream) {
-      ->(right_stream) {
-        left_next_fn = ->(stream) {
-          next_el = stream.next_item
-          if next_el == [:done]
-            [:skip, right_stream]
-          elsif next_el.first == :skip
-            [:skip, Stream.new(left_next_fn, next_el.last)]
-          elsif next_el.first == :yield
-            [next_el.first, next_el[1], Stream.new(left_next_fn, next_el.last)]
-          else
-            raise "#{next_el.inspect} is not a valid stream state!"
-          end
+      def take_until
+        @@take_until||= ->(fn) {
+          raise("take_while requires a function") unless fn.kind_of?(Proc)
+          ->(stream) {
+            next_fn = ->(state) {
+                next_item = state.next_item
+                tag = next_item.first
+                val = next_item[1]
+                next_stream = next_item.last
+                if tag == :done || (tag == :yield && fn.(val))
+                  [:done]
+                elsif tag == :skip
+                  [:skip, Stream.new(next_fn, next_stream)]
+                elsif tag == :yield
+                  [:yield, val, Stream.new(next_fn, next_stream)]
+                else
+                  raise("#{next_item} is a malformed stream response!")
+                end
+            }
+            Stream.new(next_fn, stream)
+          } * to_stream
         }
-        
-        Stream.new(left_next_fn, left_stream)
-      } * to_stream
-      
-    } * to_stream
-  end
-
-  def self.initial
-    @@initial||= ->(stream) {
-      next_fn = ->(strm) {
-        next_item = strm.next_item
-        if next_item.first == :done
-          raise "Must have at least one item inside of the stream!"
-        elsif next_item.first == :yield
-          [:yield, next_item[1], empty]
-        elsif next_item.first == :skip
-          [:skip, next_item.last]
-        else
-          raise("#{next_item} is a malformed stream response!")
-        end
-      }
-      Stream.new(next_fn, stream)
-      }
-  end
-
-  def self.final
-    @@final||= -> (stream) { 
-      next_fn = ->(state) {
-        prev_step = state.first
-        strm = state.last
-        raise("Must have at least one item inside of the stream!") if prev_step == [:done]
-        next_item = strm.next_item
-        if prev_step.first == :skip
-          [:skip, Stream.new(next_fn, [next_item, next_item.last])]
-        elsif next_item == [:done]
-          [:yield, prev_step[1], empty]
-        elsif next_item.first == :yield
-          [:skip, Stream.new(next_fn, [next_item, next_item.last])]
-        elsif next_item.first == :skip
-          [:skip, Stream.new(next_fn, [prev_step, next_item.last])]
-        else
-          raise "#{next_item} is a malformed stream result"
-        end
-      }
-      next_item = stream.next_item
-      Stream.new(next_fn, [next_item, next_item.last])
-    } * to_stream
-  end
-
+      end 
     
-
-  def self.suffixes
-    @@suffixes||= ->(stream) {
-      next_fn = ->(strm) {
-        next_item = strm.next_item
-        if next_item.first == :done
-          [:yield, strm, empty]
-        elsif next_item.first == :yield
-          [:yield, strm, Stream.new(next_fn, next_item.last)]
-        elsif next_item.first == :skip
-          [:skip, Stream.new(next_fn, next_item.last)]
+      def drop_until
+        @@drop_until||= ->(fn) {
+          raise("drop_while requires a function") unless fn.kind_of?(Proc)
+          ->(stream) {
+            next_fn = ->(state) {
+                next_item = state.next_item
+                tag = next_item.first
+                val = next_item[1]
+                next_strm = next_item.last
+                if tag == :done
+                  [:done]
+                elsif tag == :skip || (tag == :yield && !fn.(val))
+                  [:skip, Stream.new(next_fn, next_strm)]
+                elsif tag == :yield
+                  [:yield, val, next_strm]
+                else
+                  raise("#{next_item} is a malformed stream response!")
+                end
+            }
+            Stream.new(next_fn, stream)
+          } * to_stream
+        }
+      end 
+    end
+    
+    module ConverterLambdas
+      extend self
+    
+      def to_stream
+        @@to_stream||= ->(xs) { xs.to_stream }
+      end
+    
+      def from_stream(*args)
+        if args.length > 0
+          FromStream.new().(*args)
         else
-          raise("#{next_item} is a malformed stream response!")
+          FromStream.new()
         end
-      }
-      Stream.new(next_fn, stream)
-    } * to_stream
-  end
-
-
-  def self.prefixes
-    @@prefixes||= foldr.(->(el, acc) { cons.(empty, map.(cons.(el), acc)) }, wrap.(empty))
-  end
-
-  def self.naturals
-    @@naturals||= range.(1, infinity)
-  end
-
-    ## stream functions
-  def self.last
-    @@last||= first * final
-  end
-
-  def self.uncons
-    @@uncons||= ->(s) { append(first.(l), wrap(rest.(l)))  } * to_stream
-  end
-
-  def self.unsnoc
-    @@unsnoc||= ->(s) { append(wrap(init.(s)), last.(s)) } * to_stream
-  end
-
-  def self.reverse
-    @@reverse||= foldl.(->(acc, el) { cons.(el, acc) }, []) ## or foldr.(->(el,acc) { snoc.(acc, el) }
-  end
-  
-  def self.length
-    @@length||= foldl.(inc, 0)
-  end
-
-  def self.length_at_least
-    @@length_at_least||= ->(n) { ->(x) { x != Nothing } * find_where.(equals.(n)) * scanl.(inc, 0) }
-  end
-
-  def self.concat
-    @@concat||= flatmap.(to_stream)
-  end
-
-  def self.enconcat
-    @@enconcat||= ->(left_stream, el) { append.(left_stream.to_stream) * cons.(el) * to_stream }
-  end
+      end
     
-  def self.replace
-    @@replace||= ->(to_replace, to_replace_with) {map.(->(x) { x == to_replace ? to_replace_with : x })}
-  end
-  
-  def self.replace_with
-    @@replace_with||= ->(to_replace_with, to_replace) { map.(->(x) { x == to_replace ? to_replace_with : x }) }
-  end
-  
-  def self.find_where
-    @@find_where||= ->(fn){ first * filter.(fn) }
-  end
-  
-  def self.find_last_where
-    @@find_last_where||= ->(fn){ last * filter.(fn) }
-  end
-  
-  def self.transpose
-    @@transpose||= ->(stream_of_streams) { zip.( *(stream_of_streams.to_stream) ) }
-  end
-  
-  def self.tail
-    @@tail||= rest
-  end
-
-  def self.prefix
-    @@prefix||= init
-  end
-
-  def self.suffix
-    @@suffix||= rest
-  end
-
-  def self.head
-    @@head||= first
-  end
-
-  def self.inits
-    @@inits||= prefixes
-  end
-
-  def self.tails
-    @@tails||= suffixes
-  end
-
-  def self.starts_with
-    @@starts_with||= ->(slice, xs) {  }
-  end
-
-  def self.ends_with
-    @@ends_with||= ->(slice, xs) {  }
-  end
-  
-  def self.intersperse
-    @@intersperse||= ->(x, xs) { rest * flatmap.(->(y) { [x, y] }) << xs.to_stream }
-  end
-
-    # stream folds useful for containers of numbers (core statistics algorithms)
-  
-  def self.maximum  
-    @@maximum||= foldl.(max, negative_infinity)
-  end
-
-  def self.minimum
-    @@minimum||= foldl.(min, infinity)
-  end
-
-  def self.maximum_by
-    @@maximum_by||= ->(fn) { foldl.(->(max_so_far, el) { max_so_far == Nothing || fn.(el) > fn.(max_so_far) ? el : max_so_far}, Nothing) }
-  end
-  
-  def self.minimum_by
-    @@minimum_by||=  ->(fn) { foldl.(->(min_so_far, el) { min_so_far == Nothing || fn.(el) < fn.(min_so_far) ? el : min_so_far}, Nothing) }
-  end
-
-  def self.sum
-    @@sum||= foldl.(plus, 0)
-  end
-
-  def self.product
-    @@product||= foldl.(times, 1)
-  end
-
-    ## this is a one-pass algorithm, but only an estimate
-    #sum_of_squares_of_differences_from_mean_iterative
-    ## - need length, sum, sum_of_squares, M1,M2,M3, deltas, etc... see @@https||=//en.wikipedia.org/wiki/Algorithms_for_calculating_variance
-    ## population_variance
-    ## sample_variance
-    #->(l) { 
-    #  len, sm, sm_sqrs = (length + sum + sum_of_squares).(l)
-    #}
-  
-
-  def self.repeat
-    @@repeat||= ->(n, fn, x) {
-      result = x
-      count = n
-      while count > 0
-        result = fn.(result)
+      def lines_from_file
+        @@lines_from_file||= ->(filepath, options={}) {
+          (options['separator'] ? IO.foreach(filepath, options['separator']) : IO.foreach(filepath)  ).to_stream
+        }
       end
-      result
-    }
-  end
-  
-  def self.rotate
-    @@rotate||= ->(s) { append.(tail.(s), initial.(s)) }
-  end
-  
-  def self.first_index_where
-    @@first_index_where||= ->(fn) { first * find_where.( fn * last ) * zip_with_index }
-  end
-  
-  def self.last_index_where
-    @@last_index_where||= ->(fn) { first * last * filter.( fn * last ) * zip_with_index }
-  end
     
-  def self.mean
-    @@mean||= ->(l) { div_from.(*( (sum + length).(l) )) }
-  end ## this works because (sum + length).(l)== [sum.(l), length.(l)]
-  
-  def self.sum_of_squares  
-    @@sum_of_squares||= sum * map.(square)
-  end
-
-## this is a two-pass algorithm
+      def to_array
+        FromStream.new(Array)
+      end
     
-  def self.sum_of_differences_from_estimated_mean
-    @@sum_of_differences_from_estimated_mean||= ->(xs) {
-      sum * map.(square * sub_by.())
-    }
-  end
-
-    # stream folds useful for containers of booleans
-  def self.ands
-    @@ands||= ->(x) { x == Nothing } * find_where.(F.equals.(false))
-  end
-
-  def self.ors
-    @@ors||= ->(x) { x != Nothing } * find_where.(F.equals.(true))
-  end
-
+      def to_hash
+        FromStream.new(Hash)
+      end
     
-    ## stream functionals
-  def self.contains?
-    @@contains_p||= ->(el) { F.not * F.equal.(Nothing) * find_where.(equals.(el)) }
-  end
-
-  def self.does_not_contain?
-    @@does_not_contain_p||= ->(el) { F.equal.(Nothing) * find_where.(equals.(el)) }
-  end
-  
-  def self.contains_slice?
-    @@contains_slice_p||= ->(slice) { any?.(starts_with.(slice)) * tails }
-  end
-  
-  def self.all?
-    @@all_p||= ->(f) { ->(x) { x == Nothing } * find_where.(->(x) { !f.(x)})}
-  end ## this is going to become equal.(Nothing) * first * find_where.(F.not.(f))
-  
-  def self.any?
-    @@any_p||= ->(f) { ->(x) { x != Nothing } * find_where.(f)}
-  end
-  
-  def self.fold
-    @@fold||= ->(fn, u) { final * scanl.(fn, u) }
-  end
-  
-  def self.slice_by
-    @@slice_by||= ->(starts_with_fn, ends_with_fn) { take_until.(ends_with_fn) * drop_until.(starts_with_fn) }
-  end
-  
-  def self.interleave
-    @@interleave||= ->(xs, *ys) { ys.length > 0 ? (concat * zip).(*([xs]+ys)) : ->(zs, *ys) { concat << zip.(*([xs,zs]+ys)) } }
-  end ## you can undo this with % n, where n is the number of streams
-  
-  def self.intercalate
-    @@intercalate||= ->(xs, xss) { concat.intersperse.(xs, xss) }
+      def to_set
+        FromStream.new(Set)
+      end
+    
+      def to_a
+        self.to_array
+      end
+    
+      def to_h
+        self.to_hash
+      end
+    end
   end
   
-  def self.partition_by
-    @@partition_by||= ->(fn) {
-      folded_filter = ->(f) { foldl.(->(acc, el) { f.(el) ?  acc << el : acc }, []) }
-      (folded_filter.(fn) + folded_filter.(->(x) { !fn.(x) })) * to_stream
-    }
-  end
-
-  def self.partition_at
-    @@partition_at||= ->(n) { take.(n) + drop.(n) }
-  end
-
-  def self.split_by
-    @@split_by = ->(fn) { take_while.(fn) + drop_while.(fn) }
-  end
-
-  def self.sum_of_square_difference_from_mean_two_pass
-    @@sum_of_square_difference_from_mean_two_pass||= ->(l) { sum * map.(square * sub_by.(mean.(l))) << l }
-  end
   
-  def self.last_index_of
-    @@last_index_of||= ->(x) { last_index_where.(F.equal.(x)) }
-  end
+  ## module System 
+  class F
+    extend Collections::ConverterLambdas
+    extend Collections::ObjectLambdas
+    extend Collections::ProcishLambdas
+    extend Collections::BooleanLambdas
+    extend Collections::NumericLambdas
+    extend Collections::StreamDropAndTakeLambdas
+    extend Collections::OneForOneStreamLambdas
+    extend Collections::FoldableStreamLambdas
+    extend Collections::HigherOrderStreamLambdas
+    extend Collections::NumericStreamLambdas
+    extend Collections::StreamLambdas
   
-  def self.first_index_of
-    @@first_index_of||= ->(x) { first_index_where.( F.equal.(x) ) }
-  end
-
-  def self.union
-    @@union||= ->(xs) {
-      ->(ys) {
-          to_stream * to_set << append.(xs, ys)
-        } * to_stream
-    } * to_stream
-  end
-
-  def self.interesect
-    @@intersect||= ->(xs) {
-      ->(ys) {
-          to_stream << (to_set.(xs) & to_set.(ys))
-        } * to_stream
-    } * to_stream
-  end
-
-  def self.difference
-    @@difference||= ->(xs) {
-      ->(ys) {
-          to_remove = to_set.(ys)
-          filter.(->(x) { !ys.include?(x)}) << xs
-        } * to_stream
-    } * to_stream
-  end
-
-  def self.cartesian_product
-    @@cartesian_product||= ->(xs) {
-      ->(ys) {
-          flatmap.(->(x) { map.(->(y) { [x,y] }, ys) }, xs)
-        } * to_stream
-    } * to_stream
-  end
-
-  def self.unzip
-    @@unzip||= ->(xs) {
-      map.(first) + map.(last) << xs
-    } * to_stream
-  end
-
-  def self.bucket_by
-    @@bucket_by||= ->(fn, xs) {
-      foldl.(->(acc, el) { 
-          key = fn.(el)
-          acc[key] ||= []
-          acc[key] << el
-          acc 
-        }, {}).(to_stream.(xs))
-    }
-  end
+    def self.app
+      @@app||= ->(*fs) { apply.(fs.first, fs.drop(1)) }
+    end
   
-  def self.bucket_by_and_summarize
-    @@bucket_by_and_summarize||= ->(group_fn, summary_fn) {
-      map.(summary_fn) * bucket_by.(group_fn)
-    }
-  end
-
-  def self.window
-    @@window||= ->(n) {
-      map.(take.(n)) * suffixes
-    }
-  end
-
-  def self.subsequences
-    @@subsequences||= ->() { ## Using the applicative instance for <**>, which is ^ in Raskell
-      subs = ->(ys) { ys == empty ? wrap.(empty) : subs.(rest.(ys)) ^ [F.id, F.cons.(first.(ys))].to_stream }
-    }.() #wrap.(empty)
-  end
-    ## Using Control.Applicative
-    # subs [] = [[]]
-    # subs (@@x||=xs) = subs xs <**> [id, (x :)] 
-    ## subsequences is useful for fuzzy sequence matching style algorithms a la command tab in sublime, 
-    ### or figuring out if some melody or progressionis an elaboration of another (same thing), etc...
-    ## is there any way to do this with a left fold instead of a right one?
-
-
-  def self.continuous_subsequences
-    @@continuous_subsequences||= filter.(F.not * empty?) * flatmap.(prefixes) * suffixes
-  end
-  ## continuous subsequences is useful for exact inside sequence matching a la find in sublime
-    
-  def self.quicksort
-    ->(xs) {
-      if empty?.(xs)
-        empty
-      else
-        pivot = head.(xs)
-        partitions = (F.map.(self.quicksort) * partition_by.(F.is_lte.(pivot)) << tail.(xs)).to_a
-        append.(partitions[0],cons.(pivot, partitions[1]))
-      end
-    } * to_stream ### if only this wasn't infinitely recursing...
- end
-
-  def self.group_by
-    @@group_by||= ->(fn) { 
-      next_fn = ->(state) {
-        strm = state.last
-        group = state.first
-        next_item = strm.next_item
-        tag = next_item.first
-        val = next_item[1]
-        next_stream = next_item.last
-        if tag == :done && group == []
-          [:done]
-        elsif tag == :done
-          [:yield, group, empty]
-        elsif tag == :skip
-          [:skip, Stream.new(next_fn, [group, next_stream])]
-        elsif tag == :yield && (group.length == 0 || fn.(val) == fn.(group.last))
-          [:skip, Stream.new(next_fn, [group + [val], next_stream])]
-        elsif tag == :yield
-          [:yield, group, Stream.new([[], next_stream])]
-        else
-          raise "#{next_item} is a malformed stream response!"
-        end
-      }
-      Stream.new(next_fn, [[], state])
-    } * to_stream
+    def self.fold
+      @@fold||= ->(fn, u) { final * scanl.(fn, u) }
+    end
+    
   end
+end
 
-  def self.lines_from_file
-    @@lines_from_file||= ->(filepath, options={}) {
-      (options['separator'] ? IO.foreach(filepath, options['separator']) : IO.foreach(filepath)  ).to_stream
-    }
-  end
 
-  def self.group 
-    @@group||= ->(xs) { group_by.(id) }
-  end
-end
-  #std
+class F < System::F;end;
 
 class Stream
 
@@ -1232,38 +1264,6 @@ class Stream
 
   end
 
-=begin ## ruby doesn't allow you to override the return value on []=, which means we'd have to destructively alter this Stream
-## but for some reason that isn't working very well - probably due to the need for self-reference. Guess my deep_clone isn't working 100%?
-  def []=(index, item)
-    next_fn = ->(state) {
-      i = state.first
-      strm = state.last
-      if 
-        [:yield, item, strm.next_item.last]
-      else
-        next_item = strm.next_item
-        tag = next_item.first
-        val = next_item[1]
-        next_stream = next_item.last
-        if tag == :done && i < index
-          [:skip, F.snoc(item, Array.new(index - i-1, Nothing).to_stream)]
-        elsif tag == :skip
-          [:skip, Stream.new(next_fn, next_stream)]
-        elsif tag == :yield && i == index
-          [:yield, item, next_stream]
-        elsif tag == :yield 
-          [:yield, val, Stream.new(next_fn, next_stream)]
-        else
-          raise "#{next_item} is a malformed stream response"
-        end
-      end
-    }
-    state = [0, self.deep_clone]
-    self.next_item_function = next_fn
-    self.state = state
-  end
-=end
-
   def first
     F.first.(self)
   end
@@ -1332,7 +1332,7 @@ end
 class Array
 
   ## Applicative <**> 
-  ## [1,2,3] ** [id, double]
+  ## [1,2,3] ^ [id, double] == [1,2,3].flatmap([id, double])
   ## [1,2,2,4,3,6]
   def ^(arr, is_cartesian=false)
     is_cartesian || !arr.any?{|x| x.kind_of? Proc } ? self.cartesian_product(arr) : F.flatmap.(->(x) { arr.to_stream.(x) }).(self).to_a
@@ -1345,7 +1345,7 @@ class Array
   end
 
   ## zip or Applicative <*> depending on if there any function values in the array/stream
-  #[id, double] * [1,2,3]
+  #[id, double] ** [1,2,3]
   #[1,2,3,2,4,6]
   def **(arr, is_zip=false)
     is_zip || !self.any?{|x| x.kind_of? Proc } ? self.zip(arr.to_a) : F.flatmap.(->(f) { F.map.(f) << arr.to_stream }).(self.to_stream).to_a