CompositeType

Composite Types and Schema for Ruby

Modules (and the subclass Class) are often used as pattern matchers.

Usage

Defining types through Modules:

module Even
def self.=== x
Integer === x and x.even?
end
end
Even === 2 # => true
Even === 3 # => false

Module Extensions

Logical operators: #|, #&, #~ compose types logically:

(String | Symbol) === :a # => true
(String | Symbol) === "a" # => true
(String | Symbol) === 1 # => false
(Positive & Integer) === 1 # => true
(Positive & Integer) === -2 # => false
(~ NilClass) === 1 # => true
(~ NilClass) === nil # => false

Composite types create dynamic Modules that define the #=== pattern matching operator.

Thus composite types can be used in "case" clauses:

Odd = ~ Even
case x
when 0 then "zero"
when Odd then "odd"
when Even then "even"
end

Composite types are cached indefinitely, therefore anonymous Modules cannot be composed.

Schema

Provides a basic library to interpret a Ruby data structure as a matchable schema:

schema = Schema[ { Many[Symbol] => String } ]
schema === { a: "b" } # => true
schema === { } # => true
schema === { 1 => 2 } # => false
schema = Schema[ { OneOrMore[Symbol] => String } ]
schema === { a: "b" } # => true
schema === { } # => false

Basic Data Structures

Composite Types can be constructed to match data structures:

h = { "a" => 1, "b" => :symbol }
Hash.of(String.with(Integer|Symbol)) === h # => true
case h
when Hash.of(String.with(Users)) ...
when Hash.of(Symbol.with(Object)) ...
end

See spec/lib/**/_spec.rb for more examples.

Installation

Add this line to your application's Gemfile:

gem 'composite_type'

And then execute:

$ bundle

Or install it yourself as:

$ gem install composite_type

Contributing

1. Fork it
2. Create your feature branch (git checkout -b my-new-feature)
3. Commit your changes (git commit -am 'Add some feature')
4. Push to the branch (git push origin my-new-feature)
5. Create new Pull Request