algebrick 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb30a6eeabbe7769c1f946395bef047d5acf4362
-  data.tar.gz: 5c0289625f919dffe3f57e6fa2e258ca353d4ba9
+  metadata.gz: 7f70cafbfe1296efd6042757bf59917fb2f290aa
+  data.tar.gz: 3466daa431dd466059085c9e6acf42eb872a7335
 SHA512:
-  metadata.gz: 0932e96464a044f3e2a9138efcd07433bf17fb747f1718b73354599750b84543e70f7b29a97db0854343f6f25c04eda02bc6baa8498a90e5feb55f2ac57437ad
-  data.tar.gz: 7bf6898feafadd9694cf898b61c81c9879fcc0dc628044244eed4f9ec5c8d1b3d2888b826305a73d463e08621f79e6759a75b5c84283a4bb48c617d27469671f
+  metadata.gz: 37ea095790d58c8995686a70e4a25936db720d40f28b35ebdefab1e25da4395124cca6aed2f93fd5ee7f0d6d82532d55e05d428121e824b8ffcdb9829ac3b0a7
+  data.tar.gz: 779756c205b84c25f756ad8f2d8658806d9023db3c015f848ffcfb69d6b157686287fa5d3aa06c95745924d70192c87e10d78ed5ddd2cb22e5047d332d9047a1

data/README.md

@@ -11,24 +11,25 @@ It's a small gem providing **algebraic types** and **pattern matching** on them
 ## What is it good for?
 
 -   Defining data structures.
--   Algebraic types play nice with JSON serialization and deserialization. It is ideal for defining
-    message-based cross-process communication.
+-   Algebraic types play nice with JSON serialization and deserialization. It is ideal for defining message-based cross-process communication.
 -   and more...
 
 ## Quick example
 
-Load DSL for type definition and define some algebraic types
+Let's define a Tree
 
 ```ruby
-extend Algebrick::DSL
+Tree = Algebrick.type do |tree|
+  Empty = type
+  Leaf  = type { fields Integer }
+  Node  = type { fields tree, tree }
 
-type_def do
-  tree === empty | leaf(Integer) | node(tree, tree)
+  variants Empty, Leaf, Node
 end
 ```
 
 Now types `Tree(Empty | Leaf | Node)`, `Empty`, `Leaf(Integer)` and `Node(Tree, Tree)` are defined.
-Lets add some methods, don't miss the **pattern matching** example.
+Add some methods, don't miss the **pattern matching** example.
 
 ```ruby
 module Tree

data/README_FULL.md

@@ -26,14 +26,14 @@ Same thing can be defined with this gem:
 
 {include:file:doc/tree1.out.rb}
 
-There are 4 kinds of algebraic types in Algebrick gem:
+There are 4 kinds of algebraic types:
 
--   **Atom** a type that has only one value e.g. `Empty`.
--   **Product** a type that has a set nuber of fields with given type e.g. `Leaf(Integer)`
--   **Variant** a type that does have set number of variants e.g. `Tree(Empty | Leaf(Integer) | Node(Tree, Tree)`.
-    It means that values of `Empty`, `Leaf[1]`, `Node[Empty, Empry]` have all type `Tree`.
--   **ProductVariant** will be created when a recursive type like `list === empty | list(Object, list)` is defined.
-    `List` has two variants `Empty` and itself simultaneously it has fields as product type.
+1.  **Atom** a type that has only one value e.g. `Empty`.
+2.  **Product** a type that has a set number of fields with given type e.g. `Leaf(Integer)`
+3.  **Variant** a type that does have set number of variants e.g. `Tree(Empty | Leaf(Integer) | Node(Tree, Tree)`. It means that values of `Empty`, `Leaf[1]`, `Node[Empty, Empry]` are all of type `Tree`.
+4.  **ProductVariant** will be created when a recursive type like `List(Empty | List(Integer, List))` is defined. `List` has two variants `Empty` and itself, and simultaneously it has fields as product type.
+
+Atom type is implemented with {Algebrick::Atom} and the rest is implemented with {Algebrick::ProductVariant} which behaves differently based on what is set: fields, variants or both.
 
 ### Type definition
 
@@ -49,7 +49,7 @@ There are 4 kinds of algebraic types in Algebrick gem:
 
 ### Pattern matching
 
-Algebraic matchers are helper objects to match algebraic objects and others with
+Algebraic matchers are helper objects to match algebraic values and others with
 `#===` method based on theirs initialization values.
 
 {include:file:doc/pattern_matching.out.rb}
@@ -88,7 +88,7 @@ Just small snippet from a gem I am still working on.
 
       def on_message(message)
         match message,
-              Work.(~any, ~any) --> actor, work do
+              Work.(~any, ~any) >-> actor, work do
                 @executor.tell Finished[actor, work.call, self.reference]
               end
       end
@@ -97,6 +97,5 @@ Just small snippet from a gem I am still working on.
 ### TODO
 
 -   Menu model, TypedArray
--   Pretty print example, see {http://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf}
 -   update actor pattern when gem is done
-
+-   example with birth-number Valid|Invalid

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.2.0

data/lib/algebrick.rb

@@ -18,14 +18,14 @@
 
 require 'set'
 
-class Module
-  # Return any modules we +extend+
-  def extended_modules
-    class << self
-      self
-    end.included_modules
-  end
-end
+#class Module
+#  # Return any modules we +extend+
+#  def extended_modules
+#    class << self
+#      self
+#    end.included_modules
+#  end
+#end
 
 module Algebrick
 
@@ -78,8 +78,8 @@ module Algebrick
     alias_method :_, :any # TODO make it optional
 
     #match Empty,
-    #      Empty -->() {},
-    #      Leaf.(~any) >>-> value do
+    #      Empty >> static_value_like_string,
+    #      Leaf.(~any) >-> value do
     #        value
     #      end
     #match Empty,
@@ -139,6 +139,10 @@ module Algebrick
       to_m | other
     end
 
+    def ^(other)
+      to_m ^ other
+    end
+
     def !
       !to_m
     end
@@ -154,6 +158,10 @@ module Algebrick
     def >>(block)
       to_m >> block
     end
+
+    def >(block)
+      to_m > block
+    end
   end
 
   class Type < Module
@@ -161,6 +169,15 @@ module Algebrick
     include Matching
     include MatcherDelegations
 
+    def initialize(name, &definition)
+      super &definition
+      @name = name
+    end
+
+    def name
+      super || @name
+    end
+
     def to_m(*args)
       raise NotImplementedError
     end
@@ -213,8 +230,8 @@ module Algebrick
   class Atom < Type
     include Value
 
-    def initialize(&block)
-      super &block
+    def initialize(name, &block)
+      super name, &block
       extend self
     end
 
@@ -316,55 +333,11 @@ module Algebrick
     end
   end
 
-  class AbstractProductVariant < Type
-    def be_kind_of(type = nil)
-      if initialized?
-        be_kind_of! type if type
-        if @to_be_kind_of
-          while (type = @to_be_kind_of.shift)
-            be_kind_of! type
-          end
-        end
-      else
-        @to_be_kind_of ||= []
-        @to_be_kind_of << type if type
-      end
-      self
-    end
-
-    def add_field_method_accessor(field)
-      raise TypeError, 'no field names' unless @field_names
-      raise TypeError, "no field name #{field}" unless @field_names.include? field
-      define_method(field) { self[field] }
-    end
-
-    def add_field_method_accessors(*fields)
-      fields.each { |f| add_field_method_accessor f }
-    end
-
-    def add_all_field_method_accessors
-      add_field_method_accessors *@field_names
-    end
-
-    protected
-
-    def be_kind_of!(type)
-      raise NotImplementedError
-    end
-
-    private
-
-    def initialized?
-      !!@initialized
-    end
-
-    def initialize(&block)
-      super &block
-      @initialized = true
-      be_kind_of
-    end
+  class ProductVariant < Type
+    attr_reader :fields, :field_names, :field_indexes, :variants
 
     def set_fields(fields_or_hash)
+      raise TypeError, 'can be set only once' if @fields
       fields, keys = if fields_or_hash.size == 1 && fields_or_hash.first.is_a?(Hash)
                        [fields_or_hash.first.values, fields_or_hash.first.keys]
                      else
@@ -380,16 +353,25 @@ module Algebrick
       @constructor = Class.new(ProductConstructor).tap { |c| c.type = self }
     end
 
-    def set_field_names(names)
-      @field_names = names
-      names.all? { |k| is_kind_of! k, Symbol }
-      dict = @field_indexes =
-          Hash.new { |h, k| raise ArgumentError, "uknown field #{k.inspect}" }.
-              update names.each_with_index.inject({}) { |h, (k, i)| h.update k => i }
-      define_method(:[]) { |key| @fields[dict[key]] }
+    def add_field_method_accessor(field)
+      raise TypeError, 'no field names' unless @field_names
+      raise ArgumentError, "no field name #{field}" unless @field_names.include? field
+      raise ArgumentError, "method #{field} already defined" if instance_methods.include? field
+      define_method(field) { self[field] }
+      self
+    end
+
+    def add_field_method_accessors(*fields)
+      fields.each { |f| add_field_method_accessor f }
+      self
+    end
+
+    def add_all_field_method_accessors
+      add_field_method_accessors *@field_names
     end
 
     def set_variants(variants)
+      raise TypeError, 'can be set only once' if @variants
       variants.all? { |v| is_kind_of! v, Type, Class }
       @variants = variants
       variants.each do |v|
@@ -401,14 +383,91 @@ module Algebrick
       end
     end
 
-    def product_be_kind_of(type)
-      @constructor.send :include, type
+    def new(*fields)
+      raise TypeError unless @constructor
+      @constructor.new *fields
     end
 
-    def construct_product(*fields)
-      @constructor.new *fields
+    alias_method :[], :new
+
+    def ==(other)
+      other.kind_of? ProductVariant and
+          variants == other.variants and fields == other.fields
     end
 
+    def be_kind_of(type)
+      kind
+      @constructor.send :include, type if @constructor
+      variants.each { |v| v.be_kind_of type unless v == self } if @variants
+    end
+
+    def call(*field_matchers)
+      raise TypeError unless @fields
+      Matchers::Product.new self, *field_matchers
+    end
+
+    def to_m
+      case kind
+      when :product
+        Matchers::Product.new self
+      when :product_variant
+        Matchers::Variant.new self
+      when :variant
+        Matchers::Variant.new self
+      else
+        raise
+      end
+    end
+
+    def to_s
+      case kind
+      when :product
+        product_to_s
+      when :product_variant
+        name + '(' +
+            variants.map do |variant|
+              if variant == self
+                product_to_s
+              else
+                variant.name
+              end
+            end.join(' | ') +
+            ')'
+      when :variant
+        "#{name}(#{variants.map(&:name).join ' | '})"
+      else
+        raise
+      end
+    end
+
+    def from_hash(hash)
+      case kind
+      when :product
+        product_from_hash hash
+      when :product_variant
+        product_from_hash hash
+      when :variant
+        field_from_hash hash
+      else
+        raise
+      end
+    end
+
+    def kind
+      case
+      when @fields && !@variants
+        :product
+      when @fields && @variants
+        :product_variant
+      when !@fields && @variants
+        :variant
+      when !@fields && !@variants
+        raise TypeError, 'fields or variants have to be set'
+      end
+    end
+
+    private
+
     def product_to_s
       fields_str = if field_names
                      field_names.zip(fields).map { |name, field| "#{name}: #{field.name}" }
@@ -418,6 +477,15 @@ module Algebrick
       "#{name}(#{fields_str.join ', '})"
     end
 
+    def set_field_names(names)
+      @field_names = names
+      names.all? { |k| is_kind_of! k, Symbol }
+      dict = @field_indexes =
+          Hash.new { |h, k| raise ArgumentError, "unknown field #{k.inspect} in #{self}" }.
+              update names.each_with_index.inject({}) { |h, (k, i)| h.update k => i }
+      define_method(:[]) { |key| @fields[dict[key]] }
+    end
+
     def product_from_hash(hash)
       (type_name = hash[TYPE_KEY] || hash[TYPE_KEY.to_s]) or
           raise ArgumentError, "hash does not have #{TYPE_KEY}"
@@ -457,122 +525,35 @@ module Algebrick
     end
   end
 
-  class Product < AbstractProductVariant
-    attr_reader :fields, :field_names, :field_indexes
-
-    def initialize(*fields, &block)
-      set_fields fields
-      super(&block)
-    end
-
-    def new(*fields)
-      construct_product(*fields)
-    end
-
-    alias_method :[], :new
-
-    def be_kind_of!(type)
-      product_be_kind_of type
-    end
-
-    def call(*field_matchers)
-      Matchers::Product.new self, *field_matchers
-    end
-
-    def to_m
-      call *::Array.new(fields.size) { Algebrick.any }
-    end
+  class TypeDefinitionScope
+    attr_reader :new_type
 
-    def ==(other)
-      other.kind_of? Product and fields == other.fields
-    end
-
-    def to_s
-      product_to_s
-    end
-
-    def from_hash(hash)
-      product_from_hash hash
-    end
-  end
-
-  class Variant < AbstractProductVariant
-    attr_reader :variants
-
-    def initialize(*variants, &block)
-      set_variants(variants)
-      super &block
-    end
-
-    def be_kind_of!(type)
-      variants.each { |v| v.be_kind_of type }
-    end
-
-    def to_m
-      Matchers::Variant.new self
+    def initialize(&block)
+      @new_type = ProductVariant.new nil
+      instance_exec @new_type, &block
+      @new_type.kind
     end
 
-    def ==(other)
-      other.kind_of? Variant and variants == other.variants
+    def fields(*fields)
+      @new_type.set_fields fields
+      self
     end
 
-    def to_s
-      "#{name}(#{variants.map(&:name).join ' | '})"
+    def variants(*variants)
+      @new_type.set_variants variants
+      self
     end
 
-    def from_hash(hash)
-      field_from_hash hash
+    def type(&block)
+      Algebrick.type &block
     end
   end
 
-  class ProductVariant < AbstractProductVariant
-    attr_reader :fields, :field_names, :field_indexes, :variants
-
-    def initialize(fields, variants, &block)
-      set_fields fields
-      raise unless variants.include? self
-      set_variants variants
-      super &block
-    end
-
-    def be_kind_of!(type)
-      variants.each { |v| v.be_kind_of type unless v == self }
-      product_be_kind_of type
-    end
-
-    def call(*field_matchers)
-      Matchers::Product.new self, *field_matchers
-    end
-
-    def to_m
-      Matchers::Variant.new self
-    end
-
-    def new(*fields)
-      construct_product(*fields)
-    end
-
-    alias_method :[], :new
-
-    def ==(other)
-      other.kind_of? ProductVariant and
-          variants == other.variants and fields == other.fields
-    end
-
-    def to_s
-      name + '(' +
-          variants.map do |variant|
-            if variant == self
-              product_to_s
-            else
-              variant.name
-            end
-          end.join(' | ') +
-          ')'
-    end
-
-    def from_hash(hash)
-      product_from_hash hash
+  def self.type(&block)
+    if block.nil?
+      Atom.new nil
+    else
+      TypeDefinitionScope.new(&block).new_type
     end
   end
 
@@ -583,26 +564,27 @@ module Algebrick
       attr_reader :value
 
       def initialize
-        @assign, @value = nil
+        @assign, @value, @matched = nil
       end
 
       def case(&block)
         return self, block
       end
 
+      raise 'remove deprecation' if Algebrick.version >= Gem::Version.new('0.3')
+
       def -(block)
-        return self, block
+        warn "a 'matcher --> {}' and 'matcher +-> {}' is deprecated, it'll be removed in 0.3\n#{caller[0]}"
+        self > block
       end
 
-      alias_method :>>, :-
-
-      raise 'remove deprecation' if Algebrick.version >= Gem::Version.new('0.2')
-
-      def +(block)
-        warn 'a_matcher +-> {} is deprecated, it\'ll be removed in 0.2'
-        self - block
+      def >(block)
+        return self, block
       end
 
+      alias_method :>>, :>
+      alias_method :+, :-
+
       def ~
         @assign = true
         self
@@ -620,16 +602,23 @@ module Algebrick
         Not.new self
       end
 
+      def ^(matcher)
+        Xor.new self, matcher
+      end
+
       def assign?
         @assign
       end
 
+      def matched?
+        @matched
+      end
+
       def children_including_self
         children.unshift self
       end
 
       def assigns
-        mine = @assign && @value ? [@value] : []
         mine = @assign ? [@value] : []
         children.inject(mine) { |assigns, child| assigns + child.assigns }.tap do
           return yield *assigns if block_given?
@@ -637,7 +626,7 @@ module Algebrick
       end
 
       def ===(other)
-        matching?(other).tap { |matched| @value = other if matched }
+        matching?(other).tap { |matched| @value = other if (@matched = matched) }
       end
 
       def assign_to_s
@@ -725,6 +714,33 @@ module Algebrick
       end
     end
 
+    class Xor < Or
+      def to_s
+        matchers.join ' ^ '
+      end
+
+      alias_method :super_children, :children
+      private :super_children
+
+      def children
+        super.select &:matched?
+      end
+
+      def assigns
+        super.tap do |assigns|
+          missing = assigns_size - assigns.size
+          assigns.push(*::Array.new(missing))
+        end
+      end
+
+      private
+
+      def assigns_size
+        # TODO is it efficient?
+        super_children.map { |ch| ch.assigns.size }.max
+      end
+    end
+
     class Not < Abstract
       attr_reader :matcher
 
@@ -854,13 +870,14 @@ module Algebrick
     # TODO Method matcher (:size, matcher)
 
     class Product < Abstract
+      # TODO allow to match by field_name e.g. Address.(:street)
       attr_reader :algebraic_type, :field_matchers
 
       def initialize(algebraic_type, *field_matchers)
         super()
-        is_kind_of! algebraic_type, Algebrick::Product, Algebrick::ProductVariant
-        @algebraic_type = algebraic_type
-        field_matchers += ::Array.new(algebraic_type.fields.size) { Algebrick.any } if field_matchers.empty?
+        @algebraic_type = is_kind_of! algebraic_type, Algebrick::ProductVariant
+        raise ArgumentError unless algebraic_type.fields
+        field_matchers  += ::Array.new(algebraic_type.fields.size) { Algebrick.any } if field_matchers.empty?
         @field_matchers = field_matchers
         raise ArgumentError unless algebraic_type.fields.size == field_matchers.size
       end
@@ -891,7 +908,8 @@ module Algebrick
 
     class Variant < Wrapper
       def initialize(something)
-        is_kind_of! something, Algebrick::Variant, Algebrick::ProductVariant
+        raise ArgumentError unless something.variants
+        is_kind_of! something, Algebrick::ProductVariant
         super something
       end
 
@@ -912,161 +930,565 @@ module Algebrick
     end
   end
 
-  module DSL
-    class PreType
-      attr_reader :environment, :name, :fields, :variants, :definition
-
-      def initialize(environment, name)
-        @environment = environment
-        @name        = name
-        @fields      = []
-        @variants    = nil
-        @definition  = nil
-      end
-
-      def |(other)
-        [self, other]
-      end
-
-      def to_ary
-        [self]
-      end
-
-      def fields=(fields)
-        raise unless @fields.empty?
-        @fields += fields
-      end
-
-      def definition=(block)
-        raise if @definition
-        @definition = block
-      end
-
-      def is(variants)
-        raise if @variants
-        @variants = variants
-        self
-      end
-
-      alias_method :===, :is
-
-      def kind
-        if @variants
-          if @fields.empty?
-            Variant
-          else
-            ProductVariant
-          end
-        else
-          if @fields.empty?
-            Atom
-          else
-            Product
-          end
-        end
-      end
-    end
-
-    class Environment
-      attr_reader :pre_types
-      def initialize(base, &definition)
-        @base      = if base.is_a?(Object) && base.to_s == 'main'
-                       Object
-                     else
-                       base
-        end
-        @pre_types = {}
-        instance_eval &definition
-      end
-
-      def method_missing(method, *fields, &definition)
-        const_name = method.to_s.split('_').map { |s| s[0] = s[0].upcase; s }.join
-
-        @pre_types[const_name] ||= PreType.new(self, const_name)
-        @pre_types[const_name].fields = fields unless fields.empty?
-        @pre_types[const_name].definition = definition if definition
-        @pre_types[const_name]
-      end
-
-      def run
-        define_constants
-        define_fields_and_variants
-        eval_definitions
-        @pre_types.map { |name, _| get_class name }
-      end
-
-      private
-
-      def define_constants
-        @pre_types.each do |name, pre_type|
-          type = pre_type.kind.allocate
-          if @base.const_defined? name
-            defined = @base.const_get(name)
-            #  #unless defined == type
-            raise "#{name} already defined as #{defined}"
-            #  #end
-          else
-            #puts "defining #{name.to_sym.inspect} in #{@base}"
-            @base.const_set name.to_sym, type
-          end
-        end
-      end
-
-      def define_fields_and_variants
-        select = ->(klass, &block) do
-          @pre_types.select { |_, pre_type| pre_type.kind == klass }.
-              map { |name, pre_type| [name, get_class(name), pre_type] }.
-              each &block
-        end
-
-        select.(Atom) do |name, type, pre_type|
-          type.send :initialize
-        end
-
-        select.(Product) do |name, type, pre_type|
-          type.send :initialize, *pre_type.fields.map { |f| get_class f }
-        end
-
-        select.(Variant) do |name, type, pre_type|
-          type.send :initialize, *pre_type.variants.map { |v| get_class v }
-        end
-
-        select.(ProductVariant) do |name, type, pre_type|
-          type.send :initialize,
-                            pre_type.fields.map { |f| get_class f },
-                            pre_type.variants.map { |v| get_class v }
-        end
-      end
-
-      def eval_definitions
-        @pre_types.each do |name, pre_type|
-          next unless pre_type.definition
-          type = get_class name
-          type.module_eval &pre_type.definition
-        end
-      end
-
-      def get_class(key)
-        if key.kind_of? String
-          @base.const_get key
-        elsif key.kind_of? PreType
-          @base.const_get key.name
-        elsif key.kind_of? Hash
-          key.each { |k, v| key[k] = get_class v }
-        else
-          key
-        end
-      end
-    end
-
-    def type_def(base = self, &definition)
-      Environment.new(base, &definition).run
-    end
-  end
-
-  extend DSL
-
-  def self.type_def(base, &definition)
-    super base, &definition
-  end
+  #class AbstractProductVariant < Type
+  #  def be_kind_of(type = nil)
+  #    if initialized?
+  #      be_kind_of! type if type
+  #      if @to_be_kind_of
+  #        while (type = @to_be_kind_of.shift)
+  #          be_kind_of! type
+  #        end
+  #      end
+  #    else
+  #      @to_be_kind_of ||= []
+  #      @to_be_kind_of << type if type
+  #    end
+  #    self
+  #  end
+  #
+  #  def add_field_method_accessor(field)
+  #    raise TypeError, 'no field names' unless @field_names
+  #    raise TypeError, "no field name #{field}" unless @field_names.include? field
+  #    define_method(field) { self[field] }
+  #    self
+  #  end
+  #
+  #  def add_field_method_accessors(*fields)
+  #    fields.each { |f| add_field_method_accessor f }
+  #    self
+  #  end
+  #
+  #  def add_all_field_method_accessors
+  #    add_field_method_accessors *@field_names
+  #  end
+  #
+  #  protected
+  #
+  #  def be_kind_of!(type)
+  #    raise NotImplementedError
+  #  end
+  #
+  #  private
+  #
+  #  def initialized?
+  #    !!@initialized
+  #  end
+  #
+  #  def initialize(name, &block)
+  #    super name, &block
+  #    @initialized = true
+  #    be_kind_of
+  #  end
+  #
+  #  def set_fields(fields_or_hash)
+  #    fields, keys = if fields_or_hash.size == 1 && fields_or_hash.first.is_a?(Hash)
+  #                     [fields_or_hash.first.values, fields_or_hash.first.keys]
+  #                   else
+  #                     [fields_or_hash, nil]
+  #                   end
+  #
+  #    set_field_names keys if keys
+  #
+  #    fields.all? { |f| is_kind_of! f, Type, Class }
+  #    raise TypeError, 'there is no product with zero fields' unless fields.size > 0
+  #    define_method(:value) { @fields.first } if fields.size == 1
+  #    @fields      = fields
+  #    @constructor = Class.new(ProductConstructor).tap { |c| c.type = self }
+  #  end
+  #
+  #  def set_field_names(names)
+  #    @field_names = names
+  #    names.all? { |k| is_kind_of! k, Symbol }
+  #    dict = @field_indexes =
+  #        Hash.new { |h, k| raise ArgumentError, "unknown field #{k.inspect} in #{self}" }.
+  #            update names.each_with_index.inject({}) { |h, (k, i)| h.update k => i }
+  #    define_method(:[]) { |key| @fields[dict[key]] }
+  #  end
+  #
+  #  def set_variants(variants)
+  #    variants.all? { |v| is_kind_of! v, Type, Class }
+  #    @variants = variants
+  #    variants.each do |v|
+  #      if v.respond_to? :be_kind_of
+  #        v.be_kind_of self
+  #      else
+  #        v.send :include, self
+  #      end
+  #    end
+  #  end
+  #
+  #  def product_be_kind_of(type)
+  #    @constructor.send :include, type
+  #  end
+  #
+  #  def construct_product(*fields)
+  #    @constructor.new *fields
+  #  end
+  #
+  #  def product_to_s
+  #    fields_str = if field_names
+  #                   field_names.zip(fields).map { |name, field| "#{name}: #{field.name}" }
+  #                 else
+  #                   fields.map(&:name)
+  #                 end
+  #    "#{name}(#{fields_str.join ', '})"
+  #  end
+  #
+  #  def product_from_hash(hash)
+  #    (type_name = hash[TYPE_KEY] || hash[TYPE_KEY.to_s]) or
+  #        raise ArgumentError, "hash does not have #{TYPE_KEY}"
+  #    raise ArgumentError, "#{type_name} is not #{name}" unless type_name == name
+  #
+  #    fields = hash[FIELDS_KEY] || hash[FIELDS_KEY.to_s] ||
+  #        hash.reject { |k, _| k.to_s == TYPE_KEY.to_s }
+  #    is_kind_of! fields, Hash, Array
+  #
+  #    case fields
+  #    when Array
+  #      self[*fields.map { |value| field_from_hash value }]
+  #    when Hash
+  #      self[fields.inject({}) do |h, (name, value)|
+  #        raise ArgumentError unless @field_names.map(&:to_s).include? name.to_s
+  #        h.update name.to_sym => field_from_hash(value)
+  #      end]
+  #    end
+  #  end
+  #
+  #  def field_from_hash(hash)
+  #    return hash unless Hash === hash
+  #    (type_name = hash[TYPE_KEY] || hash[TYPE_KEY.to_s]) or return hash
+  #    type = constantize type_name
+  #    type.from_hash hash
+  #  end
+  #
+  #  def constantize(camel_cased_word)
+  #    names = camel_cased_word.split('::')
+  #    names.shift if names.empty? || names.first.empty?
+  #
+  #    constant = Object
+  #    names.each do |name|
+  #      constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+  #    end
+  #    constant
+  #  end
+  #end
+  #
+  #class Product < AbstractProductVariant
+  #  attr_reader :fields, :field_names, :field_indexes
+  #
+  #  def initialize(name, *fields, &block)
+  #    set_fields fields
+  #    super(name, &block)
+  #  end
+  #
+  #  def new(*fields)
+  #    construct_product(*fields)
+  #  end
+  #
+  #  alias_method :[], :new
+  #
+  #  def be_kind_of!(type)
+  #    product_be_kind_of type
+  #  end
+  #
+  #  def call(*field_matchers)
+  #    Matchers::Product.new self, *field_matchers
+  #  end
+  #
+  #  def to_m
+  #    call *::Array.new(fields.size) { Algebrick.any }
+  #  end
+  #
+  #  def ==(other)
+  #    other.kind_of? Product and fields == other.fields
+  #  end
+  #
+  #  def to_s
+  #    product_to_s
+  #  end
+  #
+  #  def from_hash(hash)
+  #    product_from_hash hash
+  #  end
+  #end
+  #
+  #class Variant < AbstractProductVariant
+  #  attr_reader :variants
+  #
+  #  def initialize(name, *variants, &block)
+  #    set_variants(variants)
+  #    super name, &block
+  #  end
+  #
+  #  def be_kind_of!(type)
+  #    variants.each { |v| v.be_kind_of type }
+  #  end
+  #
+  #  def to_m
+  #    Matchers::Variant.new self
+  #  end
+  #
+  #  def ==(other)
+  #    other.kind_of? Variant and variants == other.variants
+  #  end
+  #
+  #  def to_s
+  #    "#{name}(#{variants.map(&:name).join ' | '})"
+  #  end
+  #
+  #  def from_hash(hash)
+  #    field_from_hash hash
+  #  end
+  #end
+  #
+  #class ProductVariant < AbstractProductVariant
+  #  attr_reader :fields, :field_names, :field_indexes, :variants
+  #
+  #  def initialize(name, fields, variants, &block)
+  #    set_fields fields
+  #    raise unless variants.include? self
+  #    set_variants variants
+  #    super name, &block
+  #  end
+  #
+  #  def be_kind_of!(type)
+  #    variants.each { |v| v.be_kind_of type unless v == self }
+  #    product_be_kind_of type
+  #  end
+  #
+  #  def call(*field_matchers)
+  #    Matchers::Product.new self, *field_matchers
+  #  end
+  #
+  #  def to_m
+  #    Matchers::Variant.new self
+  #  end
+  #
+  #  def new(*fields)
+  #    construct_product(*fields)
+  #  end
+  #
+  #  alias_method :[], :new
+  #
+  #  def ==(other)
+  #    other.kind_of? ProductVariant and
+  #        variants == other.variants and fields == other.fields
+  #  end
+  #
+  #  def to_s
+  #    name + '(' +
+  #        variants.map do |variant|
+  #          if variant == self
+  #            product_to_s
+  #          else
+  #            variant.name
+  #          end
+  #        end.join(' | ') +
+  #        ')'
+  #  end
+  #
+  #  def from_hash(hash)
+  #    product_from_hash hash
+  #  end
+  #end
+
+  #module DSL
+  #  -> do
+  #    maybe[:a] === none | some(:a)
+  #    tree[:a] === tip | tree(:a, tree, tree)
+  #  end
+  #
+  #  -> do
+  #    maybe[:a].can_be none,
+  #                     some.has(:a)
+  #
+  #    maybe[:a].can_be none,
+  #                     some.having(:a)
+  #
+  #    maybe[:a].can_be none,
+  #                     some.having(:a)
+  #    tree.can_be tip,
+  #                tree.having(Object, tree, tree)
+  #
+  #    tree.can_be empty,
+  #                leaf.having(Object),
+  #                node.having(left: tree, right: tree)
+  #
+  #    tree do
+  #      # def ...
+  #    end
+  #  end
+  #
+  #  class PreType
+  #    include TypeCheck
+  #
+  #    attr_reader :environment, :name, :fields, :variants, :definition, :variables
+  #
+  #    def initialize(environment, name)
+  #      @environment = is_kind_of! environment, Environment
+  #      @name        = is_kind_of! name, String
+  #      @fields      = []
+  #      @variables   = []
+  #      @variants    = []
+  #      @definition  = nil
+  #    end
+  #
+  #    def const_name
+  #      @const_name ||= name.to_s.split('_').map { |s| s.tap { s[0] = s[0].upcase } }.join
+  #    end
+  #
+  #    #def |(other)
+  #    #  [self, other]
+  #    #end
+  #    #
+  #    #def to_ary
+  #    #  [self]
+  #    #end
+  #
+  #    def [](*variables)
+  #      variables.all? { |var| is_kind_of! var, Symbol }
+  #      @variables += variables
+  #      self
+  #    end
+  #
+  #    def fields=(fields)
+  #      raise 'fields can be defined only once' unless @fields.empty?
+  #      fields.each do |field|
+  #        if Hash === field
+  #          field.each do |k, v|
+  #            is_kind_of! k, Symbol
+  #            is_kind_of! v, PreType, Type, Class, Symbol
+  #            @variables.push v if v.is_a? Symbol
+  #          end
+  #        else
+  #          is_kind_of! field, PreType, Type, Class, Symbol
+  #          @variables += fields.select { |v| v.is_a? Symbol }
+  #        end
+  #      end
+  #      @fields += fields
+  #    end
+  #
+  #    def having(fields)
+  #      self.fields = fields
+  #      self
+  #    end
+  #
+  #    alias_method :has, :having
+  #
+  #    def fields_array
+  #      if (hash = @fields.find { |f| Hash === f })
+  #        hash.values
+  #      else
+  #        @fields
+  #      end
+  #    end
+  #
+  #    #def dependent(set = Set.new)
+  #    #  children = @variants + @fields
+  #    #  children.each do |a_type|
+  #    #    next if set.include? a_type
+  #    #    next unless a_type.respond_to? :dependent
+  #    #    set.add a_type
+  #    #    a_type.dependent set
+  #    #  end
+  #    #  set.to_a
+  #    #end
+  #
+  #    def definition=(block)
+  #      raise 'definition can be defined only once' if @definition
+  #      @definition = block
+  #    end
+  #
+  #    def can_be(*variants)
+  #      raise 'variants can be defined only once' unless @variants.empty?
+  #      @variants = variants
+  #      self
+  #    end
+  #
+  #    def no_variables?
+  #      !variables? and fields_array.select { |f| Symbol === f }.empty?
+  #    end
+  #
+  #    def variables?
+  #      not @variables.empty?
+  #    end
+  #
+  #    def kind
+  #      unless @variants.empty?
+  #        if @fields.empty?
+  #          Variant
+  #        else
+  #          ProductVariant
+  #        end
+  #      else
+  #        if @fields.empty?
+  #          Atom
+  #        else
+  #          Product
+  #        end
+  #      end
+  #    end
+  #  end
+  #
+  #  class TypeConstructor
+  #    include TypeCheck
+  #    attr_reader :const_name
+  #
+  #    def initialize(pre_types, const_name, variables)
+  #      warn "types with variables are experimental\n#{caller[0]}"
+  #      @pre_types  = is_kind_of! pre_types, Hash
+  #      @const_name = is_kind_of! const_name, String
+  #      @variables  = is_kind_of! variables, Array
+  #      @cache      = {}
+  #    end
+  #
+  #    def [](*variables)
+  #      variables.size == @variables.size or
+  #          raise ArgumentError, "variables size differs from #{@variables}"
+  #      @cache[variables] ||= begin
+  #
+  #        TypeFactory.new(@pre_types, Hash[@variables.zip(variables)]).define.tap do |types|
+  #          types.each do |name, type|
+  #
+  #          end
+  #        end
+  #      end
+  #    end
+  #
+  #    def to_s
+  #      const_name + @variables.inspect
+  #    end
+  #
+  #    def inspect
+  #      to_s
+  #    end
+  #  end
+  #
+  #  class TypeFactory
+  #    include TypeCheck
+  #
+  #    def initialize(pre_types, variable_mapping)
+  #      @pre_types        = is_kind_of! pre_types, Hash
+  #      @variable_mapping = is_kind_of! variable_mapping, Hash
+  #      @types            = {}
+  #    end
+  #
+  #    def define
+  #      define_types
+  #      define_fields_and_variants
+  #      eval_definitions
+  #
+  #      @types
+  #    end
+  #
+  #    private
+  #
+  #    def define_types
+  #      @pre_types.each do |name, pre_type|
+  #        @types[name] = pre_type.kind.allocate
+  #      end
+  #    end
+  #
+  #    def define_fields_and_variants
+  #      select = ->(klass, &block) do
+  #        @pre_types.select { |_, pre_type| pre_type.kind == klass }.each &block
+  #      end
+  #
+  #      select.(Atom) do |name, pre_type|
+  #        @types[name].send :initialize, type_name(pre_type)
+  #      end
+  #
+  #      select.(Product) do |name, pre_type|
+  #        @types[name].send :initialize, type_name(pre_type), *pre_type.fields.map { |f| get_class f }
+  #      end
+  #
+  #      select.(Variant) do |name, pre_type|
+  #        @types[name].send :initialize, type_name(pre_type), *pre_type.variants.map { |v| get_class v }
+  #      end
+  #
+  #      select.(ProductVariant) do |name, pre_type|
+  #        @types[name].send :initialize, type_name(pre_type),
+  #                          pre_type.fields.map { |f| get_class f },
+  #                          pre_type.variants.map { |v| get_class v }
+  #      end
+  #    end
+  #
+  #    def eval_definitions
+  #      @pre_types.each do |name, pre_type|
+  #        next unless pre_type.definition
+  #        type = get_class name
+  #        type.module_eval &pre_type.definition
+  #      end
+  #    end
+  #
+  #    def get_class(key)
+  #      if key.kind_of? Symbol
+  #        @variable_mapping[key] or raise "missing variable mapping for #{key}"
+  #      elsif key.kind_of? String
+  #        @types[key] or raise ArgumentError
+  #      elsif key.kind_of? PreType
+  #        @types[key.name]
+  #      elsif key.kind_of? Hash
+  #        key.each { |k, v| key[k] = get_class v }
+  #      else
+  #        key
+  #      end
+  #    end
+  #
+  #    def type_name(pre_type)
+  #      pre_type.const_name + if pre_type.variables?
+  #                              '[' + pre_type.variables.map { |v| @variable_mapping[v] } * ',' + ']'
+  #                            else
+  #                              ''
+  #                            end
+  #    end
+  #  end
+  #
+  #  class Environment
+  #    attr_reader :pre_types
+  #    def initialize(&definition)
+  #      @pre_types = {}
+  #      @types     = {}
+  #      instance_eval &definition
+  #    end
+  #
+  #    def method_missing(method, *fields, &definition)
+  #      name                        = method.to_s
+  #      @pre_types[name]            ||= PreType.new(self, name)
+  #      @pre_types[name].fields     = fields unless fields.empty?
+  #      @pre_types[name].definition = definition if definition
+  #      @pre_types[name]
+  #    end
+  #
+  #    def run
+  #      pre_types = @pre_types.select { |_, pt| pt.no_variables? }
+  #      types     = TypeFactory.new(pre_types, {}).define
+  #      constants = pre_types.inject({}) do |hash, (name, pre_type)|
+  #        hash.update pre_type.const_name => types[name]
+  #      end
+  #
+  #      pre_constructors = @pre_types.select { |_, pt| pt.variables? }
+  #      constructors     = pre_constructors.inject({}) do |hash, (name, pt)|
+  #        pre_types = Hash[([pt] + pt.dependent).map { |pt| [pt.name, pt] }]
+  #        hash.update name => TypeConstructor.new(pre_types, pt.const_name, pt.variables)
+  #      end
+  #
+  #      constants.update Hash[constructors.map { |name, c| [c.const_name, c] }]
+  #
+  #      @pre_types.map { |name, pre_type| types[name] || constructors[name] || raise("missing #{name}") }
+  #    end
+  #
+  #    private
+  #
+  #    #def define_constants(map)
+  #    #  map.each { |const_name, value| @base.const_set const_name.to_sym, value } if @base
+  #    #end
+  #  end
+  #
+  #  def type_def(&definition)
+  #    Environment.new(&definition).run
+  #  end
+  #end
+
+  #extend DSL
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: algebrick
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Petr Chalupa