adt 0.0.2 → 0.0.3

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+0.0.3
+=====
+
+* Added a DSL for declaring operations.
 
 0.0.2
 =====

data/README.md

@@ -36,7 +36,7 @@ What you now have:
 * A good #== and #inspect implementation
 * \#_case_? and #when__case_(handle_case_proc, default_proc) for dealing with a single case
 
-Check the [documentation](http://rubydoc.info/gems/adt/0.0.2/ADT:cases) for more information.
+Check the [documentation](http://rubydoc.info/gems/adt/0.0.3/ADT:cases) for more information.
 
 Usage examples
 --------------

data/lib/adt.rb

@@ -193,5 +193,44 @@ module ADT
       end
     end
   end
+
+  # Defines an operation (method) for an ADT, using a DSL similar to the cases definition.
+  # 
+  # For each case in the adt, the block should call a method of the same name, and pass it
+  # a block argument that represents the implementation of the operation for that case.
+  # 
+  # eg. To define an operation on a Maybe/Option type which returns the wrapped value, or 
+  # the supplied argument if it doesn't have anything:
+  # 
+  #     class Maybe
+  #       extend ADT
+  #       cases do
+  #         just(:value)
+  #         nothing
+  #       end
+  #
+  #       operation :or_value do |if_nothing|
+  #         just { |value| value }
+  #         nothing { if_nothing }
+  #       end
+  #     end
+  #
+  #
+  # @param [Symbol] The name of the operations to define.
+  # @param [Proc] The definitions of the implementations for each case.
+  def operation(sym, &definitions)
+    define_method(sym) do |*args|
+      dsl = CaseRecorder.new
+      dsl_cls = class <<dsl; self; end
+      # This is hax so that we can 'instance_eval' the definitions block on a recorder,
+      # but in this case the definitions block could have arguments (which are arguments
+      # to the operation)
+      dsl_cls.send(:define_method, :_defs, &definitions)
+      dsl._defs(*args)
+      # Now we just turn the [(case_name, impl)] structure into an argument for fold and
+      # are done. Fold with a hash will check that all keys are defined.
+      fold(dsl._implementations.inject({}) { |memo, (c, impl)| memo[c] = impl; memo })
+    end
+  end
 end
 

data/lib/adt/case_recorder.rb

@@ -2,22 +2,35 @@ module ADT
   # @private
   class CaseRecorder
     alias :__instance_eval :instance_eval
-
     instance_methods.each { |m| undef_method m unless m =~ /(^__|object_id)/ }
 
-    attr_reader :_church_cases
-
     def initialize
-      @_church_cases = []
+      @tape = []
+    end
+
+    def _church_cases
+      @tape.map { |xs| xs[0..1] }
+    end
+
+    def _implementations
+      # Implementations have a symbol and a block argument
+      @tape.map { |xs| [xs[0], xs[2]] }
     end
 
     # Defines a case for an ADT.
     def define_case(sym, *args)
-      @_church_cases << [sym, args]
+      record(sym, *args)
+    end
+    
+    private
+
+    def record(sym, *args, &blk)
+      @tape << [sym, args, blk]
     end
 
-    def method_missing(sym, *args)
-      define_case(sym, *args)
+    # Records EVERYTHING
+    def method_missing(sym, *args, &blk)
+      record(sym, *args, &blk)
     end
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: adt
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Nick Partridge