adt 0.0.6 → 0.0.7

data/lib/adt.rb

@@ -1,6 +1,6 @@
 require 'adt/case_recorder'
 
-module StringHelp
+module AdtUtils
   def self.underscore(camel_cased_word)
     word = camel_cased_word.to_s.dup
     word.gsub!(/::/, '/')
@@ -12,6 +12,16 @@ module StringHelp
   end
 end
 
+def ADT(&block)
+  m = Module.new
+  m.class.send(:public, :define_method)
+  (class <<m; self end).define_method(:extended) do |base|
+      base.extend(ADT)
+      base.send(:cases, &block)
+  end
+  m
+end
+
 module ADT
   module_function
 
@@ -81,68 +91,64 @@ module ADT
     cases = dsl._church_cases
     num_cases = cases.length
     case_names = cases.map { |x| x[0] }
-    is_enumeration = cases.all?{ |(_, args)| args.count == 0 }
-
-    # creates procs with a certain arg count. body should use #{prefix}N to access arguments. The result should be
-    # eval'ed at the call site
-    proc_create = proc { |argc, prefix, body|
-      args = argc > 0 ? "|#{(1..argc).to_a.map { |a| "#{prefix}#{a}" }.join(',')}|" : ""
-      "proc { #{args} #{body} }" 
-    }
+    is_enumeration = cases.all? { |(_, args)| args.count == 0 }
 
     # Initializer. Should not be used directly.
-    define_method(:initialize) do |&fold|
-      @fold = fold
+    define_method(:initialize) do |tag, tag_index, values|
+      @tag = tag
+      @tag_index = tag_index
+      @values = values
     end
 
     # The Fold.
     define_method(:fold) do |*args|
       if args.first && args.first.is_a?(Hash) then
-        @fold.call(*case_names.map { |cn| args.first.fetch(cn) })
+        args.first[@tag].call(*@values)
       else
-        @fold.call(*args)
+        args[@tag_index].call(*@values)
       end
     end
 
     # If we're inside a named class, then set up an alias to fold
-    fold_synonym = StringHelp.underscore(name.split('::').last)
-    if fold_synonym && fold_synonym.length > 0 then
-      define_method(fold_synonym) do |*args| fold(*args) end
+    fold_synonym = name && AdtUtils.underscore(name.split('::').last)
+    if fold_synonym && !fold_synonym.empty? then
+      alias_method(fold_synonym, :fold)
     end
 
     # The Constructors
     cases.each_with_index do |(name, case_args), index|
-      constructor = proc { |*args| self.new(&eval(proc_create[num_cases, "a", "a#{index+1}.call(*args)"])) }
+      constructor = lambda { |*args| self.new(name, index, args) }
       if case_args.size > 0 then
         singleton_class.send(:define_method, name, &constructor)
       else
         # Cache the constructed value if it is unary
         singleton_class.send(:define_method, name) do
           instance_variable_get("@#{name}") || begin
-            instance_variable_set("@#{name}", constructor.call)
+            instance_variable_set("@#{name}", self.new(name, index, []))
           end
         end
       end
     end
 
+    # Case info
+    singleton_class.send(:define_method, :case_info) { cases }
+
     # Getter methods for common accessors
     all_arg_names = cases.map { |(_, args)| args }.flatten
     all_arg_names.each do |arg|
-      case_positions = cases.map { |(_, args)| args.index(arg) && [args.index(arg), args.count] }
+      case_positions = cases.map { |(n, args)| args.index(arg) }
       if case_positions.all?
-        define_method(arg) do
-          fold(*case_positions.map { |(position, count)| 
-            eval(proc_create[count, "a", "a#{position+1}" ])
-          })
-        end
+        define_method(arg) { 
+          @values[case_positions[@tag_index]]
+        }
       end
     end
 
     # Case info methods
     # Indexing is 1-based
-    define_method(:case_index) do fold(*(1..case_names.length).to_a.map { |i| proc { i } }) end
-    define_method(:case_name) do fold(*case_names.map { |i| proc { i.to_s } }) end
-    define_method(:case_arity) do fold(*cases.map { |(_, args)| proc { args.count } }) end
+    define_method(:case_index) { @tag_index + 1 }
+    define_method(:case_name) { @tag.to_s }
+    define_method(:case_arity) { self.class.case_info[@tag_index][1].count }
 
     # Enumerations are defined as classes with cases that don't take arguments. A number of useful
     # functions can be defined for these.
@@ -151,31 +157,22 @@ module ADT
         @all_values ||= case_names.map { |x| send(x) }
       end
 
-      define_method(:to_i) { case_index }
+      alias_method(:to_i, :case_index)
       singleton_class.send(:define_method, :from_i) do |idx| send(case_names[idx - 1]) end
+      #TODO succ, pred
     end
 
     # The usual object helpers
     define_method(:inspect) do
-      "#<" + self.class.name + fold(*cases.map { |(cn, case_args)|
-        index = 0
-        bit = case_args.map { |ca| 
-          index += 1
-          " #{ca}:#\{a#{index}\.inspect}"
-        }.join('')
-        eval(proc_create[case_args.count, "a", " \" #{cn}#{bit}\""])
-      }) + ">"
+      args = self.class.case_info[@tag_index][1]
+      "#<#{self.class.name} #{@tag}#{args.zip(@values).map { |(x,y)| " #{x}:#{y.inspect}" }.join("")}>"
     end
 
     define_method(:==) do |other|
       !other.nil? && case_index == other.case_index && to_a == other.to_a
     end
 
-    define_method(:to_a) do 
-      fold(*cases.map { |(cn, args)|
-        eval(proc_create[args.count, "a", "[" + (1..args.count).to_a.map { |idx| "a#{idx}" }.join(',') + "]"])
-      })
-    end
+    define_method(:to_a) { @values }
 
     # Comparisons are done by index, then by the values within the case (if any) via #to_a
     define_method(:<=>) do |other|
@@ -190,22 +187,12 @@ module ADT
     cases.each_with_index do |(name, args), idx|
       #     Thing.foo(5).foo? # <= true
       #     Thing.foo(5).bar? # <= false
-      define_method("#{name}?") do
-        fold(*case_names.map { |cn|
-          eval(proc_create[0, "a", cn == name ? "true" : "false"])
-        })
-      end
+      define_method("#{name}?") { @tag == name }
       
       #     Thing.foo(5).when_foo(proc {|v| v }, proc { 0 }) # <= 5
       #     Thing.bar(5).when_foo(proc {|v| v }, proc { 0 }) # <= 0
       define_method("when_#{name}") do |handle, default|
-        fold(*case_names.map { |cn| 
-          if (cn == name)
-           proc { |*args| handle.call(*args) }
-          else
-           default
-          end
-        })
+        @tag == name ? handle.call(*@values) : default.call
       end
     end
   end
@@ -249,7 +236,7 @@ module ADT
         # instance_exec it back on the instance.
         # TODO: use the proc builder like in the `cases` method, which will let us tie 
         # down the arity
-        some_impl = proc { |*args| the_instance.instance_exec(*args, &impl) }
+        some_impl = lambda { |*args| the_instance.instance_exec(*args, &impl) }
         memo[c] = some_impl
         memo 
       })

data/lib/data/maybe.rb

@@ -8,6 +8,10 @@ class Maybe
   end
 
   def map
+    fold(proc { self }, proc { |v| self.class.just(yield v) })
+  end
+
+  def bind
     fold(proc { self }, proc { |v| yield v })
   end
 

data/lib/data/validation.rb

@@ -0,0 +1,21 @@
+require 'adt'
+
+class Validation
+  extend ADT
+  cases do
+    failure(:errors)
+    success(:value)
+  end
+
+  def self.fail_with(error)
+    failure([error])
+  end
+
+  def map
+    fold(proc { |_| self }, proc { |v| Validation.success(yield v) })
+  end
+
+  def bind(&b)
+    fold(proc { |_| self }, b)
+  end
+end

metadata

@@ -1,66 +1,52 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: adt
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 6
-  version: 0.0.6
+version: !ruby/object:Gem::Version
+  version: 0.0.7
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Nick Partridge
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-09-06 00:00:00 +10:00
-default_executable: 
+date: 2012-07-10 00:00:00.000000000 Z
 dependencies: []
-
-description: Define multiple constructors for a type, then match on them! Get all catamorphic.
+description: Define multiple constructors for a type, then match on them! Get all
+  catamorphic.
 email: nkpart@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/adt/case_recorder.rb
 - lib/adt.rb
 - lib/data/maybe.rb
+- lib/data/validation.rb
 - CHANGELOG.md
 - README.md
-has_rdoc: true
-homepage: ""
+homepage: ''
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Algebraic data type DSL
 test_files: []
-
+has_rdoc: