deterministic 0.14.1 → 0.15.0

data/lib/deterministic/monad.rb

@@ -3,15 +3,15 @@ module Deterministic
     class NotMonadError < StandardError; end
 
     # Basicly the `pure` function
-    def initialize(value)
-      @value = join(value)
+    def initialize(init)
+      @value = join(init)
     end
 
     # If the passed value is monad already, get the value to avoid nesting
     # M[M[A]] is equivalent to M[A]
-    def join(value)
-      if value.is_a? self.class then value.value
-      else value end
+    def join(other)
+      if other.is_a? self.class then other.value
+      else other end
     end
 
     # The functor: takes a function (a -> b) and applies it to the inner value of the monad (Ma),
@@ -27,6 +27,20 @@ module Deterministic
     # the self.class, i.e. the containing monad is passed as a second (optional) arg to the function
     def bind(proc=nil, &block)
       (proc || block).call(value).tap do |result|
+
+        # def parent_name(obj)
+        #   parts = obj.class.name.split('::')
+        #   if parts.count > 1
+        #     parts[0..-2].join('::')
+        #   else
+        #     parts[0]
+        #   end
+        # end
+
+        # self_parent  = parent_name(self)
+        # other_parent = parent_name(result)
+        # raise NotMonadError, "Expected #{result.inspect} to be an #{other_parent}" unless self_parent == other_parent
+
         parent = self.class.superclass === Object ? self.class : self.class.superclass
         raise NotMonadError, "Expected #{result.inspect} to be an #{parent}" unless result.is_a? parent
       end

data/lib/deterministic/option.rb

@@ -1,28 +1,11 @@
 module Deterministic
-  # Abstract parent of Some and None 
-  class Option
-    include Monad
-
-    module PatternMatching
-      include Deterministic::PatternMatching
-      class Match
-        include Deterministic::PatternMatching::Match
-
-        %w[Some None Option].each do |s|
-          define_method s.downcase.to_sym do |value=nil, &block|
-            klas = self.class.module_eval(s)
-            push(klas, value, block)
-          end
-        end
-      end
-    end
-
-    include PatternMatching
+  Option = Deterministic::enum {
+    Some(:s)
+    None()
+  }
 
-    # This is an abstract class, can't ever instantiate it directly
+  class Option
     class << self
-      protected :new
-
       def some?(expr)
         to_option(expr) { expr.nil? }
       end
@@ -39,82 +22,59 @@ module Deterministic
         yield rescue None.new
       end
     end
+  end
 
-    def map(proc=nil, &block)
-      return self if none?
-      bind(proc || block)
-    end
+  impl(Option) {
+    class NoneValueError < StandardError; end
 
-    ## Convert the inner value to an Array
-    def value_to_a
-      map { self.class.new(Array(value)) }
+    def fmap(&fn)
+      match {
+        Some(s) { |m| m.class.new(fn.(s)) }
+        None()  { |n| n }
+      }
     end
 
-    ## Add the inner values of two Some
-    def +(other)
-      return other if none?
-      fmap { |v| 
-        other.match {
-          some { v + other.value }
-          none { self }
-        }
+    def map(&fn)
+      match {
+        Some(s) { |m| m.bind(&fn) }
+        None()  { |n| n }
       }
     end
 
     def some?
-      is_a? Some
+      is_a? Option::Some
     end
 
     def none?
-      is_a? None
+      is_a? Option::None
     end
 
-    def value_or(default)
-      return default if none?
-      return value
+    def value_or(n)
+      match {
+        Some(s) { s }
+        None()  { n }
+      }
     end
 
-    class Some < Option
-      class << self; public :new; end
+    def value_to_a
+      @value
     end
 
-    class None < Option
-      class << self
-        public :new
-
-        def instance
-          @instance ||= new
-        end
-      end
-
-      def initialize(*args)
-        @value = self
-      end
-
-      def inspect
-        "None"
-      end
-
-      private :value
-
-      def fmap(*args)
-        self
-      end
-
-      alias :map :fmap
-
-      def ==(other)
-        other.class == self.class
-      end
+    def +(other)
+      match {
+        None() { other }
+        Some(_, where { !other.is_a?(Option)}) { raise TypeError, "Other must be an #{Option}"}
+        Some(s, where { other.some? }) { Option::Some.new(s + other.value) }
+        Some(_) { |s| s }
+      }
     end
-  end
+  }
 
-module_function
-  def Some(value)
-    Option::Some.new(value)
+  module Prelude
+    module Option
+      None = Deterministic::Option::None.new
+      def Some(s); Deterministic::Option::Some.new(s); end
+      def None(); Deterministic::Prelude::Option::None; end
+    end
   end
-
-  Some = Deterministic::Option::Some
-  None = Deterministic::Option::None.instance
 end
-# p Deterministic::Option::Some::Match.new(.methods

data/lib/deterministic/protocol.rb

@@ -0,0 +1,103 @@
+module Deterministic
+  class ProtocolBuilder
+
+    def initialize(typevar, block)
+      @typevar, @block = typevar, block
+      @protocol = Class.new
+    end
+
+    def build
+      instance_exec(&@block)
+      @protocol
+    end
+
+    def method_missing(m, *args)
+      [m, args]
+    end
+
+    Signature = Struct.new(:name, :params, :return_type, :block)
+
+    def fn(signature, &block)
+      m = signature.to_a.flatten
+      name        = m[0]
+      return_type = m[-1]
+      params      = Hash[(m[1..-2][0] || {}).map { |k, v| [k[0], v] }]
+
+      @protocol.instance_eval {
+          define_singleton_method(name) {
+            Signature.new(name, params, return_type, block)
+          }
+      }
+
+      @protocol.instance_eval {
+        if block
+          define_method(name) { |*args|
+            block.call(args)
+          }
+        end
+      }
+    end
+  end
+
+  class InstanceBuilder
+    def initialize(protocol, type, block)
+      @protocol, @type, @block = protocol, type, block
+      @instance = Class.new(@protocol::Protocol)
+    end
+
+    def build
+      @instance.class_exec(&@block)
+      protocol  = @protocol::Protocol
+      methods   = protocol.methods(false)
+      inst_type = @type
+
+      @instance.instance_exec {
+        methods.each { |name|
+          if method_defined?(name)
+            meth        = instance_method(name)
+            signature   = protocol.send(name)
+            params      = signature.params
+            expect_type = inst_type[signature.return_type]
+
+            define_method(name) { |*args|
+              args.each_with_index { |arg, i|
+                name     = params.keys[i]
+                arg_type = params.fetch(name)
+                expect_arg_type = inst_type.fetch(arg_type)
+
+                raise TypeError, "Expected arg #{name} to be a #{expect_arg_type}, got #<#{arg.class}: #{arg.inspect}>" unless arg.is_a? expect_arg_type
+              }
+
+              result = meth.bind(self).call(*args)
+              raise TypeError, "Expected #{name}(#{args.join(', ')}) to return a #{expect_type}, got #<#{result.class}: #{result.inspect}>" unless result.is_a? expect_type
+              result
+            }
+          end
+        }
+      }
+
+      missing = methods.detect { |m| !@instance.instance_methods(false).include?(m) }
+
+      raise NotImplementedError, "`#{missing}` has no default implementation for #{@protocol} #{@type.to_s}" unless missing.nil?
+
+      @instance
+    end
+  end
+
+module_function
+  def protocol(typevar, &block)
+    protocol = ProtocolBuilder.new(typevar, block).build
+    p_module = block.binding.eval('self')
+    p_module.const_set(:Protocol, protocol)
+  end
+
+  def instance(protocol, type, &block)
+    InstanceBuilder.new(protocol, type, block).build
+  end
+
+  module Protocol
+    def const_missing(c)
+      c
+    end
+  end
+end

data/lib/deterministic/result.rb

@@ -1,122 +1,80 @@
-module Deterministic
-  # Abstract parent of Success and Failure
-  class Result
-    include Monad
 
-    module PatternMatching
-      include Deterministic::PatternMatching
-      class Match
-        include Deterministic::PatternMatching::Match
+module Deterministic
+  Result = Deterministic::enum {
+    Success(:s)
+    Failure(:f)
+  }
 
-        %w[Success Failure Result].each do |s|
-          define_method s.downcase.to_sym do |value=nil, &block|
-            klas = klas = self.class.module_eval(s)
-            push(klas, value, block)
-          end
-        end
-      end
+  Deterministic::impl(Result) {
+    def map(proc=nil, &block)
+      match {
+        Success(_) { |s| s.bind(proc || block) }
+        Failure(_) { |f| f }
+      }
     end
 
-    include PatternMatching
-
-    # This is an abstract class, can't ever instantiate it directly
-    class << self
-      protected :new
-    end
+    alias :>> :map
+    alias :and_then :map
 
-    def success?
-      is_a? Success
+    def map_err(proc=nil, &block)
+      match {
+        Success(_) { |s| s }
+        Failure(_) { |f| f.bind(proc|| block) }
+      }
     end
 
-    def failure?
-      is_a? Failure
-    end
+    alias :or_else :map_err
 
-    # `pipe(self: Result(a), op: |Result(a)| -> b) -> Result(a)`
-    # Executes the block passed, but completely ignores its result. If an error is raised within the block it will **NOT** be catched.
     def pipe(proc=nil, &block)
       (proc || block).call(self)
       self
     end
 
-    alias :** :pipe
-    alias :<<  :pipe
+    alias :<< :pipe
 
-    # `pipe(self: Result(a), op: |Result(a)| -> b) -> Result(a)`
-    # Replaces `Success a` with `Result b`. If a `Failure` is passed as argument, it is ignored.
-    def and(other)
-      return self if failure?
-      raise NotMonadError, "Expected #{other.inspect} to be an Result" unless other.is_a? Result
-      other
-    end
-
-    # `or(self: Failure(a), other: Result(b)) -> Result(b)`
-    # Replaces `Failure a` with `Result`. If a `Failure` is passed as argument, it is ignored.
-    def or(other)
-      return self if success?
-      raise NotMonadError, "Expected #{other.inspect} to be an Result" unless other.is_a? Result
-      return other
+    def success?
+      is_a? Result::Success
     end
 
-    # `map(self: Success(a), op: |a| -> Result(b)) -> Result(b)`
-    # Maps a `Success` with the value `a` to another `Result` with the value `b`. It works like `#bind` but only on `Success`.
-    def map(proc=nil, &block)
-      return self if failure?
-      bind(proc || block)
+    def failure?
+      is_a? Result::Failure
     end
 
-    alias :>> :map
-    alias :and_then :map
-
-    # `map_err(self: Failure(a), op: |a| -> Result(b)) -> Result(b)`
-    # Maps a `Failure` with the value `a` to another `Result` with the value `b`. It works like `#bind` but only on `Failure`.
-    def map_err(proc=nil, &block)
-      return self if success?
-      bind(proc || block)
+    def or(other)
+      raise Deterministic::Monad::NotMonadError, "Expected #{other.inspect} to be a Result" unless other.is_a? Result
+      match {
+        Success(_) { |s| s }
+        Failure(_) { other}
+      }
     end
 
-    alias :or_else :map_err
-
-    # `pipe(self: Result(a), op: |Result(a)| -> b) -> Result(a)`
-    # Executes the block passed, but completely ignores its result. If an error is raised within the block it will **NOT** be catched.
-    def try(proc=nil, &block)
-      map(proc, &block)
-    rescue => err
-      Result::Failure.new(err)
+    def and(other)
+      raise Deterministic::Monad::NotMonadError, "Expected #{other.inspect} to be a Result" unless other.is_a? Result
+      match {
+        Success(_) { other }
+        Failure(_) { |f| f }
+      }
     end
 
-    # `+(self: Result(a), other: Result(a)) -> Result(a -> a)`
-    # Add the inner values of two Result
     def +(other)
-      raise Deterministic::Monad::NotMonadError, "Expected #{other.inspect} to be an Result" unless other.is_a? Result
+      raise Deterministic::Monad::NotMonadError, "Expected #{other.inspect} to be a Result" unless other.is_a? Result
       match {
-        success ->(_) { other.success? } { |s| Result::Success.new(s + other.value)}
-        failure ->(_) { other.failure? } { |f| Result::Failure.new(f + other.value)}
-        success { other } # implied other.failure?
-        failure { self }   # implied other.success?
+        Success(s, where { other.success?} ) { Result::Success.new(s + other.value) }
+        Failure(f, where { other.failure?} ) { Result::Failure.new(f + other.value) }
+        Success(_) { other } # implied other.failure?
+        Failure(_) { |f| f } # implied other.success?
       }
     end
+  }
+end
 
-    alias :>= :try
-
-    class Failure < Result
-      class << self; public :new; end
-    end
-
-    class Success < Result
-      class << self; public :new; end
+module Deterministic
+  module Prelude
+    module Result
+      def Success(s); Deterministic::Result::Success.new(s); end
+      def Failure(f); Deterministic::Result::Failure.new(f); end
     end
-  end
 
-  module_function
-  def Success(value)
-    Result::Success.new(value)
+    include Result
   end
-
-  def Failure(value)
-    Result::Failure.new(value)
-  end
-
-  Success = Result::Success
-  Failure = Result::Failure
 end