algebrick 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: acb97762ca9adaf44bcddd29fd57985f77c0d98c
-  data.tar.gz: 67a118f7462a29d4d29edeeff5cf1ce4c9a4b259
+  metadata.gz: 031ca75f438646afcde4c41e4ab4e3b5db005f2e
+  data.tar.gz: 877ecd44cd33213e95f0a9bff41eb13f9300b45b
 SHA512:
-  metadata.gz: 84402aff0bf09c611f7853ec255b97bdae86a7d43297a412a5d8f1d3aee8ef9c82303a233465b1e22a17f75f7fc2c693ebb3db9d4c194b54952c37941b59a1dc
-  data.tar.gz: c4250f16434da8d17ce1ca866c1e549694f3960bc9d81a102ff65d908f4f450e69dbe5379c8708028d013d9c0fc49d19981ad05346eeb1084a44a01da4b1979b
+  metadata.gz: 1401bf9922ffd3a3cf6c66b215c249e8b0adb910c7f5325debe0158aef55b4d75c1b0020b26fa563372e5e5cd96b2e97be93418b72358138014215f5643a0440
+  data.tar.gz: c034a72430b4ba328b180068c70a0fe5a661f01a80ca8cfcb09808b8df821b013847a15aadd166c3576abfe411e07b84ddbd5131863d8f274d34773a7ad7bf91

data/VERSION

@@ -1 +1 @@
-0.7.3
+0.7.4

data/lib/algebrick/matchers/abstract.rb

@@ -70,9 +70,9 @@ module Algebrick
       end
 
       def assigns
-        collect_assigns.tap do
-          return yield *assigns if block_given?
-        end
+        assigns = collect_assigns
+        return yield *assigns if block_given?
+        assigns
       end
 
       def to_a

data/lib/algebrick/product_constructors/abstract.rb

@@ -39,6 +39,12 @@ module Algebrick
         @fields == other.fields
       end
 
+      alias_method :eql?, :==
+
+      def hash
+        [self.class, @fields].hash
+      end
+
       def self.type
         @type || raise
       end

data/lib/algebrick/reclude.rb

@@ -17,14 +17,19 @@ module Algebrick
   #noinspection RubySuperCallWithoutSuperclassInspection
   module Reclude
     def included(base)
-      included_into << base
+      used_by << base
+      super(base)
+    end
+
+    def extended(base)
+      used_by << base
       super(base)
     end
 
     def include(*modules)
       super(*modules)
       modules.reverse.each do |module_being_included|
-        included_into.each do |mod|
+        used_by.each do |mod|
           mod.send :include, module_being_included
         end
       end
@@ -32,8 +37,8 @@ module Algebrick
 
     private
 
-    def included_into
-      @included_into ||= []
+    def used_by
+      @used_by ||= []
     end
   end
 end

metadata

@@ -1,43 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: algebrick
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Petr Chalupa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-02 00:00:00.000000000 Z
+date: 2017-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.10'
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
 description: Provides algebraic type definitions and pattern matching
 email: git+algebrick@pitr.ch
 executables: []
@@ -47,56 +75,30 @@ extra_rdoc_files:
 - README.md
 - README_FULL.md
 - VERSION
-- doc/actor.rb
-- doc/data.in.rb
 - doc/data.out.rb
-- doc/extending_behavior.in.rb
 - doc/extending_behavior.out.rb
-- doc/format.rb
-- doc/init.rb
-- doc/json.in.rb
 - doc/json.out.rb
-- doc/null.in.rb
 - doc/null.out.rb
-- doc/parametrized.in.rb
 - doc/parametrized.out.rb
-- doc/pattern_matching.in.rb
 - doc/pattern_matching.out.rb
-- doc/quick_example.in.rb
 - doc/quick_example.out.rb
-- doc/tree1.in.rb
 - doc/tree1.out.rb
-- doc/type_def.in.rb
 - doc/type_def.out.rb
-- doc/values.in.rb
 - doc/values.out.rb
 files:
 - LICENSE.txt
 - README.md
 - README_FULL.md
 - VERSION
-- doc/actor.rb
-- doc/data.in.rb
 - doc/data.out.rb
-- doc/extending_behavior.in.rb
 - doc/extending_behavior.out.rb
-- doc/format.rb
-- doc/init.rb
-- doc/json.in.rb
 - doc/json.out.rb
-- doc/null.in.rb
 - doc/null.out.rb
-- doc/parametrized.in.rb
 - doc/parametrized.out.rb
-- doc/pattern_matching.in.rb
 - doc/pattern_matching.out.rb
-- doc/quick_example.in.rb
 - doc/quick_example.out.rb
-- doc/tree1.in.rb
 - doc/tree1.out.rb
-- doc/type_def.in.rb
 - doc/type_def.out.rb
-- doc/values.in.rb
 - doc/values.out.rb
 - lib/algebrick.rb
 - lib/algebrick/atom.rb
@@ -132,7 +134,7 @@ files:
 - lib/algebrick/value.rb
 homepage: https://github.com/pitr-ch/algebrick
 licenses:
-- Apache License 2.0
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -150,9 +152,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Algebraic types and pattern matching for Ruby
 test_files: []
-has_rdoc: 

data/doc/actor.rb

@@ -1,21 +0,0 @@
-Work = Algebrick.type do
-  fields key: String, work: Proc
-end
-
-Finished = Algebrick.type do
-  fields key: String, result: Object, worker: Worker
-end
-
-class Worker < AbstractActor
-  def initialize(executor)
-    super()
-    @executor = executor
-  end
-
-  def on_message(message)
-    match message,
-          Work.(~any, ~any) >-> key, work do
-            @executor.tell Finished[key, work.call, self]
-          end
-  end
-end

data/doc/data.in.rb

@@ -1,99 +0,0 @@
-extend Algebrick::Matching
-
-# Simple data structures like trees
-Tree = Algebrick.type do |tree|
-  variants Tip  = type,
-           Node = type { fields value: Object, left: tree, right: tree }
-end
-
-module Tree
-  def depth
-    match self,
-          Tip.to_m >> 0,
-          Node.(any, ~any, ~any) >-> left, right do
-            1 + [left.depth, right.depth].max
-          end
-  end
-end #
-
-tree = Node[2,
-            Tip,
-            Node[5,
-                 Node[4, Tip, Tip],
-                 Node[6, Tip, Tip]]]
-tree.depth
-
-# Whenever you find yourself to pass around too many fragile Hash-Array structures
-# e.g. for menus.
-Menu = Algebrick.type do |menu|
-  Item = Algebrick.type do
-    variants Delimiter = atom,
-             Link      = type { fields! label: String, url: String },
-             Group     = type { fields! label: String, submenu: menu }
-  end
-
-  fields! item: Item, next: menu
-  variants None = atom, menu
-end
-None
-Item
-
-module Link
-  def self.new(*fields)
-    super(*fields).tap { |menu| valid! menu.url }
-  end
-
-  def self.valid!(url)
-    # stub
-  end
-end #
-
-module Item
-  def draw_menu(indent = 0)
-    match self,
-          Delimiter >-> { [' '*indent + '-'*10] },
-          Link.(label: ~any) >-> label { [' '*indent + label] },
-          (on ~Group do |(label, sub_menu)|
-            [' '*indent + label] + sub_menu.draw_menu(indent + 2)
-          end)
-  end
-end #
-
-module Menu
-  def self.build(*items)
-    items.reverse_each.reduce(None) { |menu, item| Menu[item, menu] }
-  end
-
-  include Enumerable
-
-  def each(&block)
-    it = self
-    loop do
-      break if None === it
-      block.call it.item
-      it = it.next
-    end
-  end
-
-  def draw_menu(indent = 0)
-    map { |item| item.draw_menu indent }.reduce(&:+)
-  end
-end #
-
-sub_menu = Menu.build Link['Red Hat', '#red-hat'],
-                      Delimiter,
-                      Link['Ubuntu', '#ubuntu'],
-                      Link['Mint', '#mint']
-
-menu = Menu.build Link['Home', '#home'],
-                  Delimiter,
-                  Group['Linux', sub_menu],
-                  Link['About', '#about']
-
-menu.draw_menu.join("\n")
-
-
-#     Group['Products',
-#           Menu[]],
-#     Link['About', '#about']
-#]]

data/doc/extending_behavior.in.rb

@@ -1,61 +0,0 @@
-Maybe = Algebrick.type do
-  variants None = atom,
-           Some = type { fields Object }
-end
-
-# Types can be extended with usual syntax for modules and using Ruby supports module reopening.
-module Maybe
-  def maybe(&block)
-    case self
-    when None
-    when Some
-      block.call value
-    end
-  end
-end #
-
-# #maybe method is defined on both values (None, Some) of Maybe.
-None.maybe { |_| raise 'never ever happens' }
-# Block is called with the value.
-Some[1].maybe { |v| v*2 }
-
-# It also works as expected when modules like Comparable are included.
-Season = Algebrick.type do
-  variants Spring = atom,
-           Summer = atom,
-           Autumn = atom,
-           Winter = atom
-end
-
-module Season
-  include Comparable
-  ORDER = Season.variants.each_with_index.each_with_object({}) { |(season, i), h| h[season] = i }
-
-  def <=>(other)
-    Type! other, Season
-    ORDER[self] <=> ORDER[other]
-  end
-end #
-
-Quarter = Algebrick.type do
-  fields! year: Integer, season: Season
-end
-
-module Quarter
-  include Comparable
-
-  def <=>(other)
-    Type! other, Quarter
-    [year, season] <=> [other.year, other.season]
-  end
-end #
-
-# Now Quarters and Seasons can be compared as expected.
-[Winter, Summer, Spring, Autumn].sort
-Quarter[2013, Spring] < Quarter[2013, Summer]
-Quarter[2014, Spring] > Quarter[2013, Summer]
-Quarter[2014, Spring] == Quarter[2014, Spring]
-[Quarter[2013, Spring], Quarter[2013, Summer], Quarter[2014, Spring]].sort
-
-
-

data/doc/format.rb

@@ -1,76 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'pry'
-require 'pp'
-
-root        = File.dirname(File.expand_path(Process.argv0))
-input_paths = if ARGV.empty?
-                Dir.glob("#{root}/*.in.rb")
-              else
-                ARGV
-              end.map { |p| File.expand_path p }
-
-input_paths.each_with_index do |input_path, i|
-
-  pid = fork do
-    require File.join(root, 'init.rb')
-
-    begin
-      output_path = input_path.gsub /\.in\.rb$/, '.out.rb'
-      input       = File.readlines(input_path)
-
-      chunks = []
-      line   = ''
-
-      while !input.empty?
-        line += input.shift
-        if Pry::Code.complete_expression? line
-          chunks << line
-          line = ''
-        end
-      end
-
-      raise unless line.empty?
-
-      chunks.map! { |chunk| [chunk, [chunk.split($/).size, 1].max] }
-      environment = Module.new.send :binding
-      evaluate    = ->(code, line) do
-        eval(code, environment, input_path, line)
-      end
-
-      indent = 50
-
-      line_count = 1
-      output     = ''
-      chunks.each do |chunk, lines|
-        result = evaluate.(chunk, line_count)
-        unless chunk.strip.empty? || chunk =~ /\A *#/
-          pre_lines = chunk.lines.to_a
-          last_line = pre_lines.pop
-          output << pre_lines.join
-
-          if last_line =~ /\#$/
-            output << last_line.gsub(/\#$/, '')
-          else
-            if last_line.size < indent && result.inspect.size < indent
-              output << "%-#{indent}s %s" % [last_line.chomp, "# => #{result.inspect}\n"]
-            else
-              output << last_line << "    # => #{result.inspect}\n"
-            end
-          end
-        else
-          output << chunk
-        end
-        line_count += lines
-      end
-
-      puts "#{input_path}\n -> #{output_path}"
-      #puts output
-      File.write(output_path, output)
-    rescue => ex
-      puts "#{ex} (#{ex.class})\n#{ex.backtrace * "\n"}"
-    end
-  end
-
-  Process.wait pid
-end

data/doc/init.rb

@@ -1 +0,0 @@
-require 'algebrick'

data/doc/json.in.rb

@@ -1,39 +0,0 @@
-extend Algebrick::Matching
-
-# Lets define message-protocol for a cross-process communication.
-Request = Algebrick.type do
-  User = type { fields login: String, password: String }
-
-  variants CreateUser = type { fields User },
-           GetUser    = type { fields login: String }
-end
-
-Response = Algebrick.type do
-  variants Success = type { fields Object },
-           Failure = type { fields error: String }
-end
-
-Message = Algebrick.type { variants Request, Response }
-
-require 'algebrick/serializer'
-require 'multi_json'
-
-# Prepare a message for sending.
-serializer   = Algebrick::Serializer.new
-request      = CreateUser[User['root', 'lajDh4']]
-raw_request  = MultiJson.dump serializer.dump(request)
-
-# Receive the message.
-response     = match serializer.load(MultiJson.load(raw_request)),
-                     (on CreateUser.(~any) do |user|
-                       # create the user and send success
-                       Success[user]
-                     end)
-
-# Send response.
-response_raw = MultiJson.dump serializer.dump(response)
-
-# Receive response.
-serializer.load(MultiJson.load(response_raw))
-
-

data/doc/null.in.rb

@@ -1,36 +0,0 @@
-extend Algebrick::Matching
-
-def deliver_email(email)
-  true
-end #
-
-Contact = Algebrick.type do |contact|
-  variants Null = atom,
-           contact
-  fields username: String, email: String
-end
-
-module Contact
-  def username
-    match self,
-          Null >> 'no name',
-          Contact >-> { self[:username] }
-  end
-  def email
-    match self,
-          Null >> 'no email',
-          Contact >-> { self[:email] }
-  end
-  def deliver_personalized_email
-    match self,
-          Null >> true,
-          Contact >-> { deliver_email(self.email) }
-  end
-end #
-
-peter  = Contact['peter', 'example@dot.com']
-john   = Contact[username: 'peter', email: 'example@dot.com']
-nobody = Null
-
-[peter, john, nobody].map &:email
-[peter, john, nobody].map &:deliver_personalized_email

data/doc/parametrized.in.rb

@@ -1,37 +0,0 @@
-# Let's define Tree but this time parameterized by :value_type,
-Tree = Algebrick.type(:value_type) do |tree|
-  variants Empty = atom,
-           Leaf  = type(:value_type) { fields value: :value_type },
-           Node  = type(:value_type) { fields left: tree, right: tree }
-end
-
-# with method depth defined as before.
-module Tree
-  def depth
-    match self,
-          Empty >> 0,
-          Leaf >> 1,
-          Node.(~any, ~any) >-> left, right do
-            1 + [left.depth, right.depth].max
-          end
-  end
-end #
-
-# Then Tree, Leaf, Node are
-Tree.class
-[Tree, Leaf, Node]
-# which servers as factories to actual types.
-Tree[Float]
-Tree[String]
-
-# Types cannot be mixed.
-Leaf[Integer]['1'] rescue $!
-Node[Integer][Leaf[String]['a'], Empty] rescue $!
-Leaf[String]['1']
-
-# Depth method works as before.
-integer_tree = Node[Integer][Leaf[Integer][2], Empty]
-integer_tree.depth
-string_tree = Node[String][Empty, Empty]
-string_tree.depth
-

data/doc/pattern_matching.in.rb

@@ -1,144 +0,0 @@
-# Let's define a tree and binary tree to demonstrate the pattern matching abilities.
-Tree = Algebrick.type do |tree|
-  variants Empty = type,
-           Leaf  = type { fields Integer },
-           Node  = type { fields tree, tree }
-end
-
-BinaryTree = BTree = Algebrick.type do |btree|
-  fields! value: Comparable, left: btree, right: btree
-  variants Empty, btree
-end
-
-extend Algebrick::Matching
-
-# Product matchers are constructed with #.() syntax.
-Leaf.(any) === Leaf[1]
-Leaf.(1) === Leaf[1]
-Leaf.(2) === Leaf[1]
-# There are also some shortcuts to use when product has more fields.
-BTree.()
-BTree.(value: any, left: Empty)
-BTree.(value: any, left: Empty) === BTree[1, Empty, Empty]
-
-# Any object responding to #=== can be converted to matcher.
-(1..2).to_m
-(1..2).to_m === 2
-Empty.to_m
-# As matchers are using standard #=== method it does not have to be always converted.
-Empty === Empty
-Leaf === Leaf[1]
-
-# Tree matches all its values.
-[Empty, Leaf[1], Node[Empty, Empty]].all? { |v| Tree === v }
-
-# There is also a #match method in Matching module to make pattern matching easier.
-match Leaf[1], # supply the value for matching
-      # if Leaf.(0) matches :zero is returned
-      (on Leaf.(0), :zero),
-      # when computation of the result needs to be avoided use block
-      # if Leaf.(1) matches block is called and its result is returned
-      (on Leaf.(1) do
-        (1..10000).inject(:*) # expensive computation
-        :one # which is :one in this case
-      end)
-
-# Alternatively case can be used.
-case Leaf[1]
-when Leaf.(0)
-  :zero
-when Leaf.(1)
-  (1..10000).inject(:*) # expensive computation
-  :one
-end
-
-# But that won't work nicely with value deconstruction.
-# Each matcher can be marked with #~ method to store value against which is being matched,
-# each matched value is passed to the block, ...
-match Leaf[0],
-      (on ~Leaf.(~any) do |leaf, value|
-        [leaf, value]
-      end)
-
-btree = BTree[1,
-              BTree[0, Empty, Empty],
-              Empty]
-match btree,
-      (on BTree.(any, ~any, ~any) do |left, right|
-        [left, right]
-      end)
-
-# or alternatively you can use Ruby's multi-assignment feature.
-match btree,
-      (on ~BTree do |(_, left, right)|
-        [left, right]
-      end)
-
-
-# Matchers also support logical operations #& for and, #| for or, and #! for negation.
-Color = Algebrick.type do
-  variants Black = atom,
-           White = atom,
-           Pink  = atom,
-           Grey  = type { fields scale: Float }
-end
-
-def color?(color)
-  match color,
-        on(Black | Grey.(-> v { v < 0.2 }), 'black-ish'),
-        on(White | Grey.(-> v { v > 0.8 }), 'white-ish'),
-        on(Grey.(-> v { v >= 0.2 }) & Grey.(-> v { v <= 0.8 }), 'grey-ish'),
-        on(Pink, "that's not a color ;)")
-end
-
-color? Black
-color? Grey[0.1]
-color? Grey[0.3]
-color? Grey[0.9]
-color? White
-color? Pink
-
-# A more complicated example of extracting node's value and values of its left and right side
-# using also logical operators to allow Empty sides.
-match BTree[0, Empty, BTree[1, Empty, Empty]],
-      (on BTree.({ value: ~any,
-                   left:  Empty | BTree.(value: ~any),
-                   right: Empty | BTree.(value: ~any) }) do |value, left, right|
-        { left: left, value: value, right: right }
-      end)
-
-# It also supports matching against Ruby Arrays
-Array.() === []
-Array.() === [1]
-Array.(*any) === []
-Array.(*any) === [1]
-Array.(*any) === [1, 2]
-Array.(1, *any) === []
-Array.(1, *any) === [1]
-Array.(1, *any) === [1, 2]
-
-match [],
-      on(~Array.to_m) { |v| v }
-match [],
-      on(~Array.()) { |v| v }
-match [1, 2],
-      on(~Array.(*any)) { |v| v }
-match [1, 2],
-      on(~Array.(*any)) { |(v, _)| v }
-match [1, 2, 3],
-      on(Array.(any, *~any)) { |v| v }
-match [:first, 1, 2, 3],
-      on(Array.(:first, ~any, *any)) { |v| v }
-match [:+, 1, 2, :foo, :bar],
-      (on Array.(:+, ~Integer.to_m, ~Integer.to_m, *~any) do |int1, int2, rest|
-        { sum: int1 + int2, rest: rest }
-      end)
-
-
-# There is also a more funky syntax for matching
-# using #>, #>> and Ruby 1.9 syntax for lambdas `-> {}`.
-match Leaf[1],
-      Leaf.(0) >> :zero,
-      Leaf.(~any) >-> value do
-        (1..value).inject(:*) # an expensive computation
-      end

data/doc/quick_example.in.rb

@@ -1,27 +0,0 @@
-# Let's define a Tree
-Tree = Algebrick.type do |tree|
-  variants Empty = atom,
-           Leaf  = type { fields Integer },
-           Node  = type { fields tree, tree }
-end
-
-# Now types `Tree(Empty | Leaf | Node)`, `Empty`, `Leaf(Integer)` and `Node(Tree, Tree)` are defined.
-# Let's add a method, don't miss the **pattern matching** example.
-module Tree
-  # compute depth of a tree
-  def depth
-    match self,
-          (on Empty, 0),
-          (on Leaf, 1),
-          # ~ will store and pass matched parts to variables left and right
-          (on Node.(~any, ~any) do |left, right|
-            1 + [left.depth, right.depth].max
-          end)
-  end
-end #
-
-# Method defined in module `Tree` are passed down to **all** values of type Tree.
-Empty.depth
-Leaf[10].depth
-Node[Leaf[4], Empty].depth
-Node[Empty, Node[Leaf[1], Empty]].depth

data/doc/tree1.in.rb

@@ -1,10 +0,0 @@
-Tree = Algebrick.type do |tree|
-  variants Empty = type,
-           Leaf  = type { fields Integer },
-           Node  = type { fields tree, tree }
-end
-# Which sets 4 modules representing these types in current module/class
-Tree
-Empty
-Leaf
-Node

data/doc/type_def.in.rb

@@ -1,21 +0,0 @@
-# Let's define some types
-Maybe = Algebrick.type do
-  variants None = atom,
-           Some = type { fields Numeric }
-end
-
-# where the Maybe actually is:
-Maybe.class
-Maybe.class.superclass
-Maybe.class.superclass.superclass
-Maybe.class.superclass.superclass.superclass
-
-# if there is a circular dependency you can define the dependent types inside the block like this:
-Tree = Algebrick.type do |tree|
-  variants Empty = type,
-           Leaf  = type { fields Integer },
-           Node  = type { fields tree, tree }
-end
-Empty
-Leaf
-Node

data/doc/values.in.rb

@@ -1,52 +0,0 @@
-# Let's define a Tree
-Tree = Algebrick.type do |tree|
-  variants Empty = type,
-           Leaf  = type { fields Integer },
-           Node  = type { fields tree, tree }
-end
-
-# Values of atomic types are represented by itself,
-# they are theirs own value.
-Empty.kind_of? Algebrick::Value
-Empty.kind_of? Algebrick::Type
-Empty.kind_of? Empty
-
-# Values of product types are constructed with #[] and they are immutable.
-Leaf[1].kind_of? Algebrick::Value
-Leaf[1].kind_of? Leaf
-Node[Empty, Empty].kind_of? Node
-
-# Variant does not have its own values, it uses atoms and products.
-Leaf[1].kind_of? Tree
-Empty.kind_of? Tree
-
-# Product can have its fields named.
-BinaryTree = BTree = Algebrick.type do |btree|
-  fields! value: Integer, left: btree, right: btree
-  variants Tip = atom, btree
-end
-
-# Then values can be created with names
-tree1      = BTree[value: 1, left: Tip, right: Tip]
-# or without them as before.
-BTree[0, Tip, tree1]
-
-# Fields of products can be read as follows:
-# 1. When type has only one field method #value is defined
-Leaf[1].value
-# 2. By multi-assign
-v, left, right = BTree[value: 1, left: Tip, right: Tip]
-[v, left, right]
-# 3. With #[] method when fields are named
-BTree[value: 1, left: Tip, right: Tip][:value]
-BTree[value: 1, left: Tip, right: Tip][:left]
-# 4. With methods named by fields when fields are named
-#    (it can be disabled if fields are defined with #fields instead of #fields!)
-BTree[1, Tip, Tip].value
-BTree[1, Tip, Tip].left
-
-# Product instantiation raises TypeError when being constructed with wrong type.
-Leaf['a'] rescue $!
-Node[nil, Empty] rescue $!
-
-