algebrick 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf3eb8ddaa209e039ffb7f1c70a6e72f5598b1c9
-  data.tar.gz: ebbd5d21d561f26c066b8a11da24620d24ec1b04
+  metadata.gz: d3e1690d46e7e9d3c9332eed298a46d35ec628ce
+  data.tar.gz: 7cf4ccef5ae69a055e9ac7806b84e0a6724d7c1b
 SHA512:
-  metadata.gz: 1aadc9051adf421099ef8e17878ae4d03fc9eb8dd91ecb430ac65fecaa999d54b26ea64844a012da0f8a43aa13bf6a2e0eabb5620ed84aef2dc6e88c82f9691e
-  data.tar.gz: 6aee2bb9d8ae13b4f71e61bfa40baa51696d4be1f45ce8a9f0f0898b628aee2f3234c9b92a86c700098ee9d86d8d9512f0d4e68c24f582398506392a6deddddf
+  metadata.gz: ae2f4b9cd4bebbb889b8d91383cbe9380d8b2c440104c0302b4b128b589fbdb6d1bdae886a49cf790022a76f1fe304180bc8b6ed77da6ce60d6aba038fac67fd
+  data.tar.gz: becadc540cc08d5002060e0fc1e64eac87d1848ff11bc44b6e628a45b61bc705fcce870741e568b2e6803e39b08b7f789d42e2926d176f8c40c8083bea3db21c

data/README.md

@@ -2,7 +2,7 @@
 
 [![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.
+It's a gem providing **algebraic types** and **pattern matching** seamlessly integrates with standard features Ruby.
 
 -   Documentation: <http://blog.pitr.ch/algebrick>
 -   Source: <https://github.com/pitr-ch/algebrick>
@@ -27,24 +27,24 @@ end
 ```
 
 Now types `Tree(Empty | Leaf | Node)`, `Empty`, `Leaf(Integer)` and `Node(Tree, Tree)` are defined.
-Add some methods, don't miss the **pattern matching** example.
+Let's add a method, don't miss the **pattern matching** example.
 
 ```ruby
 module Tree
   # compute depth of a tree
   def depth
     match self,
-          Empty >> 0,
-          Leaf >> 1,
+          (on Empty, 0),
+          (on Leaf, 1),
           # ~ will store and pass matched parts to variables left and right
-          Node.(~any, ~any) >-> left, right do
+          (on Node.(~any, ~any) do |left, right|
             1 + [left.depth, right.depth].max
-          end
+          end)
   end
 end
 ```
 
-Methods are defined on **all** values of type Tree
+Method defined in module `Tree` are passed down to **all** values of type Tree
 
 ```ruby
 Empty.depth                                        # => 0

data/README_FULL.md

@@ -1,6 +1,6 @@
 # Algebrick
 
-Is a small gem providing **algebraic types** and **pattern matching** on them for Ruby.
+It's a gem providing **algebraic types** and **pattern matching** and seamlessly integrating with standard features of Ruby.
 
 -   Documentation: <http://blog.pitr.ch/algebrick>
 -   Source: <https://github.com/pitr-ch/algebrick>
@@ -10,30 +10,46 @@ Is a small gem providing **algebraic types** and **pattern matching** on them fo
 
 {include:file:doc/quick_example.out.rb}
 
-## Algebraic types: what is it?
+## Algebraic types
 
-If you ever read something about Haskell that you probably know:
+Algebraic type is a kind of composite type, i.e. a type formed by combining other types.
+In Haskell algebraic type looks like this:
 
     data Tree = Empty
               | Leaf Int
               | Node Tree Tree
+			  
+	depth :: Tree -> Int
+	      depth Empty = 0
+	      depth (Leaf n) = 1
+	      depth (Node l r) = 1 + max (depth l) (depth r)
+    
+	depth (Node Empty (Leaf 5)) -- => 2
 
-which is an algebraic type. This snippet defines type `Tree` which has 3 possible values:
-`Empty`, `Leaf` with and extra value of type `Int`, `Node` with two values of type `Tree`. 
-See {https://en.wikipedia.org/wiki/Algebraic_data_type}.
+This snippet defines type `Tree` which has 3 possible values:
 
-Same thing can be defined with this gem:
+-  `Empty`
+-  `Leaf` with and extra value of type `Int`
+-  `Node` with two values of type `Tree` 
 
-{include:file:doc/tree1.out.rb}
+and function `depth` to calculate depth of a tree which is called on the last line and evaluates to `2`.
 
-There are 4 kinds of algebraic types:
+Same `Tree` type and `depth` method can be also defined with this gem as it was shown in {file:README_FULL.md#quick-example Quick Example}.
 
-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.
+### Algebrick implementation
 
-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.
+Algebrick distinguishes 4 kinds of algebraic types:
+
+1.  **Atom** - type that has only one value, e.g. `Empty`.
+2.  **Product** - type that has a set number of fields with given type, e.g. `Leaf(Integer)`
+3.  **Variant** - type that is one of the set variants, e.g. `Tree(Empty | Leaf(Integer) | Node(Tree, Tree)`, meaning that values `Empty`, `Leaf[1]`, `Node[Empty, Empry]` have all 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. Simultaneously it has fields as a 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.
+
+More information can be found at <https://en.wikipedia.org/wiki/Algebraic_data_type>.
+
+## Documentation
 
 ### Type definition
 
@@ -43,14 +59,14 @@ Atom type is implemented with {Algebrick::Atom} and the rest is implemented with
 
 {include:file:doc/values.out.rb}
 
-### Extending behavior
+### Behaviour extending
 
 {include:file:doc/extending_behavior.out.rb}
 
 ### Pattern matching
 
-Algebraic matchers are helper objects to match algebraic values and others with
-`#===` method based on theirs initialization values.
+Pattern matching is implemented with helper objects defined in `ALgebrick::Matchers`.
+They use standard `#===` method to match against values.
 
 {include:file:doc/pattern_matching.out.rb}
 
@@ -60,29 +76,24 @@ Algebraic matchers are helper objects to match algebraic values and others with
 
 ## What is it good for?
 
-### Defining data with a given structure
-
-{include:file:doc/data.out.rb}
-
-### Serialization
+### Defining data structures
 
-Algebraic types also play nice with JSON serialization and deserialization. It is ideal for defining
-messege-based cross-process comunication.
+<!-- {include:file:doc/data.out.rb} -->
 
-{include:file:doc/json.out.rb}
+- Simple data structures like trees
+- Whenever you find yourself to pass around too many fragile Hash-Array structures
 
-### Null Object Pattern
+_Examples are coming shortly._
 
-see {http://en.wikipedia.org/wiki/Null_Object_pattern#Ruby}.
+### Serialization
 
-{include:file:doc/null.out.rb}
+Algebraic types also play nice with JSON serialization and de-serialization making it ideal for defining message-based cross-process communication.
 
-This has advantage over a classical approach that the methods are defined
-on one place, no need to track methods in two separate classes `User` and `NullUser`.
+{include:file:doc/json.out.rb}
 
 ### Message matching in Actor pattern
 
-Just small snippet from a gem I am still working on.
+Just a small snippet how it can be used in Actor model world.
 
     class Worker < AbstractActor
       def initialize(executor)
@@ -97,3 +108,14 @@ Just small snippet from a gem I am still working on.
               end
       end
     end
+
+<!--
+### Null Object Pattern
+
+see {http://en.wikipedia.org/wiki/Null_Object_pattern#Ruby}.
+
+{include:file:doc/null.out.rb}
+
+This has advantage over a classical approach that the methods are defined
+on one place, no need to track methods in two separate classes `User` and `NullUser`.
+-->

data/VERSION

@@ -1 +1 @@
-0.3.3
+0.4.0

data/lib/algebrick.rb

@@ -1,4 +1,4 @@
-#  Copyright 2013 Petr Chalupa <git@pitr.ch>
+#  Copyright 2013 Petr Chalupa <git+algebrick@pitr.ch>
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -59,6 +59,7 @@ module Algebrick
 
   module TypeCheck
     # FIND: type checking of collections?
+
     def Type?(value, *types)
       types.any? { |t| value.is_a? t }
     end
@@ -94,31 +95,7 @@ module Algebrick
 
     def self.error(value, message, types)
       raise TypeError,
-            "value (#{value.class}) '#{value}' #{message} any of #{types.join(', ')}"
-    end
-
-    public
-
-    raise 'remove deprecations' if Algebrick.version >= Gem::Version.new('0.4')
-
-    def is_kind_of?(value, *types)
-      warn "is_kind_of? is deprecated use Type?\n#{caller[0]}"
-      Type? value, *types
-    end
-
-    def is_kind_of!(value, *types)
-      warn "Type! is deprecated use Type!\n#{caller[0]}"
-      Type! value, *types
-    end
-
-    def is_matching?(value, *types)
-      warn "is_matching? is deprecated use Match?\n#{caller[0]}"
-      Match? value, *types
-    end
-
-    def is_matching!(value, *types)
-      warn "is_matching! is deprecated use Match!\n#{caller[0]}"
-      Match! value, *types
+            "Value (#{value.class}) '#{value}' #{message} any of: #{types.join('; ')}."
     end
   end
 
@@ -128,8 +105,6 @@ module Algebrick
       Matchers::Any.new
     end
 
-    alias_method :_, :any
-
     def match(value, *cases)
       cases = if cases.size == 1 && cases.first.is_a?(Hash)
                 cases.first
@@ -153,7 +128,7 @@ module Algebrick
       [matcher, value || block]
     end
 
-    # TODO #match! raise when match is not complete on a given type
+    # FIND: #match! raise when match is not complete on a given type
 
     private
 
@@ -186,10 +161,6 @@ module Algebrick
       to_m | other
     end
 
-    def ^(other)
-      to_m ^ other
-    end
-
     def !
       !to_m
     end
@@ -397,6 +368,14 @@ module Algebrick
       self.class.type
     end
 
+    def self.name
+      @type.to_s
+    end
+
+    def self.to_s
+      name
+    end
+
     def self.type=(type)
       raise if @type
       @type = type
@@ -511,7 +490,7 @@ module Algebrick
     end
 
     def call(*field_matchers)
-      raise TypeError unless @fields
+      raise TypeError, "#{self} does not have any fields" unless @fields
       Matchers::Product.new self, *field_matchers
     end
 
@@ -863,10 +842,6 @@ module Algebrick
         Not.new self
       end
 
-      def ^(matcher)
-        Xor.new self, matcher
-      end
-
       def assign?
         @assign
       end
@@ -981,12 +956,6 @@ module Algebrick
       def matching?(other)
         matchers.any? { |m| m === other }
       end
-    end
-
-    class Xor < Or
-      def to_s
-        matchers.join ' ^ '
-      end
 
       alias_method :super_children, :children
       private :super_children
@@ -1158,15 +1127,6 @@ module Algebrick
                               field_matchers.key?(field) ? field_matchers[field] : Algebrick.any
                             end
 
-                            # AProduct.(:field_name)
-                          when field_matchers.all? { |v| v.is_a? Symbol }
-                            unless (dif = field_matchers - algebraic_type.field_names).empty?
-                              raise ArgumentError, "no #{dif} fields in #{algebraic_type}"
-                            end
-                            algebraic_type.field_names.map do |field|
-                              field_matchers.include?(field) ? ~Algebrick.any : Algebrick.any
-                            end
-
                             # normal
                           else
                             field_matchers
@@ -1181,9 +1141,11 @@ module Algebrick
       end
 
       def to_s
-        assign_to_s + "#{@algebraic_type.name}.(#{@field_matchers.join(',')})"
+        assign_to_s + "#{@algebraic_type.name}.(#{@field_matchers.join(', ')})"
       end
 
+      # TODO prety_print for all matchers
+
       def ==(other)
         other.kind_of? self.class and
             self.algebraic_type == other.algebraic_type and
@@ -1224,4 +1186,21 @@ module Algebrick
     end
   end
 
+  module Types
+    Maybe = Algebrick.type(:v) do
+      variants None = atom,
+               Some = type(:v) { fields :v }
+    end
+
+    module Maybe
+      def maybe
+        match self,
+              None >> nil,
+              Some >-> { yield value }
+      end
+    end
+  end
+
+  include Types
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algebrick
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Petr Chalupa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-11 00:00:00.000000000 Z
+date: 2014-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest