algebrick 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 986e5746d10e9a2e2edf3c25da212fff33719dee
-  data.tar.gz: a711d19897aa1c4085948aa21cace8a86ede5ef6
+  metadata.gz: fb30a6eeabbe7769c1f946395bef047d5acf4362
+  data.tar.gz: 5c0289625f919dffe3f57e6fa2e258ca353d4ba9
 SHA512:
-  metadata.gz: 5c0264da1e050dab04f2238905fab10b253762c68bcaa3c80103a6c4366efb236c003c3b8ce06cba03b0a0a7913f63662bf9246181237215881c99c77856d14a
-  data.tar.gz: 52d55de9dd00eebb7b6e38959cbf8bae0add19090ff04213a58a053f30389ef313669c41831848d5bf942f6a11274e4c1729f21dbd3b77256d1f4b2c02cac1dc
+  metadata.gz: 0932e96464a044f3e2a9138efcd07433bf17fb747f1718b73354599750b84543e70f7b29a97db0854343f6f25c04eda02bc6baa8498a90e5feb55f2ac57437ad
+  data.tar.gz: 7bf6898feafadd9694cf898b61c81c9879fcc0dc628044244eed4f9ec5c8d1b3d2888b826305a73d463e08621f79e6759a75b5c84283a4bb48c617d27469671f

data/LICENSE

@@ -0,0 +1,191 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+#  Copyright 2013 Petr Chalupa <git@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.

data/README.md

@@ -1,7 +1,55 @@
-## Algebrick
+# Algebrick
 
-Is a small gem providing algebraic types and pattern matching on them for Ruby.
+[![Build Status](https://travis-ci.org/pitr-ch/algebrick.png?branch=master)](https://travis-ci.org/pitr-ch/algebrick)
+
+It's a small gem providing **algebraic types** and **pattern matching** on them for Ruby.
 
 -   Documentation: <http://blog.pitr.ch/algebrick>
 -   Source: <https://github.com/pitr-ch/algebrick>
 -   Blog: <http://blog.pitr.ch/blog/categories/algebrick/>
+
+## 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.
+-   and more...
+
+## Quick example
+
+Load DSL for type definition and define some algebraic types
+
+```ruby
+extend Algebrick::DSL
+
+type_def do
+  tree === empty | leaf(Integer) | node(tree, tree)
+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.
+
+```ruby
+module Tree
+  # compute depth of a tree
+  def depth
+    match self,
+          Empty >> 0,
+          Leaf >> 1,
+          # ~ will store and pass matched parts to variables left and right
+          Node.(~any, ~any) --> left, right do
+            1 + [left.depth, right.depth].max
+          end
+  end
+end
+```
+
+Methods are defined on **all** values of type Tree
+
+```ruby
+Empty.depth                                        # => 0
+Leaf[10].depth                                     # => 1
+Node[Leaf[4], Empty].depth                         # => 2
+Node[Empty, Node[Leaf[1], Empty]].depth            # => 3
+```

data/README_FULL.md

@@ -1,14 +1,14 @@
 # Algebrick
 
-Is a small gem providing algebraic types and pattern matching on them for Ruby.
+Is a small gem providing **algebraic types** and **pattern matching** on them for Ruby.
 
 -   Documentation: <http://blog.pitr.ch/algebrick>
 -   Source: <https://github.com/pitr-ch/algebrick>
 -   Blog: <http://blog.pitr.ch/blog/categories/algebrick/>
 
-## Quick example with Maybe type
+## Quick example
 
-{include:file:doc/maybe.out.rb}
+{include:file:doc/quick_example.out.rb}
 
 ## Algebraic types: what is it?
 
@@ -62,8 +62,8 @@ Algebraic matchers are helper objects to match algebraic objects and others with
 
 ### Serialization
 
-Algebraic types also play nice with JSON serialization. So it is ideal for defining messegas
-for cross-process comunication.
+Algebraic types also play nice with JSON serialization and deserialization. It is ideal for defining
+messege-based cross-process comunication.
 
 {include:file:doc/json.out.rb}
 

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.1.3

data/lib/algebrick.rb

@@ -1,4 +1,20 @@
-# TODO method definition in variant type defines methods on variants based on match
+#  Copyright 2013 Petr Chalupa <git@pitr.ch>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+
+# TODO method definition in variant type defines methods on variants based on match, better performance?
+# TODO type variables/constructor maybe(a) === none | a
 
 require 'set'
 
@@ -18,9 +34,9 @@ module Algebrick
   end
 
   module TypeCheck
-    #def is_kind_of?(value, *types)
-    #  a_type_check :kind_of?, false, value, *types
-    #end
+    def is_kind_of?(value, *types)
+      a_type_check :kind_of?, false, value, *types
+    end
 
     def is_kind_of!(value, *types)
       a_type_check :kind_of?, true, value, *types
@@ -191,6 +207,9 @@ module Algebrick
     end
   end
 
+  TYPE_KEY   = :algebrick
+  FIELDS_KEY = :fields
+
   class Atom < Type
     include Value
 
@@ -220,7 +239,7 @@ module Algebrick
     end
 
     def to_hash
-      { name => name }
+      { TYPE_KEY => name }
     end
 
     def from_hash(hash)
@@ -263,12 +282,12 @@ module Algebrick
     end
 
     def to_hash
-      { self.class.type.name =>
-            if type.field_names
-              type.field_names.inject({}) { |h, name| h.update name => hashize(self[name]) }
-            else
-              fields.map { |v| hashize v }
-            end }
+      { TYPE_KEY => self.class.type.name }.
+          update(if type.field_names
+                   type.field_names.inject({}) { |h, name| h.update name => hashize(self[name]) }
+                 else
+                   { FIELDS_KEY => fields.map { |v| hashize v } }
+                 end)
     end
 
     def ==(other)
@@ -346,21 +365,13 @@ module Algebrick
     end
 
     def set_fields(fields_or_hash)
-      fields = if fields_or_hash.size == 1 && fields_or_hash.first.is_a?(Hash)
-                 keys = fields_or_hash.first.keys
-                 fields_or_hash.first.values
-               else
-                 fields_or_hash
-               end
-
-      if keys
-        @field_names = keys
-        keys.all? { |k| is_kind_of! k, Symbol }
-        dict = @field_indexes =
-            Hash.new { |h, k| raise ArgumentError, "uknown field #{k.inspect}" }.
-                update keys.each_with_index.inject({}) { |h, (k, i)| h.update k => i }
-        define_method(:[]) { |key| @fields[dict[key]] }
-      end
+      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
@@ -369,6 +380,15 @@ 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]] }
+    end
+
     def set_variants(variants)
       variants.all? { |v| is_kind_of! v, Type, Class }
       @variants = variants
@@ -399,10 +419,14 @@ module Algebrick
     end
 
     def product_from_hash(hash)
-      raise ArgumentError, 'hash does not have size 1' unless hash.size == 1
-      type_name, fields = hash.first
+      (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 }]
@@ -416,14 +440,9 @@ module Algebrick
 
     def field_from_hash(hash)
       return hash unless Hash === hash
-      return hash unless hash.size == 1
-      type_name, value = hash.first
-      type             = constantize type_name
-      if type.respond_to? :from_hash
-        type.from_hash hash
-      else
-        value
-      end
+      (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)
@@ -446,10 +465,12 @@ module Algebrick
       super(&block)
     end
 
-    def [](*fields)
+    def new(*fields)
       construct_product(*fields)
     end
 
+    alias_method :[], :new
+
     def be_kind_of!(type)
       product_be_kind_of type
     end
@@ -527,10 +548,12 @@ module Algebrick
       Matchers::Variant.new self
     end
 
-    def [](*fields)
+    def new(*fields)
       construct_product(*fields)
     end
 
+    alias_method :[], :new
+
     def ==(other)
       other.kind_of? ProductVariant and
           variants == other.variants and fields == other.fields
@@ -951,7 +974,7 @@ module Algebrick
                        Object
                      else
                        base
-                     end
+        end
         @pre_types = {}
         instance_eval &definition
       end
@@ -1010,8 +1033,8 @@ module Algebrick
 
         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 }
+                            pre_type.fields.map { |f| get_class f },
+                            pre_type.variants.map { |v| get_class v }
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: algebrick
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Petr Chalupa
@@ -24,6 +24,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: turn
   requirement: !ruby/object:Gem::Requirement
@@ -67,7 +81,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: kramdown
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: github-markup
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -99,16 +127,16 @@ email: git@pitr.ch
 executables: []
 extensions: []
 extra_rdoc_files:
-- MIT-LICENSE
+- LICENSE
 - README.md
 - README_FULL.md
+- VERSION
 files:
 - lib/algebrick.rb
 - VERSION
-- MIT-LICENSE
+- LICENSE
 - README.md
 - README_FULL.md
-- spec/algebrick.rb
 homepage: https://github.com/pitr-ch/algebrick
 licenses:
 - MIT
@@ -133,6 +161,5 @@ rubygems_version: 2.0.0
 signing_key: 
 specification_version: 4
 summary: Algebraic types and pattern matching for Ruby
-test_files:
-- spec/algebrick.rb
+test_files: []
 has_rdoc: 

data/MIT-LICENSE

@@ -1,19 +0,0 @@
-Copyright (c) 2013 Petr Chalupa <git@pitr.ch>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/spec/algebrick.rb

@@ -1,541 +0,0 @@
-require 'bundler/setup'
-
-require 'minitest/spec'
-#require 'minitest/autorun'
-require 'turn/autorun'
-
-require 'pp'
-require_relative '../lib/algebrick'
-require 'pry'
-
-class Module
-  def const_missing const
-    raise "no constant #{const.inspect} in #{self}"
-  end
-end
-
-Turn.config do |c|
-  # use one of output formats:
-  # :outline  - turn's original case/test outline mode [default]
-  # :progress - indicates progress with progress bar
-  # :dotted   - test/unit's traditional dot-progress mode
-  # :pretty   - new pretty reporter
-  # :marshal  - dump output as YAML (normal run mode only)
-  # :cue      - interactive testing
-  c.format  = :outline
-  # turn on invoke/execute tracing, enable full backtrace
-  #c.trace   = true
-  # use humanized test names (works only with :outline format)
-  c.natural = true
-end
-
-
-describe 'AlgebrickTest' do
-  i_suck_and_my_tests_are_order_dependent!
-
-  #type_def do
-  #  maybe === none | some(Object)
-
-  #  message === success | failure
-  #  sucess === int(Integer) | str(String)
-  #  failure === error | str_error(String)
-
-  #user = user(String, address) do
-  #  def name
-  #    fields[0]
-  #  end
-  #
-  #  def address
-  #    fields[1]
-  #  end
-  #end
-  #
-  #psc     = psc(String) do
-  #  REG = /\d{5}/
-  #
-  #  def initialize(*fields)
-  #    raise TypeError unless fields[0] =~ REG
-  #  end
-  #
-  #  def schema
-  #    super << { pattern: REG.to_s }
-  #  end
-  #end
-  #
-  ##                 street, num,      city
-  #address = address(street(String), street_number(Integer), city(String), psc)
-  #
-  #message1 === user
-  #
-  #User['pepa',
-  #     Adress[
-  #         Street['Stavebni'],
-  #         StreetNumber[5],
-  #         City['Brno']]]
-  #
-  #{ user: ['pepa',
-  #         { address: [{ street: 'Stavebni' },
-  #                     { street_number: 5 }] }] }
-
-  #sucess === int(Integer) | str(String)
-  #failure === error | str_error(String)
-  #message === success | failure
-
-
-  #list === empty | list_item(Integer, list)
-  #end
-
-  #Empty = Algebrick::Atom.new
-  #Leaf  = Algebrick::Product.new(Integer)
-  #Tree  = Algebrick::Variant.allocate
-  #Node  = Algebrick::Product.new(Tree, Tree)
-  #Tree.send :initialize, Empty, Leaf, Node do
-  #  def a
-  #    :a
-  #  end
-  #end
-  #List = Algebrick::ProductVariant.allocate
-  #List.send :initialize, [Integer, List], [Empty, List]
-
-  extend Algebrick::DSL
-
-  type_def do
-    tree === empty | leaf(Integer) | node(tree, tree)
-    tree do
-      def a
-        :a
-      end
-
-      def depth
-        case self
-        when Empty
-          0
-        when Leaf
-          1
-        when Node
-          left, right = *self
-          1 + [left.depth, right.depth].max
-        end
-      end
-
-      def each(&block)
-        return to_enum :each unless block
-        case self
-        when Empty
-        when Leaf
-          block.call self.value
-        when Node
-          left, right = *self
-          left.each &block
-          right.each &block
-        end
-      end
-
-      def sum
-        each.inject(0) { |sum, v| sum + v }
-      end
-    end
-
-    list === empty | list(Integer, list)
-  end
-
-  Empty = self::Empty
-  Node  = self::Node
-  Leaf  = self::Leaf
-  Tree  = self::Tree
-  List  = self::List
-
-  describe 'type definition' do
-    module Asd
-      Algebrick.type_def self do
-        b === c | d
-      end
-    end
-
-    it 'asd' do
-      assert Asd::B
-    end
-  end
-
-  describe 'type.to_s' do
-    it { Empty.to_s.must_equal 'Empty' }
-    it { Node.to_s.must_equal 'Node(Tree, Tree)' }
-    it { Leaf.to_s.must_equal 'Leaf(Integer)' }
-    it { Tree.to_s.must_equal 'Tree(Empty | Leaf | Node)' }
-    it { List.to_s.must_equal 'List(Empty | List(Integer, List))' }
-  end
-
-  describe 'atom' do
-    it { Empty.must_be_kind_of Algebrick::Type }
-    it { Empty.must_be_kind_of Algebrick::Value }
-    it { assert Empty.kind_of? Empty }
-
-    it { assert Empty == Empty }
-    it { assert Empty === Empty }
-    it { eval(Empty.to_s).must_equal Empty }
-    it { eval(Empty.inspect).must_equal Empty }
-
-    it { Empty.from_hash(Empty.to_hash).must_equal Empty }
-  end
-
-  describe 'product' do
-    it { Leaf[1].must_be_kind_of Algebrick::Value }
-    it { Leaf.must_be_kind_of Algebrick::Type }
-    it { Leaf[1].wont_be_kind_of Algebrick::Type }
-    it { Leaf.wont_be_kind_of Algebrick::Value }
-
-    it { assert Leaf[1] == Leaf[1] }
-    it { assert Leaf[1] != Leaf[0] }
-    it { assert Leaf === Leaf[1] }
-    it { assert Leaf[1].kind_of? Leaf }
-    it { eval(Leaf[1].to_s).must_equal Leaf[1] }
-    it { eval(Leaf[1].inspect).must_equal Leaf[1] }
-    it { eval(Node[Leaf[1], Empty].to_s).must_equal Node[Leaf[1], Empty] }
-    it { eval(Node[Leaf[1], Empty].inspect).must_equal Node[Leaf[1], Empty] }
-
-    it 'field assign' do
-      value = Leaf[1].value
-      value.must_equal 1
-
-      left, right = *Node[Empty, Leaf[1]]
-      left.must_equal Empty
-      right.must_equal Leaf[1]
-
-      lambda { Node[Empty, Empty].value }.must_raise NoMethodError
-    end
-
-    it { lambda { Leaf['a'] }.must_raise TypeError }
-    it { lambda { Leaf[nil] }.must_raise TypeError }
-    it { lambda { Node['a'] }.must_raise TypeError }
-    it { lambda { Node[Empty, nil] }.must_raise TypeError }
-
-    describe 'named field' do
-      type_def { named(a: Integer, b: Object) }
-      Named = self::Named
-      Named.add_all_field_method_accessors
-      it { -> { Named[:a, 1] }.must_raise TypeError }
-      it { Named[1, :a][:a].must_equal 1 }
-      it { Named[1, :a][:b].must_equal :a }
-      it { Named[a: 1, b: :a][:a].must_equal 1 }
-      it { Named[b: :a, a: 1][:a].must_equal 1 }
-      it { Named[a: 1, b: :a][:b].must_equal :a }
-      it { Named[a: 1, b: 2].to_s.must_equal 'Named[a: 1, b: 2]' }
-      it { Named[a: 1, b: 2].a.must_equal 1 }
-      it { Named[a: 1, b: 2].b.must_equal 2 }
-    end
-
-    it { Leaf.from_hash(Leaf[1].to_hash).must_equal Leaf[1] }
-    it { Named.from_hash(Named[1, :a].to_hash).must_equal Named[1, :a] }
-    it { Named[1, Leaf[1]].to_hash.must_equal 'Named' => { a: 1, b: { 'Leaf' => [1] } } }
-    it { Named.from_hash(Named[1, Leaf[1]].to_hash).must_equal Named[1, Leaf[1]] }
-
-  end
-
-  describe 'variant' do
-    it { Tree.must_be_kind_of Algebrick::Type }
-    it { Empty.must_be_kind_of Tree }
-    it { Empty.a.must_equal :a }
-    it { Leaf[1].must_be_kind_of Tree }
-    it { Leaf[1].a.must_equal :a }
-    it { Node[Empty, Empty].must_be_kind_of Tree }
-    #it { assert Empty.kind_of? List }
-
-    it { assert Tree === Empty }
-    it { assert Tree === Leaf[1] }
-
-    describe 'inherit behavior deep' do
-      type_def do
-        a === a1 | a2
-        a1 === b1 | b2
-        a do
-          def a
-            :a
-          end
-        end
-      end
-
-      it { self.class::B1.a.must_equal :a }
-    end
-
-    describe 'a klass as a variant' do
-      MaybeString = Algebrick::Variant.new Empty, String
-      it { 'a'.must_be_kind_of MaybeString }
-    end
-  end
-
-  describe 'product_variant' do
-    it { List[1, Empty].must_be_kind_of Algebrick::Value }
-    it { List.must_be_kind_of Algebrick::Type }
-
-    it { List[1, Empty].must_be_kind_of List }
-    it { List[1, List[1, Empty]].must_be_kind_of List }
-    it { Empty.must_be_kind_of List }
-
-    it { assert List[1, Empty] == List[1, Empty] }
-    it { assert List[1, Empty] != List[2, Empty] }
-    it { assert List === List[1, Empty] }
-    it { assert List === Empty }
-    it { assert List[1, Empty].kind_of? List }
-  end
-
-  describe '#depth' do
-    it do
-      tree = Node[Node[Empty, Leaf[1]], Leaf[1]]
-      tree.depth.must_equal 3
-    end
-    it do
-      tree = Node[Empty, Leaf[1]]
-      tree.depth.must_equal 2
-    end
-    it do
-      tree = Empty
-      tree.depth.must_equal 0
-    end
-  end
-
-  describe '#sum' do
-    it do
-      tree = Node[Node[Empty, Leaf[1]], Leaf[1]]
-      tree.sum.must_equal 2
-    end
-  end
-
-  describe 'maybe' do
-    type_def do
-      maybe === none | some(Object)
-      maybe do
-        def maybe(&block)
-          case self
-          when None
-          when Some
-            block.call self.value
-          end
-        end
-      end
-    end
-
-    None = self::None
-    Some = self::Some
-
-    it { refute None.maybe { true } }
-    it { assert Some[nil].maybe { true } }
-  end
-
-  extend Algebrick::Matching
-  include Algebrick::Matching
-
-  describe 'matchers' do
-    it 'assigns' do
-      m = ~Empty
-      m === 2
-      m.assigns.must_equal [nil]
-      m === Empty
-      m.assigns.must_equal [Empty]
-
-      m = ~String.to_m
-      m === 2
-      m.assigns.must_equal [nil]
-      m === 'a'
-      m.assigns.must_equal %w(a)
-
-      m = ~Leaf.(~any)
-      m === Leaf[5]
-      m.assigns.must_equal [Leaf[5], 5]
-      m === Leaf[3]
-      m.assigns.must_equal [Leaf[3], 3]
-    end
-
-    it 'assigns in case' do
-      case Leaf[5]
-      when m = ~Leaf.(~any)
-        m.assigns.must_equal [Leaf[5], 5]
-        m.assigns do |leaf, value|
-          leaf.must_equal Leaf[5]
-          value.must_equal 5
-        end
-      else
-        raise
-      end
-    end
-
-    describe 'match' do
-      it 'returns value from executed block' do
-        Algebrick.match(Empty, Empty.to_m.case { 1 }).must_equal 1
-      end
-
-      it 'passes assigned values' do
-        v = Algebrick.match Leaf[5],
-                            Leaf.(~any).case { |value| value }
-        v.must_equal 5
-
-        v = Algebrick.match Leaf[5],
-                            Leaf.(~any) => -> value { value }
-        v.must_equal 5
-      end
-
-      it 'raises when no match' do
-        -> { Algebrick.match Empty,
-                             Leaf.(any).case {} }.must_raise RuntimeError
-      end
-
-      it 'does not pass any values when no matcher' do
-        Algebrick.match(Empty, Empty => -> *a { a }).must_equal []
-      end
-    end
-
-    describe '#to_s' do
-      [Empty.to_m,
-       # leaf(Object)
-       ~Leaf.(Integer),
-       ~Empty.to_m,
-       any,
-       ~any,
-       Leaf.(any),
-       ~Leaf.(any),
-       Node.(Leaf.(any), any),
-       ~Node.(Leaf.(any), any),
-       ~Leaf.(1) | Leaf.(~any),
-       ~Leaf.(1) & Leaf.(~any)
-      ].each do |matcher|
-        it matcher.to_s do
-          eval(matcher.to_s).must_equal matcher
-        end
-      end
-    end
-
-    { Empty.to_m                           => Empty,
-      any                                  => Empty,
-      any                                  => Leaf[1],
-
-      Empty                                => Empty,
-      Empty.to_m                           => Empty,
-
-      Leaf                                 => Leaf[1],
-      Leaf.(any)                           => Leaf[5],
-      Leaf.(~any)                          => Leaf[5],
-
-      Node                                 => Node[Empty, Empty],
-      Node.(any, any)                      => Node[Leaf[1], Empty],
-      Node.(Empty, any)                    => Node[Empty, Leaf[1]],
-      Node.(Leaf.(any), any)               => Node[Leaf[1], Empty],
-      Node.(Leaf.(any), any)               => Node[Leaf[1], Empty],
-
-      Tree.to_m                            => Node[Leaf[1], Empty],
-      Tree.to_m                            => Node[Leaf[1], Empty],
-      Node                                 => Node[Leaf[1], Empty],
-
-      Tree & Leaf.(_)                      => Leaf[1],
-      Empty | Leaf.(_)                     => Leaf[1],
-      Empty | Leaf.(_)                     => Empty,
-      !Empty & Leaf.(_)                    => Leaf[1],
-      Empty & !Leaf.(_)                    => Empty,
-
-      Array.()                             => [],
-      Array.(1)                            => [1],
-      Array.(Empty, Leaf.(-> v { v > 0 })) => [Empty, Leaf[1]],
-      Array.(TrueClass)                    => [true],
-
-    }.each do |matcher, value|
-      it "#{matcher} === #{value}" do
-        assert matcher === value
-      end
-    end
-  end
-
-  it {
-    assert List.to_m === Empty
-    assert List === Empty
-    assert List.to_m === List[1, Empty]
-    assert List === List[1, Empty]
-    assert List.(1, _) === List[1, Empty]
-    refute List.(_, _) === Empty
-  }
-
-  describe 'and-or matching' do
-    it do
-      m = ~Leaf.(1) | ~Leaf.(~any)
-      assert m === Leaf[1]
-      m.assigns.must_equal [Leaf[1], nil, nil]
-    end
-    it do
-      m = ~Leaf.(1) | ~Leaf.(~any)
-      assert m === Leaf[2]
-      m.assigns.must_equal [nil, Leaf[2], 2]
-    end
-    it do
-      m = ~Leaf.(->(v) { v > 1 }) & Leaf.(~any)
-      assert m === Leaf[2]
-      m.assigns.must_equal [Leaf[2], 2]
-    end
-
-  end
-
-  describe 'equality' do
-    data = (0..1).map do
-      [Empty,
-       Leaf[1],
-       Node[Empty, Leaf[1]],
-       Node[Node[Empty, Leaf[1]], Leaf[1]]]
-    end
-    data[0].zip(data[1]).each do |tree1, tree2|
-      it "equals #{tree1}" do
-        refute tree1.object_id == tree2.object_id, [tree1.object_id, tree2.object_id] unless tree1 == Empty
-        assert tree1 == tree2
-      end
-    end
-  end
-
-  describe 'list' do
-    it { List.(any, any) === List[1, Empty] }
-    it { List.(any, List) === List[1, Empty] }
-  end
-
-  describe 'binary tree' do
-    type_def { b_tree === tip | b_node(Object, b_tree, b_tree) }
-  end
-
-end
-
-
-#require 'benchmark'
-#
-#include Algebrick
-#
-#class None < Atom
-#end
-#
-#class Some < Product
-#  fields Object
-#end
-#
-#Maybe = Variant.new do
-#  variants None, Some
-#end
-#count = 1000_000
-#
-#Benchmark.bmbm(10) do |b|
-#  b.report('nil') do
-#    count.times do
-#      v = [Object.new, nil].sample
-#      case v
-#      when Object
-#        true
-#      when nil
-#        false
-#      end
-#    end
-#  end
-#  b.report('Maybe') do
-#    count.times do
-#      v = [Some[Object.new], None].sample
-#      case v
-#      when Some
-#        true
-#      when Maybe
-#        false
-#      end
-#    end
-#  end
-#
-#
-#end