composite_type 0.1.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79b73ddf6ca69a94ade50421d460271d88bfa71c
-  data.tar.gz: eff100ef24de4b9136566c47bd123eafe63491d0
+  metadata.gz: ae4bbf53d86ecc2c5e9ff994ccb7d5314fa163bd
+  data.tar.gz: 8866e977bf37b1bb094b30bc9dfb101d7dd126f0
 SHA512:
-  metadata.gz: 0be9100aa76f309188b51710feb30837f760c03556fa7a76f92541227811bb3499e62cbc8de7b395a045b47f17c98349968758c6800813773d4527263f805fe3
-  data.tar.gz: d05c6b593fee921e608bcb581c3478fb1b2b1d85ba3f2dd5c7582dac0ff3d12d5ad976be1afd3f27657aee22e3054590725b73f6de2422a7bfc5da570fbb7d8e
+  metadata.gz: '06584bde3409c9835559d40125b4c3d63ebc53e40adcddf0aacf2db473ae524d87fc04e2617054991a06863cdaab5ffc86e86c6933b9eca6f049984fe5b6af73'
+  data.tar.gz: 92314b05a2ee942bd02781f30524f4d57bc5eed7d10b8f4d1cfec45dd6b7bce9a7b740ce01871b5ae1874b5a800a86561e34ad339768f2be20215e1cab34955d

data/README.md

@@ -13,7 +13,7 @@ Defining types through Modules:
 
     module Even
       def self.=== x
-         Integer === x and x.even?
+        Integer === x and x.even?
       end
     end
     Array.of(Even) === [ 2, 4, 10 ]
@@ -29,14 +29,17 @@ Thus composite types can be used in "case when" clauses:
 Logical operators: #|, #&, #~ are supported:
 
     a = [ 1, 2, 3 ]
-    Array.of(Positive & Numeric) === a   # => true
-    Array.of(~ NilClass) === a           # => false
+    Array.of(Positive & Integer) === a   # => true
+    Array.of(~ NilClass) === a           # => true
     
     b = [ 1, -2, 3 ]
-    Array.of(Positive & Numeric) === b   # => false
-    
-    c = [ 1, nil, 3 ]
-    Array.of(~ NilClass) === c           # => false
+    Array.of(Positive & Integer) === b   # => false
+
+    c = [ 1, 1.5, 3 ]
+    Array.of(Positive & Integer) === c   # => false
+
+    d = [ 1, nil, 3 ]
+    Array.of(~ NilClass) === d           # => false
 
 Composite types are cached indefinitely, therefore anonymous Modules cannot be composed.
 

data/composite_type.gemspec

@@ -19,10 +19,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "simplecov", "~> 0.8"
-  spec.add_development_dependency "pry", "~> 0.9"
-  spec.add_development_dependency "guard", "~> 2.6"
-  spec.add_development_dependency "guard-rspec", "~> 4.3"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "guard", "~> 2.14"
+  spec.add_development_dependency "guard-rspec", "~> 4.7"
 end

data/lib/composite_type.rb

@@ -23,16 +23,27 @@ class Module
   end
 
   # Matches nothing.
-  module Void
+  module VoidType
     def === x
       false
     end
+
+    def >= t
+      self == t
+    end
   end
+  Void = Class.new.extend(VoidType)
 
   class ContainerType < CompositeType
     def === x
       @_t[0] === x and x.all?{|e| @_t[1] === e }
     end
+
+    def >= t
+      super or
+        t.is_a?(self.class) and @_t.zip(t._t).all?{|e1, e2| e1 >= e2 }
+    end
+
     def to_s
       @to_s ||= "#{@_t[0]}.of(#{@_t[1]})".freeze
     end
@@ -54,6 +65,12 @@ class Module
           @_t.all?{|t| t === x[i += 1]}
         end
     end
+
+    def >= t
+      super or
+        t.is_a?(self.class) and @_t.zip(t._t).all?{|e1, e2| e1 >= e2 }
+    end
+
     def to_s
       @to_s ||= "#{@_t[0]}.with(#{@_t[1..-1] * ','})".freeze
     end
@@ -61,8 +78,8 @@ class Module
 
   # Constructs a type of Enumerable elements.
   #
-  # String.with(Integer, Float) === [ "foo", 1, 1.2 ]
-  # Hash.of(String.with(Integer))
+  #   String.with(Integer, Float) === [ "foo", 1, 1.2 ]
+  #   Hash.of(String.with(Integer))
   def with *types
     EnumeratedType.new_cached(self, *types)
   end
@@ -71,6 +88,18 @@ class Module
     def === x
        @_t[0] === x or @_t[1] === x
     end
+
+    def >= t
+      case
+      when super
+        true
+      when t.is_a?(self.class)
+        t._t.all?{|e2| @_t.any?{|e1| e1 >= e2}}
+      else
+        @_t.any?{|e1| e1 >= t}
+      end
+    end
+
     def to_s
       @to_s ||= "(#{@_t[0]}|#{@_t[1]})".freeze
     end
@@ -78,7 +107,7 @@ class Module
 
   # Constructs a type which can be A OR B.
   #
-  # Array.of(String|Integer)
+  #   Array.of(String|Integer)
   def | t
     case
     when t <= self
@@ -86,7 +115,9 @@ class Module
     when self <= t
       t
     else
-      DisjunctiveType.new_cached(self, t)
+      a, b = self, t
+      a, b = b, a if a.to_s > b.to_s
+      DisjunctiveType.new_cached(a, b)
     end
   end
 
@@ -94,6 +125,18 @@ class Module
     def === x
        @_t[0] === x and @_t[1] === x
     end
+
+    def >= t
+      case
+      when super
+        true
+      when t.is_a?(self.class)
+        t._t.all?{|e2| @_t.all?{|e1| e1 >= e2}}
+      else
+        @_t.all?{|e1| e1 >= t}
+      end
+    end
+
     def to_s
       @to_s ||= "(#{@_t[0]}&#{@_t[1]})".freeze
     end
@@ -103,24 +146,47 @@ class Module
   #
   # Array.of(Positive & Integer)
   def & t
-    ConjunctiveType.new_cached(self, t)
+    case
+    when equal?(t)
+      self
+    else
+      a, b = self, t
+      a, b = b, a if a.to_s > b.to_s
+      ConjunctiveType.new_cached(a, b)
+    end
   end
 
   class NegativeType < CompositeType
     def === x
        ! (@_t[0] === x)
     end
+
+    def >= t
+      t.is_a?(self.class) and
+        t._t[0] >= @_t[0]
+    end
+
     def to_s
       @to_s ||= "(~#{@_t[0]})".freeze
     end
+
+    INVERSE_MAP = {
+    }
+    def self.inverse(a, b)
+      INVERSE_MAP[a] = b
+      INVERSE_MAP[b] = a
+    end
+    inverse(Object, Void)
   end
 
   # Constructs a type which must not be A.
   #
   # Array.of(~ NilClass)
   def ~@
-    case self
-    when NegativeType
+    case
+    when x = NegativeType::INVERSE_MAP[self]
+      x
+    when self.is_a?(NegativeType)
       self._t.first
     else
       NegativeType.new_cached(self)
@@ -161,6 +227,7 @@ module NonPositive
   def self.=== x
     x <= 0 rescue nil
   end
+  Module::NegativeType.inverse(self, Positive)
 end
 
 # Objects that are Numericlike and >= 0.
@@ -168,6 +235,7 @@ module NonNegative
   def self.=== x
     x >= 0 rescue nil
   end
+  Module::NegativeType.inverse(self, Negative)
 end
 
 # Objects that can do IO.

data/lib/composite_type/version.rb

@@ -1,3 +1,3 @@
 module CompositeType
-  VERSION = "0.1.1"
+  VERSION = "0.2.2"
 end

data/spec/lib/composite_type_spec.rb

@@ -1,7 +1,14 @@
 require 'spec_helper'
 require 'composite_type'
 
-describe Class::CompositeType do
+describe Module::CompositeType do
+  module A; end
+  module B; end
+  module C; include A; end
+  module D; include B; end
+  module E; include A, B; end
+  module F; include A, B; end
+
   it "should cache instances" do
     t1 = Array.of(String.with(~ Float | Symbol & Hash))
     t2 = Array.of(String.with(~ Float | Symbol & Hash))
@@ -14,6 +21,20 @@ describe Class::CompositeType do
     }.to raise_error(Module::CompositeType::Error, "cannot create CompositeType from unamed object")
   end
 
+  context Module::Void do
+    subject { Module::Void }
+    it "does not match anything" do
+      expect(subject === Object.new) .to be_falsey
+    end
+    context "#>=" do
+      it "is disjoint from everything" do
+        expect( subject >= subject ) .to be_truthy
+        expect( Object  >= subject ) .to be_truthy
+        expect( subject >= Object  ) .to be_falsey
+      end
+    end
+  end
+
   context Numericlike do
     subject { Numericlike }
     let(:numeric_like) do
@@ -43,125 +64,102 @@ describe Class::CompositeType do
 
   context "EnumeratedType" do
     subject { Integer.with(Symbol, String) }
-    it "should not fail" do
+    it "is true for respective unmatches" do
       expect(subject === [ 1, :symbol, "string" ]) .to be_truthy
     end
-    it "should fail" do
+    it "is false for respective unmatches" do
       expect(subject === [ ]) .to be_falsey
-    end
-    it "should fail" do
       expect(subject === [ 1, :symbol, :wrong ]) .to be_falsey
     end
-    it "should fail" do
+    it "is false for too many elements" do
       expect(subject === [ 1, :symbol, "string", :too_many]) .to be_falsey
     end
   end
 
   context "ContainerType" do
     subject { Array.of(String) }
-    it "should not fail when empty" do
+    it "is true when empty" do
       expect(subject === [ ]) .to be_truthy
     end
-    it "should not fail with a matching element" do
+    it "is true with a matching element" do
       expect(subject === [ "String" ]) .to be_truthy
     end
-    it "should fail when contains unmatching element" do
+    it "is false with an unmatching element" do
       expect(subject === [ "String", 1234 ]) .to be_falsey
     end
-    it "should fail when is not an Enumerable" do
+    it "is false without an Enumerable" do
       expect(subject === 1234) .to be_falsey
     end
-    it "should fail when is not equvalent" do
+    it "is false when not equvalent" do
       expect(subject === { }) .to be_falsey
     end
   end
 
   context "EnumeratedType" do
     subject { Hash.of(String.with(Integer)) }
-    it "should not fail when empty" do
+    it "matches" do
       expect(subject === { }) .to be_truthy
-    end
-
-    it "should not fail" do
       expect(subject === { "foo" => 1 }) .to be_truthy
-    end
-
-    it "should fail" do
       expect(subject === { "foo" => :symbol }) .to be_falsey
-    end
-
-    it "should fail" do
       expect(subject === { :symbol => 2 }) .to be_falsey
     end
   end
 
   context "DisjunctiveType" do
-    it "should reduce to the greater type if A or B are subclasses of each other" do
-      expect(Float   | Numeric) .to equal(Numeric)
-      expect(Numeric | Float  ) .to equal(Numeric)
-      expect(Numeric | Numeric) .to equal(Numeric)
-    end
-
-    it "should not reduce if A and B are disjunctive" do
-      expect((Numericlike | Numeric).to_s) .to eq("(Numericlike|Numeric)")
-      expect((String | Array).to_s)        .to eq("(String|Array)")
+    it "matches" do
+      expect((String | Integer) === "String") .to be_truthy
+      expect((String | Integer) === 1234)     .to be_truthy
+      expect((String | Integer) === :symbol)  .to be_falsey
     end
 
-    it "should not fail when empty" do
-      v = [ ]
-      expect(Array.of(String | Integer) === v) .to be_truthy
+    it "rewrites B | A => A | B" do
+      expect((B | A)) .to equal((A | B))
     end
 
-    it "should not fail" do
-      v = [ "String", 1234 ]
-      expect(Array.of(String | Integer) === v) .to be_truthy
+    it "reduces to the greater type if A or B are subclasses of each other" do
+      expect(Float   | Numeric) .to equal(Numeric)
+      expect(Numeric | Float  ) .to equal(Numeric)
+      expect(Numeric | Numeric) .to equal(Numeric)
     end
 
-    it "should fail" do
-      v = [ "String", 1234, :symbol ]
-      expect(Array.of(String | Integer) === v) .to be_falsey
+    it "does not reduce if A and B are disjunctive" do
+      expect((Numericlike | Numeric).to_s) .to eq("(Numeric|Numericlike)")
+      expect((String | Array).to_s)        .to eq("(Array|String)")
     end
   end
 
   context "ConjunctiveType" do
-    subject { Array.of(Positive & Integer) }
-    it "should not fail when empty" do
-      v = [ ]
-      expect(subject === v) .to be_truthy
-    end
-
-    it "should not fail" do
-      v = [ 1, 2 ]
-      expect(subject === v) .to be_truthy
+    subject { Positive & Integer }
+    it "matches" do
+      expect(subject === 1) .to be_truthy
+      expect(subject === 0) .to be_falsey
+      expect(subject === 0.0) .to be_falsey
+      expect(subject === :symbol) .to be_falsey
     end
-
-    it "should fail" do
-      v = [ 0, 1 ]
-      expect(subject === v) .to be_falsey
+    it "folds A & A => A" do
+      expect((A & A)) .to equal(A)
     end
-
-    it "should fail" do
-      v = [ 1, :symbol ]
-      expect(subject === v) .to be_falsey
+    it "rewrites B & A => A & B" do
+      expect((B & A)) .to equal((A & B))
     end
   end
 
   context "NegativeType" do
-    it "~~A == A" do
-      t = String
-      expect(~ ~ t) .to equal(t)
+    it "matches" do
+      expect((~ NilClass) === 1)       .to be_truthy
+      expect((~ NilClass) === :symbol) .to be_truthy
+      expect((~ NilClass) === nil)     .to be_falsey
     end
 
-    it "should be true for match" do
-      v = [ 1, :symbol ]
-      expect(Array.of(~ NilClass) === v) .to be_truthy
+    it "rewrites (~ (~ A)) => A" do
+      expect(~ ~ A) .to equal(A)
     end
 
-    it "should be false for match" do
-      v = [ 1, nil, :symbol ]
-      expect((~ NilClass) === 1)    .to be_truthy
-      expect((~ NilClass) === nil)  .to be_falsey
-      expect(Array.of(~ NilClass) === v) .to be_falsey
+    it "rewrites inverse types" do
+      expect(~ Object)       .to equal(Module::Void)
+      expect(~ Module::Void) .to equal(Object)
+      expect(~ Negative)     .to equal(NonNegative)
+      expect(~ NonNegative)  .to equal(Negative)
     end
   end
 
@@ -209,6 +207,44 @@ describe Class::CompositeType do
     end
   end
 
+  context "#>=" do
+    it "returns true where left side is a supertype of right side" do
+      expect( Array.of(Object) >= Array.of(String) ) .to be_truthy
+      expect( Array.of(String) >= Array.of(Object) ) .to be_falsey
+      expect( Array.of(String) >= Object           ) .to be_falsey
+
+      expect( Numeric.with(Integer) >= Numeric.with(Bignum) ) .to be_truthy
+      expect( Numeric.with(Integer) >= Float.with(Bignum)   ) .to be_truthy
+      expect( Numeric.with(Integer) >= Object.with(Bignum)  ) .to be_falsey
+      expect( Numeric.with(Integer) >= Float.with(Object)   ) .to be_falsey
+      expect( Numeric.with(Integer) >= Integer.with(Object) ) .to be_falsey
+
+      expect( Hash.of(Symbol.with(Object)) >= Hash.of(Symbol.with(String)) ) .to be_truthy
+      expect( Hash.of(Symbol.with(Object)) >= Hash.of(Symbol.with(Fixnum)) ) .to be_truthy
+      expect( Hash.of(Symbol.with(String)) >= Hash.of(Symbol.with(Fixnum)) ) .to be_falsey
+      expect( Hash.of(Symbol.with(Object)) >= Array.of(String) ) .to be_falsey
+
+      expect( (Integer | Float) >= (Integer | Float) ) .to be_truthy
+      expect( (Integer | Float) >= Integer ) .to be_truthy
+      expect( (Integer | Float) >= Fixnum  ) .to be_truthy
+      expect( (Integer | Float) >= Bignum  ) .to be_truthy
+      expect( (Fixnum  | Float) >= Bignum  ) .to be_falsey
+      expect( (Fixnum  | Float) >= (Float | Bignum)  ) .to be_falsey
+      expect( (Integer | Float) >= (Float | Fixnum)  ) .to be_truthy
+
+      expect( (Positive & Integer) >= (Integer & Positive) ) .to be_truthy
+      expect( (A & B) >= E ) .to be_truthy
+      expect( (A & B) >= C ) .to be_falsey
+      expect( (A & B) >= (E & F) ) .to be_truthy
+      expect( (Positive & Integer) >= Integer ) .to be_falsey
+
+      expect( (~ A) >= B ) .to be_falsey
+      expect( (~ Numeric) >= (~ Fixnum) )  .to be_falsey
+      expect( (~ Fixnum)  >= (~ Numeric) ) .to be_truthy
+      expect( (~ Object)  >= (~ Fixnum)  ) .to be_falsey
+    end
+  end
+
   context "misc" do
     it "example 1" do
       h = { "a" => 1, "b" => :symbol }
@@ -223,6 +259,5 @@ describe Class::CompositeType do
     it "should handle to_s" do
       expect(Hash.of(String.with(Integer | Symbol)).to_s) .to eq("Hash.of(String.with((Integer|Symbol)))")
     end
-
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: composite_type
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Kurt Stephens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-27 00:00:00.000000000 Z
+date: 2016-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,34 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
-- !ruby/object:Gem::Dependency
-  name: rake
-  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: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -72,42 +44,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.10'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.14'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '4.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '4.7'
 description: Composite Types for Ruby
 email:
 - ks.github@kurtstephens.com
@@ -147,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Array.of(String)