mon 0.0.2

data/lib/monads/list.rb

@@ -0,0 +1,89 @@
+# The List monad wraps lists. Gasp!
+#
+# A simple example:
+# <tt>l = List[1, 2, 3]
+# list9 = l.bind { |i| i * 9 } # ==> List[9, 18, 27]
+# longList = l.bind { |i| [i, i * 2] } # ==> List[1, 2, 2, 4, 3, 6]</tt>
+#
+# Simple and straightforward.
+
+module Mon
+
+  module Monad
+
+    require_relative 'chainable_monad'
+    require_relative 'monad'
+    
+    class List < Monad
+
+      include ChainableMonad
+
+      def initialize(list)
+        @list = list
+      end
+
+      # Create a list. Eg: List[1, 2, 3]
+      def self.[](*list)
+        List.new(list)
+      end
+
+      # Apply fun to all elements of the list (ala map):
+      # List[1, 2, 3].map { |i| i + 5 } # ==> List[6, 7, 8]
+      def bind &fun
+        List.send(:new, @list.map { |i| fun.call(i) }.map { |i| (i.is_a? List) ? i.to_a : i}.flatten(1))
+      end
+
+      # Return the array wrapped by the List
+      def unwrap
+        to_a
+      end
+
+      # Alias for #unwrap
+      def _
+        to_a
+      end
+
+      def _canBind? name
+        @list.all? { |i| i.respond_to?(name) }
+      end
+
+      def to_s
+        (@list.length > 3) ? (tail = "...") : tail = "" 
+        "List[#{ @list.take(3).join(", ") }#{ tail }]"
+      end
+      
+      # Return the array wrapped by the list
+      def to_a
+        @list
+      end
+      
+      class << self
+        protected :new
+      end
+      
+      def eql?(other)
+        if other.is_a? List
+          @list == other.unwrap
+        elsif other.is_a? Array
+          @list == other
+        else
+          false
+        end
+      end
+
+      def ==(o)
+        eql?(o)
+      end
+      
+      def equal?(o)
+        eql?(o)
+      end
+
+      def self::valid?(o)
+        o.is_a?(List)
+      end
+      
+      protected :unwrap, :_canBind?
+    end
+  end
+end

data/lib/monads/maybe.rb

@@ -0,0 +1,211 @@
+# The Maybe monad wraps a possible value. It allows chaining of
+# operations on a potentially-null value.
+#
+# A simple example:
+# <tt>m = Maybe[callSomeIntOrNilFunction()]
+# v = (m * 3 + 2).abs
+# # Depending whether the original method call returned a number or nil,
+# # could be either None or Some[N].</tt>
+
+module Mon
+
+  module Monad
+
+    require_relative 'chainable_monad'
+    require_relative 'monad'
+
+    # Superclass for Some and None. Can be used as follows:
+    # <tt>m = Maybe[nil] # ==> None
+    # m = Maybe[5]   # ==> Some[5]
+    # m = Maybe[nil] * 7 # ==> None
+    # m = Maybe[5] * 7 # ==> Some[35]
+    # m = Maybe[call_to_fun].someOperation(3) # ==> Some[...] or None, never an error</tt>
+    class Maybe < Monad
+      include ChainableMonad
+
+      # Override to catch None
+      def method_missing(name, *args, &fun)
+        self.bind { |o| o.send(name, *args, &fun) }
+      end
+
+      # Use to instantiate a Maybe monad:
+      # <tt>m = Maybe[<either nil/false or not>]</tt>
+      def self.[](obj)
+        if obj.is_a? Maybe
+          obj
+        elsif obj
+          Some[obj]
+        else
+          None[]
+        end
+      end
+
+      # Get the value, or throw an exception (using the optional supplied msg) if it's empty
+      def orFail(msg = nil)
+        msg = "#{ self } is empty!" unless msg
+        throw RuntimeError.new(msg)
+      end
+
+      # For Contracts, DEPRECATED
+      def valid?(o)
+        o.is_a? Maybe
+      end
+
+      class << self
+        protected :new
+      end
+    end
+
+    # The Some class represents a value that is NOT null/false
+    class Some < Maybe
+
+      def initialize(obj)
+        @obj = obj
+        super()
+      end
+
+      # Wrap an object. You probably want Maybe[...], but there's a slight difference:
+      # Maybe[nil] # ==> None
+      # Some[nil] # ==> Some[nil]
+      def self.[](obj)
+        if obj.is_a? None
+          obj
+        else
+          Some.new(obj)
+        end
+      end
+
+      # Unwrap the wrapped value, nil or not
+      def unwrap
+        @obj
+      end
+
+      def _canBind? name
+        @obj.respond_to? name
+      end
+
+      # If there's a wrapped value, return it. Otherwise, either return
+      # the supplied object, or execute the supplied block.
+      # Eg:
+      # <tt>Maybe[1].or(5) # ==> 1
+      # Maybe[nil].or(5) # ==> 5
+      # Maybe[nil].or { throw Exception.new("...") } # ==> Exception!
+      def or obj = nil, &f
+        @obj
+      end
+
+      # Get the value, or throw an exception (using the optional supplied msg) if it's empty
+      def orFail(msg = nil)
+        msg = "No such value!" if msg.nil?
+        self::or { throw RuntimeError.new(msg) }
+      end
+
+      # If we're wrapping a value, apply fun() to it. Otherwise, None stays None.
+      def bind &fun
+        o = fun.call(@obj)
+        if o.is_a? Maybe
+          o
+        elsif o
+          Some[o]
+        else
+          None::none
+        end
+      end
+
+      def to_s
+        "Some[#{ @obj.to_s }]"
+      end
+      
+      def eql?(other)
+        if other.is_a? Some
+          @obj == other.unwrap
+        else
+          @obj == other
+        end
+      end
+
+      def ==(o)
+        eql?(o)
+      end
+      
+      def equal?(o)
+        eql?(o)
+      end
+      
+      class << self
+        protected :new
+      end
+
+      protected :unwrap, :_canBind?
+    end
+
+    class None < Maybe
+
+      # If we're wrapping a value, apply fun() to it. Otherwise, None stays None.
+      def bind &fun
+        self
+      end
+
+      # Unwrap the wrapped value, nil or not
+      def unwrap
+        nil
+      end
+      
+      # If there's a wrapped value, return it. Otherwise, either return
+      # the supplied object, or execute the supplied block.
+      # Eg:
+      # <tt>Maybe[1].or(5) # ==> 1
+      # Maybe[nil].or(5) # ==> 5
+      # Maybe[nil].or { throw Exception.new("...") } # ==> Exception!</tt>
+      def or obj = nil, &f
+        if obj and f
+          f.call obj
+        elsif f
+          f.call
+        else
+          obj
+        end
+      end
+
+      def _canBind? name
+        true
+      end
+
+      # Return a new None object. Takes no args.
+      # <tt>None[] # ==> None</tt>
+      def self.[]
+        None.new
+      end
+
+      def to_s
+        "None"
+      end
+      
+      def initialize
+        super()
+      end
+      
+      def eql?(other)
+        other.is_a? None
+      end
+
+      def ==(o)
+        eql?(o)
+      end
+      
+      def equal?(o)
+        eql?(o)
+      end
+
+      def self::none
+        self.new
+      end
+
+      class << self
+        protected :new
+      end
+      
+      protected :unwrap, :_canBind?
+    end
+  end
+end

data/lib/monads/monad.rb

@@ -0,0 +1,11 @@
+
+module Mon
+  module Monad
+
+    class Monad
+      # Empty class, for matching purposes
+      private_class_method :new
+    end
+
+  end
+end

data/lib/monads/reactron.rb

@@ -0,0 +1,175 @@
+# The React monad wraps a changeable value, and catches changes to that value.
+#
+# A simple example:
+# <tt>r = React[5]
+# d = r * r
+# # Currently r = Reactron[5], d = Reactor[25]
+# r << 25
+# # Now r = Reactron[25], d = Reactor[625]
+# dd = d * 2
+# # d = Reactor[625], dd = Reactor[1250]</tt>
+#
+# More or less, this is a Listener pattern. Reactrons are listenable,
+# Reactors are listeners.
+
+module Mon
+  
+  module Monad
+
+    require_relative 'chainable_monad'
+    require_relative 'monad'
+
+    # The React class is the parent of Reactron and Reactor. The key difference
+    # between the two is the presence of the << operator. The value of a Reactor is
+    # derived from a Reactron, and cannot be directly changed. If viewed as a tree,
+    # Reactrons are the root, and only the root may be changed.
+    #
+    # However, we can have more than one root!
+    # <tt>m = React[2]  # ==> Reactron[2]
+    # n = React[10] # ==> Reactron[10]
+    # v = m * n     # Currently v == Reactor[20]
+    # n << 5        # Now v == Reactor[10]</tt>
+    #
+    # Usage of React is straightforward:
+    # <tt>r = React[some_value]</tt>
+    class React < Monad
+      include ChainableMonad
+      
+      # Wrap a value in a Reactron:
+      # <tt>r = React["test"] # ==> Reactron["test"]
+      def self::[] obj
+        if (obj.is_a? Proc)
+          Reactor[obj]
+        else
+          Reactron[obj]
+        end
+      end
+      
+      class << self
+        protected :new
+      end
+
+      def self::valid?(v)
+        v.is_a? React
+      end
+    end    
+
+    # The Reactron class represents a changeable value, from which other
+    # values can be derived (as Reactrons)
+    class Reactron < React
+      
+      def initialize(obj)
+        @obj = obj
+      end
+
+      # You should be using React[...]
+      def self::[] obj
+        Reactron.new(obj)
+      end
+
+      # Apply fun to the value wrapped by this Reactron. Returns a
+      # Reactor. Whenever the value is changed (with <<), all derived
+      # Reactors are also updated.
+      def bind &fun
+        Reactor[lambda { fun.call(self.unwrap) }]
+      end
+
+      def _canBind? name
+        @obj.respond_to? name
+      end
+
+      # Unwrap the value contained by this Reactron
+      def unwrap
+        @obj
+      end
+
+      # Change the value of this Reactron
+      def << obj
+        @obj = obj
+        self
+      end
+
+      def eql? o
+        if o.is_a? React
+          @obj == o.unwrap
+        else
+          @obj == o
+        end
+      end
+
+      def equal? o
+        eql? o
+      end
+
+      def ==(o)
+        eql? o
+      end
+
+      def to_s
+        "Reactron[#{ @obj }]"
+      end
+      
+      class << self
+        protected :new
+      end
+
+      protected :_canBind?
+    end
+
+    class Reactor < React
+
+      def initialize(fun)
+        @fun = fun
+      end
+      
+      # Apply fun to the value wrapped by this Reactor (which in turn is
+      # a transform on some Reactron), returning another
+      # Reactron. Changes to the root Reactron will propagate through
+      # the whole tree.
+      def bind &fun
+        Reactor[lambda { fun.call(self.unwrap) }]
+      end
+
+      # You want React[...]
+      def self::[] fun
+        Reactor.new(fun)
+      end
+
+      # Unwrap the (current) value contained by this Reactor
+      def unwrap
+        r = @fun.call
+        r.is_a?(Reactor) ? r.unwrap : r
+      end
+
+      def _canBind? name
+        unwrap.respond_to? name
+      end
+
+      def eql? o
+        if o.is_a? React
+          @fun.call == o.unwrap
+        else
+          @fun.call == o
+        end
+      end
+
+      def equal? o
+        eql? o
+      end
+
+      def ==(o)
+        eql? o
+      end
+
+      def to_s
+        "Reactor[#{ unwrap }]"
+      end
+      
+      class << self
+        protected :new
+      end
+
+      protected :_canBind?
+    end
+  end
+end