fr 0.9.1

data/Rakefile

@@ -0,0 +1,81 @@
+require "pathname"
+abspath = Pathname.new(File.dirname(__FILE__)).expand_path
+relpath = abspath.relative_path_from(Pathname.pwd)
+
+begin
+  require "rubygems"
+  require "bundler/setup"
+rescue LoadError
+  warn "couldn't load bundler:"
+  warn "  #{$!}"
+end
+
+task :console do
+  exec *%w(irb -I lib -r fr)
+end
+
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new do |t|
+    t.verbose = false
+    t.pattern = "#{relpath}/spec/examples/**/*.example"
+
+    t.rspec_opts  = %w(--color --format p)
+    t.rspec_opts << "-I#{abspath}/spec"
+  end
+rescue LoadError
+  task :spec do
+    warn "couldn't load rspec"
+    warn "  #{$!}"
+    exit 1
+  end
+end
+
+begin
+  require "rcov"
+  begin
+    require "rspec/core/rake_task"
+    RSpec::Core::RakeTask.new(:rcov) do |t|
+      t.rcov = true
+      t.rcov_opts = "--exclude spec/,gems/"
+
+      t.verbose = false
+      t.pattern = "#{relpath}/spec/examples/**/*.example"
+
+      t.rspec_opts  = %w(--color --format p)
+      t.rspec_opts << "-I#{abspath}/spec"
+    end
+  rescue LoadError
+    task :rcov do
+      warn "couldn't load rspec"
+      warn "  #{$!}"
+      exit 1
+    end
+  end
+rescue LoadError
+  task :rcov do
+    warn "couldn't load rcov:"
+    warn "  #{$!}"
+    exit 1
+  end
+end
+
+begin
+  require "yard"
+
+  # Note options are loaded from .yardopts
+  YARD::Rake::YardocTask.new(:yard => :clobber_yard)
+
+  task :clobber_yard do
+    rm_rf "#{relpath}/doc/generated"
+    mkdir_p "#{relpath}/doc/generated/images"
+  end
+rescue LoadError
+  task :yard do
+    warn "couldn't load yard:"
+    warn "  #{$!}"
+    exit 1
+  end
+end
+
+task :default => :spec

data/lib/fr.rb

@@ -0,0 +1,44 @@
+module Fr
+  autoload :Errors,         "fr/errors"
+  autoload :Maybe,          "fr/maybe"
+  autoload :Either,         "fr/either"
+  autoload :Functor,        "fr/functor"
+  autoload :Monad,          "fr/monad"
+  autoload :Monoid,         "fr/monoid"
+  autoload :Additive,       "fr/monoid/numeric"
+  autoload :Multiplicitive, "fr/monoid/numeric"
+  autoload :Random,         "fr/monad/random"
+  autoload :State,          "fr/monad/state"
+  autoload :Reader,         "fr/monad/reader"
+  autoload :Writer,         "fr/monad/writer"
+  autoload :SZipper,        "fr/szipper"
+  autoload :TZipper,        "fr/tzipper"
+  autoload :Thunk,          "fr/thunk"
+
+  def self.thunk(&block)
+    Thunk.new(block)
+  end
+
+  def self.some(value)
+    Fr::Maybe::Some.new(value)
+  end
+
+  def self.none
+    Fr::Maybe::None
+  end
+
+  def self.left(value)
+    Fr::Either::Left.new(value)
+  end
+
+  def self.right(value)
+    Fr::Either::Right.new(value)
+  end
+end
+
+require "fr/array"
+require "fr/boolean"
+require "fr/object"
+require "fr/unfold"
+require "fr/string"
+require "fr/numeric"

data/lib/fr/array.rb

@@ -0,0 +1,168 @@
+class Array
+
+  # Return the first item. Raises an `IndexError` if the Array is `empty?`.
+  #
+  # @example
+  #   [1, 2, 3].head  #=> 1
+  #
+  def head
+    raise IndexError, "head of empty list" if empty?
+    x, = self
+    x
+  end
+
+  # True if `#at` is defined for the given `n`
+  #
+  # @example
+  #   [1, 2, 3].defined_at?(0)    #=> true
+  #   [].defined_at?(0)           #=> false
+  #
+  def defined_at?(n)
+    n < length and -n <= length
+  end
+
+  # @group Selection
+  #############################################################################
+
+  # Selects all elements except the first.
+  #
+  # @example
+  #   [1, 2, 3].tail  #=> [2, 3]
+  #   [1].tail        #=> []
+  #   [].tail         #=> []
+  #
+  # @return [Array]
+  def tail
+    _, *xs = self
+    xs
+  end
+
+  # Selects all elements except the last `n` ones.
+  #
+  # @example
+  #   [1, 2, 3].init      #=> [1, 2]
+  #   [1, 2, 3].init(2)   #=> [1]
+  #   [].tail             #=> []
+  #
+  # @return [Array]
+  def init(n = 1)
+    raise ArgumentError, "n cannot be negative" if n < 0
+    slice(0..-(n + 1)) or []
+  end
+
+  # Select all elements except the first `n` ones.
+  #
+  # @example
+  #   [1, 2, 3].drop(1)   #=> [2, 3]
+  #   [1, 3, 3].drop(2)   #=> [3]
+  #   [].drop(10)         #=> []
+  #
+  # @return [Array]
+  def drop(n)
+    raise ArgumentError, "n cannot be negative" if n < 0
+    slice(n..-1) or []
+  end
+
+  # Select the first `n` elements.
+  #
+  # @example
+  #   [1, 2, 3].take(2)  #=> [1, 2]
+  #   [1, 2, 3].take(0)  #=> []
+  #
+  # @return [Array]
+  def take(n)
+    raise ArgumentError, "n cannot be negative" if n < 0
+    slice(0, n) or []
+  end
+
+  # Split the array in two at the given position.
+  #
+  # @example
+  #   [1, 2, 3].split_at(2)   #=> [[1,2], [3]]
+  #   [1, 2, 3].split_at(0)   #=> [[], [1,2,3]]
+  #
+  # @return [(Array, Array)]
+  def split_at(n)
+    n = length + n if n < 0
+    return take(n), drop(n)
+  end
+
+  # @endgroup
+  #############################################################################
+
+  # @group Filtering
+  #############################################################################
+
+  # Drops the longest prefix of elements that satisfy the predicate.
+  #
+  # @return [Array]
+  def drop_while(&block)
+    # This is in tail call form
+    if not empty? and yield(head)
+      tail.drop_while(&block)
+    else
+      self
+    end
+  end
+
+  # Drops the longest prefix of elements that do not satisfy the predicate.
+  #
+  # @return [Array]
+  def drop_until(&block)
+    # This is in tail call form
+    unless empty? or yield(head)
+      tail.drop_until(&block)
+    else
+      self
+    end
+  end
+
+  # Takes the longest prefix of elements that satisfy the predicate.
+  #
+  # @return [Array]
+  def take_while(accumulator = [], &block)
+    # This is in tail call form
+    if not empty? and yield(head)
+      tail.take_while(head.snoc(accumulator), &block)
+    else
+      accumulator
+    end
+  end
+
+  # Takes the longest prefix of elements that do not satisfy the predicate.
+  #
+  # @return [Array]
+  def take_until(accumulator = [], &block)
+    # This is in tail call form
+    unless empty? or yield(head)
+      tail.take_until(head.snoc(accumulator), &block)
+    else
+      accumulator
+    end
+  end
+
+  # Splits the array into prefix/suffix pair according to the predicate.
+  #
+  # @return [(Array, Array)]
+  def split_until(&block)
+    prefix = take_while(&block)
+    suffix = drop(prefix.length)
+    return prefix, suffix
+  end
+
+  # Splits the array into prefix/suffix pair according to the predicate.
+  #
+  # @return [(Array, Array)]
+  def split_when(&block)
+    prefix = take_until(&block)
+    suffix = drop(prefix.length)
+    return prefix, suffix
+  end
+
+  # @endgroup
+  #############################################################################
+end
+
+require "fr/functor/array"
+require "fr/monoid/array"
+require "fr/monad/array"

data/lib/fr/boolean.rb

@@ -0,0 +1,15 @@
+class TrueClass
+  # true.maybe(value) => Fr::Some(value)
+  def maybe(value)
+    Fr::Maybe::Some.new(value)
+  end
+end
+
+class FalseClass
+  # false.maybe(value) => Fr::None
+  def maybe(value)
+    Fr::Maybe::None
+  end
+end
+
+require "fr/monoid/boolean"

data/lib/fr/either.rb

@@ -0,0 +1,94 @@
+module Fr
+
+  class Either
+
+    class << self
+      # :: [Either a b] -> [a]
+      def lefts(es)
+        es.inject([]) do |ls,e|
+          e.fold(lambda{|l| ls.push(l) }, lambda{|_| ls })
+        end
+      end
+
+      # :: [Either a b] -> [b]
+      def rights(es)
+        es.inject([]) do |rs,e|
+          e.fold(lambda{|_| rs }, lambda{|r| rs.push(r) })
+        end
+      end
+
+      # :: [Either a b] -> [a] -> [b]
+      def partition(es)
+        es.inject([[],[]]) do |(ls,rs),e|
+          e.fold(lambda{|l| [ls.push(l), rs] },
+                 lambda{|r| [ls, rs.push(r)] })
+        end
+      end
+    end
+
+    class Left < Either
+      def initialize(value)
+        @value = value
+      end
+
+      # :: Either a b -> (a -> c) -> (b -> c) -> c
+      def fold(left, right)
+        left.call(@value)
+      end
+
+      def map(&f)
+        self
+      end
+
+      def right?
+        false
+      end
+
+      def left?
+        true
+      end
+
+      def eql?(other)
+        Either === other and
+        other.fold(lambda{|o| o == @value }, lambda{|_| false })
+      end
+
+      alias_method :==, :eql?
+    end
+
+    class Right < Either
+      def initialize(value)
+        @value = value
+      end
+
+      # :: Either a b -> (a -> c) -> (b -> c) -> c
+      def fold(left, right)
+        right.call(@value)
+      end
+
+      def map(&f)
+        Right.new(f.call(@value))
+      end
+
+      def right?
+        true
+      end
+
+      def left?
+        false
+      end
+
+      def eql?(other)
+        Either === other and
+        other.fold(lambda{|_| false }, lambda{|o| o == @value })
+      end
+
+      alias_method :==, :eql?
+    end
+  end
+
+end
+
+require "fr/functor/either"
+require "fr/monoid/either"
+require "fr/monad/either"

data/lib/fr/errors.rb

@@ -0,0 +1,5 @@
+module Fr
+  module Errors
+    autoload :ZipperError,  "fr/errors/zipper_error"
+  end
+end

data/lib/fr/errors/zipper_error.rb

@@ -0,0 +1,8 @@
+module Fr
+  module Errors
+
+    class ZipperError < StandardError
+    end
+
+  end
+end

data/lib/fr/functor.rb

@@ -0,0 +1,11 @@
+module Fr
+  module Functor
+    # map :: Functor f => (a -> b) -> f a -> f b
+
+    # :: Functor f => f a -> f ()
+    def void(f)
+      map(lambda{|a| nil }, f)
+    end
+
+  end
+end

data/lib/fr/functor/array.rb

@@ -0,0 +1,15 @@
+#
+# Because Array is a monad, we automatically derive
+# the implementation for `map` from `liftM`.
+#
+# class << Array
+#   include Fr::Functor
+#
+#   def map(f = nil, x = nil, &block)
+#     (x.nil?) ?
+#       (block_given?) ?
+#         f.map(&block) :         # Array.map([..]){ .. }
+#         lambda{|x| x.map(&f) } :# Array.map(lambda{ .. })
+#         x.map(&f)               # Array.map(lambda{ .. }, [..])
+#   end
+# end