raskell 0.1.0

data/lib/raskell/folds.rb

@@ -0,0 +1,188 @@
+require 'singleton'
+
+
+class Foldl
+
+   alias_method :standard_ruby_kind_of?, :kind_of?
+
+   def kind_of?(clazz)
+     [Proc].include?(clazz) || standard_ruby_kind_of?(clazz)
+   end
+
+   def initialize(*monoids) # must be [fn, unit] pair, a monoid
+       @monoids = monoids
+       self
+   end
+
+   def monoids
+     @monoids
+   end
+
+   def *(lamb)
+     ->(x) { self.( lamb.( x ) ) }
+   end
+
+   def |(lamb)
+     ->(x) { lamb.( self.( x ) ) }
+   end
+
+   def <<(val)
+     self.(val.())
+   end
+
+   def >>(lamb)
+     lamb.(self)
+   end
+
+   def +(foldl)
+     if foldl.kind_of?(Foldl)
+       Foldl.new(*(self.monoids + foldl.monoids))
+     else
+       raise "Cannot add two non-folds together"
+     end
+   end
+
+   def call(stream)
+     if stream.respond_to?(:to_stream)
+        if @monoids.length > 1
+          fn = ->(acc, el) { F.zip_with.(F.apply_fn).(@monoids.map(&:first), acc, @monoids.map {|x| el }).to_a }
+          F.foldleft.(fn, @monoids.map(&:last)).(stream).to_a
+        else
+          F.foldleft.(*@monoids.first).(stream)
+        end
+     else
+       raise "Cannot call Foldl on an object that does not have to_stream defined."
+     end
+   end
+
+  @@foldl = ->(f,u) { Foldl.new([f,u])} 
+  def self.foldl
+    @@foldl
+  end
+end
+
+class F
+  include Singleton
+end
+
+F.define_singleton_method(:foldl) { Foldl.foldl }
+
+class Scanl
+   alias_method :standard_ruby_kind_of?, :kind_of?
+
+   def kind_of?(clazz)
+     [Proc].include?(clazz) || standard_ruby_kind_of?(clazz)
+   end
+
+   def initialize(*monoids) # must be [fn, unit] pair, a monoid
+       @monoids = monoids
+       self
+   end
+
+   def monoids
+     @monoids
+   end
+
+   def *(lamb)
+     ->(x) { self.( lamb.( x ) ) }
+   end
+
+   def |(lamb)
+     ->(x) { lamb.( self.( x ) ) }
+   end
+
+   def <<(val)
+     self.(val.())
+   end
+
+   def >>(lamb)
+     lamb.(self)
+   end
+
+   def +(scanl)
+     if scanl.kind_of?(Scanl)
+       Scanl.new(*(self.monoids + scanl.monoids))
+     else
+       raise "Cannot add two non-folds together"
+     end
+   end
+
+   def call(stream)
+     if stream.respond_to?(:to_stream)
+        if @monoids.length > 1
+          fn = ->(acc, el) { F.zip_with.(F.apply_fn).(@monoids.map(&:first), acc, @monoids.map {|x| el }).to_a }
+          F.scanleft.(fn, @monoids.map(&:last)).(stream)
+        else
+          F.scanleft.(*@monoids.first).(stream)
+        end
+     else
+       raise "Cannot call Foldl on an object that does not have to_stream defined."
+     end
+   end
+
+  @@scanl = ->(f,u) { Scanl.new([f,u])} 
+  def self.scanl
+    @@scanl
+  end
+end
+F.define_singleton_method(:scanl) { Scanl.scanl }
+
+
+class Mapl
+   alias_method :standard_ruby_kind_of?, :kind_of?
+
+   def kind_of?(clazz)
+     [Proc].include?(clazz) || standard_ruby_kind_of?(clazz)
+   end
+
+   def initialize(*functions)
+       @functions = functions
+       self
+   end
+
+   def functions
+     @functions
+   end
+
+   def *(lamb)
+     ->(x) { self.( lamb.( x ) ) }
+   end
+
+   def |(lamb)
+     ->(x) { lamb.( self.( x ) ) }
+   end
+
+   def <<(val)
+     self.(val.())
+   end
+
+   def >>(lamb)
+     lamb.(self)
+   end
+
+   def +(mapl)
+     if mapl.kind_of?(Mapl)
+       Mapl.new(*(self.functions + mapl.functions))
+     else
+       raise "Cannot add two non-maps together"
+     end
+   end
+
+   def call(stream)
+     if stream.respond_to?(:to_stream)
+        if @functions.length > 1
+          F.mapleft.(@functions).(stream)
+        else
+          F.mapleft.(@functions.first).(stream)
+        end
+     else
+       raise "Cannot call Mapl on an object that does not have to_stream defined."
+     end
+   end
+
+  @@map = ->(f) { Mapl.new(f)} 
+  def self.map
+    @@map
+  end
+end
+F.define_singleton_method(:map) { Mapl.map }

data/lib/raskell/identity.rb

@@ -0,0 +1,34 @@
+class Identity
+
+  alias_method :standard_kind_of?, :kind_of?
+  def kind_of?(clazz)
+    clazz == Proc || standard_kind_of?(clazz)
+  end
+
+  def call(arg)
+    arg
+  end
+
+  def *(lamb)
+    lamb
+  end
+
+  def |(lamb)
+    lamb
+  end
+
+  def +(lamb)
+    ->(x) { x } + lamb
+  end
+
+  def <<(val)
+    # feed data from the right
+    self.(val.())
+  end
+
+  def >>(lamb)
+    # feed data from the left, assuming I am a wrapped Object of some sort
+    lamb.(self)
+  end
+
+end

data/lib/raskell/integer.rb

@@ -0,0 +1,23 @@
+class Integer
+  def self.empty
+    0
+  end
+
+  def foldl(func, unit)
+    i = 0
+    while i <= self
+      unit = func.(unit, i)
+      i+=1
+    end
+    unit
+  end
+
+  def foldr(func, unit)
+    i = self
+    while i >= 0
+      unit = func.(i, unit)
+      i-=1
+    end
+    unit
+  end
+end

data/lib/raskell/nothing.rb

@@ -0,0 +1,5 @@
+require 'singleton'
+
+class Nothing
+  include Singleton
+end

data/lib/raskell/object.rb

@@ -0,0 +1,27 @@
+class Object
+
+  def self.empty
+    self.class.new
+  end
+
+  def fmap(fn)
+  	fn.(self)
+  end
+
+  def lift
+    ->() { self }
+  end
+
+  def call(*args)
+  	self
+  end
+
+  def apply(fn)
+    fn.(self)
+  end
+
+  def deep_clone
+    self.respond_to?(:clone) && !self.kind_of?(Numeric) && !self.kind_of?(TrueClass) && !self.kind_of?(FalseClass) && !self.kind_of?(NilClass) ? self.clone : self
+  end
+
+end

data/lib/raskell/proc.rb

@@ -0,0 +1,111 @@
+
+class Proc
+  alias_method :standard_ruby_call, :call
+  attr_accessor :is_tupled
+
+  def fmap(lamb)
+    self * lamb
+  end
+
+  def self.pure(arg)
+    ->(x) { arg }
+  end
+
+  def **(lamb) ## <*> from Control.Applicative
+    ->(x) { self.(x, lamb.(x)) }
+  end
+
+
+  ## <**> from Control.Applicative
+  def ^(lamb)
+    ->(x) { lamb.(self.(x), x) }
+  end
+
+  def bind(lamb)
+    ->(x) { lamb.(self.(x), x)}
+  end
+  
+  # Just a friendly reminder
+  # .() is shorthand for .call() 
+  # and self.arity is the number of arguments this Proc takes
+
+  def [](*args)
+    call(*args)
+  end
+
+  def call(*args)
+    args_to_consume = args.take(self.arity < 0 ? self.arity.abs : self.arity) ## the < 1 here is because ruby stores *args as an arity of one more than the required args, in a negative number
+    remaining_args = args.drop(self.arity < 0 ? self.arity.abs : self.arity)
+    
+    if !args_to_consume.respond_to?(:length) ## then we're dealing with a *args-only lambda, and we have enough args. just apply them all
+        result = self.standard_ruby_call(*args)
+    elsif self.arity == 0
+      result = self.standard_ruby_call()
+    elsif args.length == 0
+      #interpret application with no arguments on a non-zero-arity function as a no-op
+      return self
+    elsif (self.arity < 0 && args.length >= self.arity.abs - 1) ## then we're dealing with a *args-based lambda, and we have enough args. just apply them all
+      result = self.standard_ruby_call(*args)
+    elsif args_to_consume.length < self.arity 
+      #if you have too few arguments, return a lambda asking for more before attempting to re-apply
+      return ->(x) { self.call( *( args + [x] ) ) }
+    elsif self.arity < 0
+      return ->(*xs) { self.call( *( args + xs.deep_clone ) ) }
+    else
+      #otherwise, apply the arguments
+      result = self.standard_ruby_call(*args_to_consume)
+    end
+    # if the result is a proc, make sure to unwrap further by recursively calling with any remaining arguments
+    (result.kind_of?(Proc) && remaining_args.length > 0) || (result.kind_of?(Proc) && remaining_args.length == 0 && result.respond_to?(:arity) && result.arity == 0) ? result.call(*remaining_args) : result
+  end
+
+  def *(lamb)
+    # You, then me
+    # like function composition
+    if lamb.class != Proc
+      lamb | self
+    else
+      ->(x) { self.( lamb.( x ) ) }
+    end
+  end
+
+  def |(lamb)
+    # Me, then you
+    # like unix pipes
+    if lamb.class != Proc
+      lamb * self
+    else
+      ->(x) { lamb.( self.( x ) ) }
+    end
+  end
+
+  def +(lamb)
+    ## later need to check if they have the same arity, once I've fixed the arity function to handle nesting lambdas
+    this = self
+    
+    result = ->(xs) { 
+      if lamb.is_tupled && this.is_tupled 
+        this.(xs) + lamb.(xs)
+      elsif lamb.is_tupled
+        [this.(xs)] + lamb.(xs)
+      elsif this.is_tupled
+        this.(xs) + [lamb.(xs)]
+      else
+        [this.(xs),lamb.(xs)] 
+      end
+    }
+    result.is_tupled = true
+    result
+  end
+
+  def <<(val)
+    # feed data from the right
+    self.(val.())
+  end
+
+  def >>(lamb)
+    # feed data from the left, assuming I am a wrapped Object of some sort
+    lamb.(self.())
+  end
+
+end

data/lib/raskell/streams.rb

@@ -0,0 +1,440 @@
+class Stream
+  include Enumerable
+
+  def each(&fn)
+    item = self.next_item
+    while item != [:done]
+      fn.call(item[1]) if item.first == :yield
+      item = item.last.next_item
+    end
+    self
+  end
+
+  attr_accessor :state, :next_item_function
+  def initialize(next_func, state, options={})
+    @next_item_function = next_func
+    @state = state
+    @options = options
+    ## step_fn should return one of [:done], [:yield element stream], or [:skip stream]
+    self
+  end
+
+  def ==(stream)
+    if stream.respond_to?(:to_stream)
+      stream = stream.to_stream
+      next1 = self.another
+      next2 = stream.another
+      equal_so_far = next1 == next2 || (next1.first != :skip && next1[1] == next2[1])
+      while equal_so_far && !(next1 == [:done] || next2 == [:done])
+        next1 = next1.last.another
+        next2 = next2.last.another
+        equal_so_far = next1 == next2
+      end
+      equal_so_far
+    else
+      false
+    end
+  end
+
+  def ===(stream)
+    if stream.respond_to?(:to_stream)
+      stream = stream.to_stream
+      next1 = self.another
+      next2 = stream.another
+      equal_so_far = next1 == next2 || (next1.first != :skip && next1[1] === next2[1])
+      while equal_so_far && !(next1 == [:done] || next2 == [:done])
+        next1 = next1.last.another
+        next2 = next2.last.another
+        equal_so_far = next1 === next2
+      end
+      equal_so_far
+    else
+      false
+    end
+  end
+
+  def self.to_stream(stream)
+    stream
+  end
+
+  def to_stream
+    self
+  end
+
+  def from_stream
+    FromStream.new().(self)
+  end
+
+  def to_a
+    from_stream
+  end
+
+  def next_item
+    result = @next_item_function.(@state)
+    @state[2] = @state[1].clone.drop(@state[0]) if @options[:type] == "enumerator"
+    result
+  end
+
+  def next_item_function
+    @next_item_function
+  end 
+
+  def another
+    item = self.next_item
+    while item.first == :skip
+      item = item.last.next_item
+    end
+    item
+  end
+
+  def foldl(func, unit)
+    from_stream.foldl(func, unit)
+  end
+
+  def call(*args)
+    next_fn = ->(next_item) {
+      tag = next_item.first
+      fn = next_item[1]
+      stream = next_item.last
+      if tag == :done
+        [:done]
+      elsif tag == :skip
+        [:skip, Stream.new(next_fn, stream.state)]
+      elsif tag == :yield
+        [:yield, fn.(*args), Stream.new(next_fn, stream.state)]
+      else
+        raise "#{next_item} is a malformed stream result!"
+      end
+    } * self.next_item_function
+    Stream.new(next_fn, self.state)
+  end
+
+end
+
+
+class FromStream
+  def initialize(clazz=Array, options={})
+    if clazz.kind_of?(Hash)
+      options = clazz
+      clazz = Array
+    end
+    @before_function = options['before']
+    @after_function = options['after']
+    @output_type = clazz
+  end
+
+  attr_accessor :before_function, :after_function
+  singleton_class.send(:alias_method, :standard_new, :new)
+  def self.new(clazz=Array,options={})
+    options['before'] && options['after'] ? ->(x) { self.standard_new(clazz,options).(x) } : self.standard_new(clazz,options)
+  end
+
+  
+
+
+  alias_method :standard_kind_of?, :kind_of?
+  def kind_of?(clazz)
+    clazz == Proc || standard_kind_of?(clazz)
+  end
+
+
+  def call(stream)
+    before = @before_function
+    after = @after_function
+    stream = before.(stream) if before
+    result = self.unfold(stream)
+    after ? after.(result) : result
+  end
+
+
+  def unfold(stream)
+    result = @output_type.new
+    # puts 'unfolding'
+    # puts stream.inspect
+    next_val = stream.next_item
+    while next_val.first != :done
+      #puts next_val.inspect
+      result << next_val[1] if next_val.first == :yield
+      next_val = next_val.last.next_item
+    end
+    result
+  end
+
+  def join(after)
+    before = self
+    if after.class == before.class && !after.before_function && !before.after_function
+      before.class.new({
+        'before' => before.before_function,
+        'after' => after.after_function
+      })
+    elsif ToStream == after.class
+      StreamTransducer.new({
+        'before' =>  before.before_function,
+        'inside' => (after.before_function || Identity.new) * ((after.kind_of?(StreamTransducer) ? inside_function : nil) || Identity.new) * (before.after_function || Identity.new),
+        'after' => after.after_function
+      })
+    elsif StreamTransducer == after.class && !before.after_function && !after.before_function
+      StreamTransducer.new({
+          'before' => before.before_function,
+          'inside' => after.inside_function,
+          'after' => after.after_function
+        })
+    else
+      ->(xs) { after.(before.(xs)) }
+    end
+  end
+
+  def fuse(before_converter, after_converter)
+    before_converter.join(after_converter)
+  end
+
+  def *(lamb)
+    if lamb.kind_of?(Identity)
+      self
+    elsif [FromStream, StreamTransducer].include?(lamb.class)
+      ## then fuse away the streams by just making this the Identity.new function
+      self.fuse(lamb, self)
+    else
+      self.class.new({ 'before' => (self.before_function || Identity.new) * lamb ,
+                       'after' => self.after_function})
+    end
+  end
+
+  def |(lamb)
+    if lamb.kind_of?(Identity)
+      self
+    elsif [FromStream, ToStream, StreamTransducer].include?(lamb.class)
+      ## then fuse away the streams by just making this the Identity.new function
+      self.fuse(self, lamb)
+    else
+      self.class.new({ 'before' => self.before_function,
+                       'after' => (self.after_function || Identity.new) | lamb })
+    end
+  end
+
+  def <=(val)
+    # feed data from the right
+    self.(val.())
+  end
+
+  def >=(lamb)
+    # feed data from the left, assuming I am a wrapped Object of some sort
+    lamb.(self.())
+  end
+end
+
+class ToStream
+  ## Represents a generic to_stream function
+  def initialize(options={})
+    @before_function = options['before']
+    @after_function = options['after']
+  end
+
+  attr_reader :before_function, :after_function
+  singleton_class.send(:alias_method, :standard_new, :new)
+  def self.new(options={})
+    options['before'] && options['after'] ? ->(x) { self.standard_new(options).(x) } : self.standard_new(options)
+  end
+
+  
+
+  alias_method :standard_kind_of?, :kind_of?
+
+  def kind_of?(clazz)
+    clazz == Proc || standard_kind_of?(clazz)
+  end
+
+
+  def call(collection)
+    before = @before_function
+    after = @after_function
+    collection = before.(collection) if before
+    result = collection.to_stream
+    after ? after.(result) : result
+  end
+
+  def join(after)
+    ## to = ToStream, from = FromStream
+    ## to = ToStream, from = ToStream
+    ## to = ToStream, from = StreamTransducer
+    before = self
+    if after.class == before.class && !after.before_function && !before.after_function
+      before.class.new({
+        'before' => before.before_function,
+        'after' => after.after_function
+      })
+    elsif FromStream == after.class
+      StreamTransducer.new({
+        'before' =>  before.before_function,
+        'inside' => (after.before_function || Identity.new) * ((after.kind_of?(StreamTransducer) ? inside_function : nil) || Identity.new) * (before.after_function || Identity.new),
+        'after' => after.after_function
+      })
+    elsif StreamTransducer == after.class && !before.after_function && !after.before_function
+      StreamTransducer.new({
+          'before' => before.before_function,
+          'inside' => after.inside_function,
+          'after' => after.after_function
+        })
+
+    else
+      ->(xs) { after.(before.(xs)) }
+    end
+  end
+
+  def fuse(before_converter, after_converter)
+    before_converter.join(after_converter)
+  end
+
+  def *(lamb)
+    if lamb.kind_of?(Identity)
+      self
+    elsif [FromStream, ToStream, StreamTransducer].include?(lamb.class)
+      ## then fuse away the streams by just making this the Identity.new function
+      self.fuse(lamb, self)
+    else
+      self.class.new({ 'before' => (self.before_function || Identity.new) * lamb ,
+                       'after' => self.after_function})
+    end
+  end
+
+  def |(lamb)
+    if lamb.kind_of?(Identity)
+      self
+    elsif [FromStream, ToStream, StreamTransducer].include?(lamb.class)
+      ## then fuse away the streams by just making this the Identity.new function
+      self.fuse(self, lamb)
+    else
+      self.class.new({ 'before' => self.before_function,
+                       'after' => (self.after_function || Identity.new) | lamb })
+    end
+  end
+
+  def <=(val)
+    # feed data from the right
+    self.(val.())
+  end
+
+  def >=(lamb)
+    # feed data from the left, assuming I am a wrapped Object of some sort
+    lamb.(self.())
+  end
+end
+
+class StreamTransducer
+
+
+  def initialize(options={})
+    @before_function = options['before']
+    @after_function = options['after']
+    @inside_function = options['inside']
+  end
+
+  attr_accessor :before_function, :after_function, :inside_function  
+  singleton_class.send(:alias_method, :standard_new, :new)
+  def self.new(options={})
+    if options['inside'] && options['inside'].class != Identity
+      options['before'] && options['after'] ? ->(x) { self.standard_new(options).(x) } : self.standard_new(options)
+    else
+      ->(x) { self.standard_new(options).(x) }
+    end
+  end
+
+  
+
+  def +(stream_transducer)
+    ##TODO handle case where before function and after functions exist
+    if stream_transducer.kind_of?(StreamTransducer) && !stream_transducer.before_function && !stream_transducer.after_function && !self.before_function && !self.after_function
+      StreamTransducer.new({
+        'inside' => self.inside_function + stream_transducer.inside_function
+      })
+    else
+      raise "#{stream_transducer.class} should be of class StreamTransducer to be combined via + with another StreamTransducer"
+    end
+  end
+
+
+  alias_method :standard_kind_of?, :kind_of?
+  def kind_of?(clazz)
+    clazz == Proc || standard_kind_of?(clazz)
+  end
+
+
+  def call(arg)
+    before = self.before_function || Identity.new
+    after = self.after_function || Identity.new
+    after <= (F.from_stream * ->(stream) { 
+      next_fn = self.inside_function * stream.next_item_function 
+      Stream.new(next_fn, stream)
+    } <= F.to_stream.(before.(arg)))
+  end
+
+  def join(after)
+
+    ## to = StreamTransducer, from = FromStream
+    ## to = StreamTransducer, from = ToStream
+    ## to = StreamTransducer, from = StreamTransducer
+    before = self
+    if after.class == before.class && !after.before_function && !before.after_function
+      before.class.new({
+        'before' => before.before_function,
+        'inside' => after.inside_function * before.inside_function,
+        'after' => after.after_function
+      })
+    elsif [ToStream,FromStream].include?(after.class) && !after.before_function && !before.after_function ## TODO TOMORROW figure this otu
+      ## if i am a transducer and have no after, and from has no before
+      ## then I cleanly merge with from and make a new transducer
+      ## if i have an after, then I produce a lambda?
+      ## NEXT STEP is to make a buuunch of test cases for all of this transducer/from/to merge stuff
+      ## and then keep implementing until they all pass
+      ## then build
+      StreamTransducer.new({
+        'before' =>  before.before_function,
+        'inside' => before.inside_function,
+        'after' => after.after_function
+      })
+    else
+      ->(xs) { after.(before.(xs)) }
+    end
+  end
+
+  def fuse(before_converter, after_converter)
+    before_converter.join(after_converter)
+  end
+
+  def *(lamb)
+    if lamb.kind_of?(Identity)
+      self
+    elsif [ToStream, StreamTransducer].include?(lamb.class)
+      ## then fuse away the streams by just making this the Identity.new function
+      self.fuse(lamb, self)
+    else
+      self.class.new({ 'before' => (self.before_function || Identity.new) * lamb ,
+                       'inside' => self.inside_function,
+                       'after' => self.after_function})
+    end
+  end
+
+  def |(lamb)
+    if lamb.kind_of?(Identity)
+      self
+    elsif [FromStream, ToStream, StreamTransducer].include?(lamb.class)
+      ## then fuse away the streams by just making this the Identity.new function
+      self.fuse(self, lamb)
+    else
+      self.class.new({ 'before' => self.before_function,
+                       'inside' => self.inside_function,
+                       'after' => (self.after_function || Identity.new) | lamb })
+    end
+  end
+
+  def <=(val)
+    # feed data from the right
+    self.(val.())
+  end
+
+  def >=(lamb)
+    # feed data from the left, assuming I am a wrapped Object of some sort
+    lamb.(self.())
+  end
+
+end