composite_type 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9faec747d46328dfe04c62ee29c4a1e98684db41
+  data.tar.gz: bd68565039a8dbca31c5cc486ca2a705c964e871
+SHA512:
+  metadata.gz: 4d9548cd6e18641f59295f6f7017f92d6ef9196b057b586552130da90f44374abedb7e4a66b8dee63482dc829f7a1fde4c5cb539299bea1e5821a397f98fa5a0
+  data.tar.gz: d0f8c5ec6cce22afca349bb85d464919b3b3eb4b7015e912f45b047274a5265633d99f578218d98449275cd39c960ff0af128c86a349fac2131bc467ca9155bb

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Guardfile

@@ -0,0 +1,7 @@
+guard 'rspec', cmd: "bundle exec rspec" do
+  watch(%r{^spec/.+_spec\.rb$}) { "spec" }
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch('.rspec')               { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kurt Stephens
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,92 @@
+# TypedAttr
+
+Typed Attributes and Composite Types for Functional Programming in Ruby
+
+## Usage
+
+TypedAttr simplifies typed functional programming in Ruby.
+
+The creation of data types is central to functional programming.
+Ruby does not enforce any typing of object attributes or method parameters.
+
+TypedAttr introduces a class macro "typed_attr".  It constructs an #initialize method
+given a list of attributes and their expected types.
+
+Example:
+
+    require 'typed_attr'
+    class Account
+      typed_attr name: String, amount: Money
+    end
+    Account.new("Foo", Money.new(1234))
+    Account.new("Foo", 1234) # => raise TypeError
+
+Use "typecheck" to perform checks on values:
+
+    def m x, y
+      typecheck x, String
+      typecheck y, Positive, Integer
+      x * y
+    end
+    m("string", -1) # => raise TypeError
+    m("string", 2)  # => "stringstring"
+
+The type assertions use the #=== matching operator.
+
+Composite Types can be constructed to match deeper data structures:
+
+    h = { "a" => 1, "b" => :symbol }
+    typecheck h, Hash.of(String.with(Integer|Symbol))
+
+Defining types through Modules:
+
+    module Even
+      def self.=== x
+         Integer === x and x.even?
+      end
+    end
+    Array.of(Even) === [ 2, 4, 10 ]
+
+Composite types create dynamic Modules that redefine the #=== pattern matching operator.
+Thus composite types can be used in "case when" clauses:
+
+    case h
+    when Hash.of(String.with(Users))  ...
+    when Hash.of(Symbol.with(Object)) ...
+    end
+
+Logical operators: #|, #&, #~ are supported:
+
+    a = [ 1, 2, 3 ]
+    typecheck a, Array.of(Positive & Numeric)
+    typecheck a, Array.of(~ NilClass)
+    
+    b = [ 1, -2, 3 ]
+    typecheck b, Array.of(Positive & Numeric) # => raise TypeError
+    
+    c = [ 1, nil, 3 ]
+    typecheck c, Array.of(~ NilClass)         # => raise TypeError
+
+Composite types are cached indefinitely, therefore anonymous Modules cannot be composed.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'typed_attr'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install typed_attr
+
+## 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

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/composite_type.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'composite_type/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "composite_type"
+  spec.version       = CompositeType::VERSION
+  spec.authors       = ["Kurt Stephens"]
+  spec.email         = ["ks.github@kurtstephens.com"]
+  spec.description   = %q{Composite Types for Ruby}
+  spec.summary       = %q{Array.of(String)}
+  spec.homepage      = "https://github.com/kstephens/composite_type"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  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"
+end

data/lib/composite_type/version.rb

@@ -0,0 +1,3 @@
+module CompositeType
+  VERSION = "0.1.0"
+end

data/lib/composite_type.rb

@@ -0,0 +1,182 @@
+require 'thread'
+
+class Module
+  class CompositeType < self
+    class Error < ::StandardError; end
+
+    def self.new_cached *types
+      key = [ self, types ]
+      (Thread.current[:'Module::CompositeType.cache'] ||= { })[key] ||=
+      CACHE_MUTEX.synchronize do
+        CACHE[key] ||= new(types)
+      end
+    end
+    CACHE = { }
+    CACHE_MUTEX = Mutex.new
+
+    def initialize types
+      raise Error, "cannot create CompositeType from unamed object" unless types.all?{|x| x.name}
+      @_t = types
+    end
+    attr_reader :_t
+    def name; to_s; end
+  end
+
+  # Matches nothing.
+  module Void
+    def === x
+      false
+    end
+  end
+
+  class ContainerType < CompositeType
+    def === x
+      @_t[0] === x and x.all?{|e| @_t[1] === e }
+    end
+    def to_s
+      @to_s ||= "#{@_t[0]}.of(#{@_t[1]})".freeze
+    end
+  end
+
+  # Constructs a type of that matches an Enumerable with an element type.
+  #
+  # Array.of(String)
+  def of t
+    ContainerType.new_cached(self, t)
+  end
+
+  class EnumeratedType < CompositeType
+    def === x
+      Enumerable === x and
+        @_t.size == x.size and
+        begin
+          i = -1
+          @_t.all?{|t| t === x[i += 1]}
+        end
+    end
+    def to_s
+      @to_s ||= "#{@_t[0]}.with(#{@_t[1..-1] * ','})".freeze
+    end
+  end
+
+  # Constructs a type of Enumerable elements.
+  #
+  # String.with(Integer, Float) === [ "foo", 1, 1.2 ]
+  # Hash.of(String.with(Integer))
+  def with *types
+    EnumeratedType.new_cached(self, *types)
+  end
+
+  class DisjunctiveType < CompositeType
+    def === x
+       @_t[0] === x or @_t[1] === x
+    end
+    def to_s
+      @to_s ||= "(#{@_t[0]}|#{@_t[1]})".freeze
+    end
+  end
+
+  # Constructs a type which can be A OR B.
+  #
+  # Array.of(String|Integer)
+  def | t
+    case
+    when t <= self
+      self
+    when self <= t
+      t
+    else
+      DisjunctiveType.new_cached(self, t)
+    end
+  end
+
+  class ConjunctiveType < CompositeType
+    def === x
+       @_t[0] === x and @_t[1] === x
+    end
+    def to_s
+      @to_s ||= "(#{@_t[0]}&#{@_t[1]})".freeze
+    end
+  end
+
+  # Constructs a type which must be A AND B.
+  #
+  # Array.of(Positive & Integer)
+  def & t
+    ConjunctiveType.new_cached(self, t)
+  end
+
+  class NegativeType < CompositeType
+    def === x
+       ! (@_t[0] === x)
+    end
+    def to_s
+      @to_s ||= "(~#{@_t[0]})".freeze
+    end
+  end
+
+  # Constructs a type which must not be A.
+  #
+  # Array.of(~ NilClass)
+  def ~@
+    case self
+    when NegativeType
+      self._t.first
+    else
+      NegativeType.new_cached(self)
+    end
+  end
+end
+
+# Numeric origin/continuum types.
+
+# Objects that are Numeric or respond to :to_numeric.
+module Numericlike
+  def self.=== x
+    case
+    when Numeric === x
+      x
+    when x.respond_to?(:to_numeric)
+      x.to_numeric
+    end
+  end
+end
+
+# Objects that are > 0.
+module Positive
+  def self.=== x
+    x > 0 rescue nil
+  end
+end
+
+# Objects that are < 0.
+module Negative
+  def self.=== x
+    x < 0 rescue nil
+  end
+end
+
+# Objects that are <= 0.
+module NonPositive
+  def self.=== x
+    x <= 0 rescue nil
+  end
+end
+
+# Objects that are Numericlike and >= 0.
+module NonNegative
+  def self.=== x
+    x >= 0 rescue nil
+  end
+end
+
+# Objects that can do IO.
+#
+# Note: IO and StringIO do not share a common ancestor Module
+# that distingushes them as being capable of "IO".
+# So we create one here -- devdriven.com 2013/11/14
+require 'stringio'
+module IOable
+  ::IO.send(:include, self)
+  ::StringIO.send(:include, self)
+end

data/spec/lib/composite_type_spec.rb

@@ -0,0 +1,228 @@
+require 'spec_helper'
+require 'composite_type'
+
+describe Class::CompositeType do
+  it "should cache instances" do
+    t1 = Array.of(String.with(~ Float | Symbol & Hash))
+    t2 = Array.of(String.with(~ Float | Symbol & Hash))
+    expect(t1.object_id) .to eql(t2.object_id)
+  end
+
+  it "should fail for anonymous Modules" do
+    expect {
+      Module.new | String
+    }.to raise_error(Module::CompositeType::Error, "cannot create CompositeType from unamed object")
+  end
+
+  context Numericlike do
+    subject { Numericlike }
+    let(:numeric_like) do
+      Class.new do
+        def to_numeric; -1234; end
+      end
+    end
+
+    it "should be true for Numeric" do
+      v = 1234
+      x = subject === v
+      expect(x) .to eql(v)
+    end
+
+    it "should be true for anything that responds to :to_numeric" do
+      v = numeric_like.new
+      x = subject === v
+      expect(x) .to eql(-1234)
+    end
+
+    it "should be false for non-Numeric" do
+      v = "a String"
+      expect(v.respond_to?(:to_numeric)) .to be_falsey
+      expect(subject === v)              .to be_falsey
+    end
+  end
+
+  context "EnumeratedType" do
+    subject { Integer.with(Symbol, String) }
+    it "should not fail" do
+      expect(subject === [ 1, :symbol, "string" ]) .to be_truthy
+    end
+    it "should fail" do
+      expect(subject === [ ]) .to be_falsey
+    end
+    it "should fail" do
+      expect(subject === [ 1, :symbol, :wrong ]) .to be_falsey
+    end
+    it "should fail" 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
+      expect(subject === [ ]) .to be_truthy
+    end
+    it "should not fail with a matching element" do
+      expect(subject === [ "String" ]) .to be_truthy
+    end
+    it "should fail when contains unmatching element" do
+      expect(subject === [ "String", 1234 ]) .to be_falsey
+    end
+    it "should fail when is not an Enumerable" do
+      expect(subject === 1234) .to be_falsey
+    end
+    it "should fail when is 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
+      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)")
+    end
+
+    it "should not fail when empty" do
+      v = [ ]
+      expect(Array.of(String | Integer) === v) .to be_truthy
+    end
+
+    it "should not fail" do
+      v = [ "String", 1234 ]
+      expect(Array.of(String | Integer) === v) .to be_truthy
+    end
+
+    it "should fail" do
+      v = [ "String", 1234, :symbol ]
+      expect(Array.of(String | Integer) === v) .to be_falsey
+    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
+    end
+
+    it "should fail" do
+      v = [ 0, 1 ]
+      expect(subject === v) .to be_falsey
+    end
+
+    it "should fail" do
+      v = [ 1, :symbol ]
+      expect(subject === v) .to be_falsey
+    end
+  end
+
+  context "NegativeType" do
+    it "~~A == A" do
+      t = String
+      expect(~ ~ t) .to equal(t)
+    end
+
+    it "should be true for match" do
+      v = [ 1, :symbol ]
+      expect(Array.of(~ NilClass) === v) .to be_truthy
+    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
+    end
+  end
+
+  context Negative do
+    subject { Negative }
+    it "matches non-positive Numerics" do
+      expect(subject === -1)   .to be_truthy
+      expect(subject === -0.5) .to be_truthy
+      expect(subject === 0)    .to be_falsey
+      expect(subject === 0.5)  .to be_falsey
+      expect(subject === 1)    .to be_falsey
+    end
+  end
+
+  context Negative do
+    subject { Negative }
+    it "matches non-positive Numerics" do
+      expect(subject === -1)   .to be_truthy
+      expect(subject === -0.5) .to be_truthy
+      expect(subject === 0)    .to be_falsey
+      expect(subject === 0.5)  .to be_falsey
+      expect(subject === 1)    .to be_falsey
+    end
+  end
+
+  context NonPositive do
+    subject { NonPositive }
+    it "matches non-positive Numerics" do
+      expect(subject === -1)   .to be_truthy
+      expect(subject === -0.5) .to be_truthy
+      expect(subject === 0)    .to be_truthy
+      expect(subject === 0.5)  .to be_falsey
+      expect(subject === 1)    .to be_falsey
+    end
+  end
+
+  context NonNegative do
+    subject { NonNegative }
+    it "matches non-negative Numerics" do
+      expect(subject === -1)   .to be_falsey
+      expect(subject === -0.5) .to be_falsey
+      expect(subject === 0)    .to be_truthy
+      expect(subject === 0.5)  .to be_truthy
+      expect(subject === 1)    .to be_truthy
+    end
+  end
+
+  context "misc" do
+    it "example 1" do
+      h = { "a" => 1, "b" => :symbol }
+      expect(Hash.of(String.with(Integer | Symbol)) === h) .to be_truthy
+    end
+
+    it "example 2" do
+      h = { "a" => 1, "b" => "string" }
+      expect(Hash.of(String.with(Integer | Symbol)) === h) .to be_falsey
+    end
+
+    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

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+gem 'pry'
+require 'pry'
+
+gem 'simplecov'
+require 'simplecov'
+SimpleCov.start do
+  add_filter "spec/"
+end
+
+RSpec.configure do |config|
+  # ## Mock Framework
+  config.mock_with :rspec
+  config.order = "random"
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: composite_type
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kurt Stephens
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+description: Composite Types for Ruby
+email:
+- ks.github@kurtstephens.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- composite_type.gemspec
+- lib/composite_type.rb
+- lib/composite_type/version.rb
+- spec/lib/composite_type_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kstephens/composite_type
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Array.of(String)
+test_files:
+- spec/lib/composite_type_spec.rb
+- spec/spec_helper.rb