algebrick 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c59b78e81ddad7a8982de954309dba01ccc26db9
-  data.tar.gz: 94cbecbb1b1bd1f3ca682fa0707439b7afcba7fc
+  metadata.gz: 986e5746d10e9a2e2edf3c25da212fff33719dee
+  data.tar.gz: a711d19897aa1c4085948aa21cace8a86ede5ef6
 SHA512:
-  metadata.gz: aeff2d9b02f3f947f0019c9c915f37194a1c02bc4d20eef4f7365ad22c836c8b4158b10cfc0686f66e9a640bb0cb1dff0cc39c253328ee043926f6dfe9dc851e
-  data.tar.gz: d225e46f414574b28ff8719639d1ce193fe12e86935d27a9faef0bcaed2c3003ee2eebaf5eb336bdaf5f697d3f3ab8d24bd84df1e98c69d3f2d3161950b87453
+  metadata.gz: 5c0264da1e050dab04f2238905fab10b253762c68bcaa3c80103a6c4366efb236c003c3b8ce06cba03b0a0a7913f63662bf9246181237215881c99c77856d14a
+  data.tar.gz: 52d55de9dd00eebb7b6e38959cbf8bae0add19090ff04213a58a053f30389ef313669c41831848d5bf942f6a11274e4c1729f21dbd3b77256d1f4b2c02cac1dc

data/README.md

@@ -1,7 +1,7 @@
 ## Algebrick
 
-Algebraic types and pattern matching 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/
+-   Documentation: <http://blog.pitr.ch/algebrick>
+-   Source: <https://github.com/pitr-ch/algebrick>
+-   Blog: <http://blog.pitr.ch/blog/categories/algebrick/>

data/README_FULL.md

@@ -2,9 +2,9 @@
 
 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}
+-   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
 

data/VERSION

@@ -0,0 +1 @@
+0.1.2

data/lib/algebrick.rb

@@ -13,6 +13,10 @@ end
 
 module Algebrick
 
+  def self.version
+    @version ||= Gem::Version.new File.read(File.join(File.dirname(__FILE__), '..', 'VERSION'))
+  end
+
   module TypeCheck
     #def is_kind_of?(value, *types)
     #  a_type_check :kind_of?, false, value, *types
@@ -22,9 +26,9 @@ module Algebrick
       a_type_check :kind_of?, true, value, *types
     end
 
-    #def is_matching?(value, *types)
-    #  a_type_check :===, false, value, *types
-    #end
+    def is_matching?(value, *types)
+      a_type_check :===, false, value, *types
+    end
 
     def is_matching!(value, *types)
       a_type_check :===, true, value, *types
@@ -43,8 +47,10 @@ module Algebrick
           raise ArgumentError
         end
       end
-      raise TypeError, "value (#{value.class}) '#{value}' is not ##{which} any of #{types.join(', ')}" if bang && !ok
-      value
+      bang && !ok and
+          raise TypeError,
+                "value (#{value.class}) '#{value}' is not ##{which} any of #{types.join(', ')}"
+      bang ? value : ok
     end
   end
 
@@ -83,7 +89,7 @@ module Algebrick
       cases.each do |matcher, block|
         return match_value matcher, block if matcher === value
       end
-      raise "no match for #{value} by any of #{cases.map(&:first).join ', '}"
+      raise "no match for (#{value.class}) '#{value}' by any of #{cases.map(&:first).join ', '}"
     end
 
     private
@@ -307,6 +313,20 @@ module Algebrick
       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)
@@ -336,7 +356,9 @@ module Algebrick
       if keys
         @field_names = keys
         keys.all? { |k| is_kind_of! k, Symbol }
-        dict = @field_indexes = keys.each_with_index.inject({}) { |h, (k, i)| h.update k => i }
+        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
 
@@ -551,6 +573,8 @@ module Algebrick
 
       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
@@ -678,7 +702,7 @@ module Algebrick
       end
     end
 
-    class Not < Abstract # TODO
+    class Not < Abstract
       attr_reader :matcher
 
       def initialize(matcher)
@@ -1012,8 +1036,14 @@ module Algebrick
       end
     end
 
-    def type_def(&definition)
-      Environment.new(self, &definition).run
+    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
 end

data/spec/algebrick.rb

@@ -0,0 +1,541 @@
+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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: algebrick
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Petr Chalupa
@@ -104,9 +104,11 @@ extra_rdoc_files:
 - README_FULL.md
 files:
 - lib/algebrick.rb
+- VERSION
 - MIT-LICENSE
 - README.md
 - README_FULL.md
+- spec/algebrick.rb
 homepage: https://github.com/pitr-ch/algebrick
 licenses:
 - MIT
@@ -131,5 +133,6 @@ rubygems_version: 2.0.0
 signing_key: 
 specification_version: 4
 summary: Algebraic types and pattern matching for Ruby
-test_files: []
+test_files:
+- spec/algebrick.rb
 has_rdoc: