typist 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2757d8cd18bfb8ebf6112c05e260f20805f6fb4d
+  data.tar.gz: b5a017f46fba7063f1d8661bfadc2dca4876f0bd
+SHA512:
+  metadata.gz: 175cca390f72642c375d281d836c90a38bbad5bb774049babbb17b3a626a2e74fc1fe51971cb6af2549f867dad42027cfdb12ef33d37728077b0bf8cccc96086
+  data.tar.gz: e0502bdfa7442b48ae9a7baae0985c4f49c353bbeedcccf759f03e46755fbd18cc3f81573878803c06c42d1a396e414295fd66b6149d20af74ec799c01d0d6ee

data/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+*.gem
+Gemfile.lock
+coverage/

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3-p484
+  - 2.0.0-p353
+  - 2.1.0
+  - jruby-1.7.9

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,133 @@
+# typist
+
+[![Build Status](https://travis-ci.org/nahiluhmot/typist.png?branch=master)](https://travis-ci.org/nahiluhmot/typist)
+[![Code Climate](https://codeclimate.com/github/nahiluhmot/typist.png)](https://codeclimate.com/github/nahiluhmot/typist)
+
+`typist` is a gem that allows you to define Algebraic Data Types (ADTs) in Ruby.
+For a tutorial on ADTs, I recommend [Learn You a Haskell's tutorial](http://learnyouahaskell.com/making-our-own-types-and-typeclasses).
+
+Features:
+
+* A rich DSL that allows for idiomatic defintions of the data types
+* Pattern matching
+* Runtime support for incomplete pattern matches
+* Class-load time support for invalid pattern matches
+
+Planned Improvements:
+
+* Type classes
+* Optional runtime type checking
+
+# Installation
+
+From the command line:
+
+```shell
+$ gem install typist
+```
+
+From a Gemfile:
+
+```ruby
+gem 'typist'
+```
+
+# Usage
+
+To define a data type, first extend the `Typist` module in a top-level statement, or in the module in which you'd like your data type defined.
+For example, to create a new data type in the `Test` module:
+
+```ruby
+module Test
+  extend Typist
+
+  ...
+end
+```
+
+Once `Typist` has been extended, the `data` function will define a data type.
+The following defines a new data type called `Tree` in the `Test` module:
+
+```ruby
+module Test
+  extend Typist
+
+  data :Tree do
+    ...
+  end
+end
+```
+
+Type constructors may be defined using the `constructor` function.
+
+```ruby
+module Test
+  extend Typist
+
+  data :Tree do
+    constructor :Leaf
+    constructor :Node, :value, :left, :right
+  end
+end
+```
+
+Now, `Tree::Leaf` and `Tree::Node` are defined.
+The arguments that come after the constructor name are the instance variables -- accessors are defined for each of them.
+To create a new Leaf, run `Tree.leaf`.
+To create a new Node, run `Tree.node(:value => val, :right => Tree.leaf, :left => Tree.leaf)`.
+
+Finally, the DSL allows the user to define and pattern match in functions.
+The `func` method in the context of a data type declares a new function.
+For example:
+
+```ruby
+module Test
+  extend Typist
+
+  data :Tree do
+    constructor :Leaf
+    constructor :Node, :value, :left, :right
+
+    func :contains? do
+      match Tree::Leaf do |element|
+        false
+      end
+
+      match Tree::Node do |element|
+        case value <=> element
+        when -1
+          left.contains?(element)
+        when 1
+          right.contains?(element)
+        else
+          true
+        end
+      end
+    end
+  end
+end
+```
+
+This defines `#contains?` method on `Tree::Node` and `Tree::Leaf`.
+Example usage:
+
+```ruby
+leaf = Tree.leaf
+node = Tree.node(:value => 'a', :left => Tree.leaf, right => Tree.leaf)
+
+leaf.contains?('a')
+# => false
+
+node.contains?('a')
+# => true
+```
+
+# Contributing
+
+1. Fork the repository
+2. Create a branch
+3. Add tests
+4. Commit your changes
+5. Push the branch
+6. DO NOT bump the version
+7. Submit a Pull Request

data/Rakefile

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'rake'
+require 'typist'
+require 'rspec/core/rake_task'
+require 'cane/rake_task'
+
+task :default => [:spec, :quality]
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+Cane::RakeTask.new(:quality) do |cane|
+  cane.canefile = '.cane'
+end

data/lib/typist/constructor.rb

@@ -0,0 +1,48 @@
+# This class represents a data-type contstructor.
+class Typist::Constructor
+  attr_reader :name, :vars
+
+  # Create a new constructor with the given name and instance variable(s).
+  def initialize(name, *vars)
+    @name = name
+    @vars = vars
+  end
+
+  # Get the Class that this Constructor defines.
+  def get_class
+    @class ||= Class.new
+  end
+
+  # Turn the constructor into a class definition, then define a convenience
+  # method in the given module.
+  def define!(context)
+    get_class.tap do |klass|
+      define_class(context, klass)
+      define_initializer(context, klass)
+    end
+  end
+
+  def define_class(context, klass)
+    attrs = vars
+    klass.instance_eval do
+      include context
+      attr_accessor(*attrs)
+
+      define_method(:initialize) do |hash = {}|
+        hash.each { |key, val| instance_variable_set(:"@#{key}", val) }
+      end
+    end
+    context.const_set(name, klass)
+  end
+  private :define_class
+
+  def define_initializer(context, klass)
+    method_name = Typist::Util.snakeify(name)
+
+    context.module_eval do
+      define_method(method_name) { |*args| klass.new(*args) }
+      module_function method_name
+    end
+  end
+  private :define_initializer
+end

data/lib/typist/data.rb

@@ -0,0 +1,38 @@
+# Instances of this class may be included like a module.
+class Typist::Data
+  attr_reader :name, :constructors, :funcs, :block
+
+  # Create a new data type with the given name. The block will be evaluated in
+  # the context of the new instance.
+  def initialize(name, &block)
+    @name = name
+    @constructors = []
+    @funcs = []
+    @block = block
+  end
+
+  # Define a constructor for this data type.
+  def constructor(*args, &block)
+    constructors << Typist::Constructor.new(*args, &block)
+  end
+
+  # Define a function which may pattern-matched against
+  def func(*args, &block)
+    funcs << Typist::Func.new(*args, &block)
+  end
+
+  # Get the module that is defined.
+  def get_module
+    @module ||= Module.new
+  end
+
+  # Define the module, constructors, and functions.
+  def define!(mod = Kernel)
+    get_module.tap do |context|
+      mod.const_set(name, context)
+      instance_eval(&block) unless block.nil?
+      constructors.each { |constructor| constructor.define!(context) }
+      funcs.each { |func| func.define!(context) }
+    end
+  end
+end

data/lib/typist/error.rb

@@ -0,0 +1,11 @@
+# This module holds all errors thrown in the gem.
+module Typist::Error
+  # This class is never thrown, but can be used as a catch-all.
+  class BaseError < StandardError; end
+
+  # This is thrown when a pattern match is not exhaustive.
+  class PatternError < BaseError; end
+
+  # This is thrown when an invalid type contstructor is matched against.
+  class MatchError < BaseError; end
+end

data/lib/typist/func.rb

@@ -0,0 +1,49 @@
+# This class defines the `func` DSL.
+class Typist::Func
+  attr_reader :name, :matches, :block
+
+  # Create a new function with the given name (String/Symbol). If a block is
+  # given, it will be evaluated in the context of the new instance.
+  def initialize(name, &block)
+    @name = name
+    @matches = {}
+    @block = block
+  end
+
+  # Pattern match against the given class.
+  def match(klass, &block)
+    matches[klass] = block
+  end
+
+  # Given a module define this function, plus the pattern matches for all of its
+  # subclasses.
+  def define!(context)
+    instance_eval(&block) unless block.nil?
+    define_base(context)
+    matches.each { |klass, block| define_match(context, klass, &block) }
+    context
+  end
+
+  def define_base(context)
+    method_name = name
+
+    context.class_eval do
+      define_method(method_name) do |*_, &_|
+        raise Typist::Error::PatternError,
+          "Patterns not exhaustive in #{context}##{method_name}"
+      end
+    end
+  end
+  private :define_base
+
+  def define_match(context, klass, &block)
+    unless klass.ancestors.include?(context)
+      raise Typist::Error::MatchError,
+        "#{klass} is not a valid constructor for #{context}"
+    end
+
+    method_name = name
+    klass.class_eval { define_method(method_name, &block) }
+  end
+  private :define_match
+end

data/lib/typist/util.rb

@@ -0,0 +1,15 @@
+# This module contains common logic used throughout the gem.
+module Typist::Util
+  # Convert a CamelCase String to snake_case. Shamelessly stolen from
+  # ActiveSupport.
+  def snakeify(string)
+    string.to_s.
+      gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+
+  module_function :snakeify
+end

data/lib/typist/version.rb

@@ -0,0 +1,4 @@
+# This file holds version information for the gem.
+module Typist
+  VERSION = '0.0.1'
+end

data/lib/typist.rb

@@ -0,0 +1,16 @@
+# This is the top level module for the gem, used as a namespace and as a
+# location for high-level functions.
+module Typist
+  autoload :Constructor, 'typist/constructor'
+  autoload :Data, 'typist/data'
+  autoload :Error, 'typist/error'
+  autoload :Func, 'typist/func'
+  autoload :Util, 'typist/util'
+
+  # Define a new data type.
+  def data(*args, &block)
+    Data.new(*args, &block).define!(self.is_a?(Module) ? self : Kernel)
+  end
+
+  module_function :data
+end

data/spec/lib/typist/constructor_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Typist::Constructor do
+  describe '#initialize' do
+    subject { described_class.new(:Node, :value, :left, :right) }
+
+    it 'sets the @name instance variable' do
+      subject.name.should == :Node
+    end
+
+    it 'sets the @vars instance variable' do
+      subject.vars.should == [:value, :left, :right]
+    end
+  end
+
+  describe '#get_class' do
+    subject { described_class.new(:Leaf) }
+
+    it 'returns a Class' do
+      subject.get_class.should be_a Class
+    end
+  end
+
+  describe '#define!' do
+    subject { Typist::Constructor.new(:TestClass, :arg1, :arg2) }
+    let(:mod) { Module.new }
+
+    before { subject.define!(mod) }
+
+    describe 'the defined class' do
+      let(:instance) {
+        mod::TestClass.new(:arg1 => ?a, :arg2 => ?b, :arg3 => ?c)
+      }
+
+      it 'has each @var as an accessor' do
+        instance.should respond_to(:arg1)
+        instance.should respond_to(:arg2)
+        instance.should_not respond_to(:arg3)
+      end
+
+      it 'accepts a hash in its initializer which sets instance variables' do
+        instance.instance_variable_get(:@arg1).should == ?a
+        instance.instance_variable_get(:@arg2).should == ?b
+        instance.instance_variable_get(:@arg3).should == ?c
+      end
+
+      it 'includes the given module' do
+        subject.get_class.ancestors.should include(mod)
+      end
+    end
+
+    describe 'the given module' do
+      let(:instance) { mod.test_class(:arg1 => 1, :arg2 => 2) }
+
+      it 'defines a method to create an instance of the defined class' do
+        instance.should be_a mod::TestClass
+        instance.arg1.should == 1
+        instance.arg2.should == 2
+      end
+    end
+  end
+end

data/spec/lib/typist/data_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe Typist::Data do
+  describe '#initialize' do
+    context 'when no block is given' do
+      subject { described_class.new(:Test) }
+
+      it 'sets the @name' do
+        subject.name.should == :Test
+      end
+
+      it 'sets the @constructors to []' do
+        subject.constructors.should be_empty
+      end
+
+      it 'sets the @funcs to []' do
+        subject.funcs.should be_empty
+      end
+    end
+
+    context 'when a block is given' do
+      subject {
+        described_class.new(:Test) do
+          instance_variable_set(:@test_var, true)
+        end
+      }
+    end
+  end
+
+  describe '#constructor' do
+    subject { described_class.new(:BinaryTree) }
+
+    it 'adds a constructor' do
+      expect { subject.constructor(:Leaf) }
+        .to change { subject.constructors.length }.by(1)
+
+      subject.constructors.should be_all { |constructor|
+        constructor.is_a?(Typist::Constructor)
+      }
+    end
+  end
+
+  describe '#func' do
+    subject { described_class.new(:Trie) }
+
+    it 'adds a constructor' do
+      expect { subject.func(:empty) }
+        .to change { subject.funcs.length }.by(1)
+
+      subject.funcs.should be_all { |funcs|
+        funcs.is_a?(Typist::Func)
+      }
+    end
+  end
+
+  describe '#get_module' do
+    subject { described_class.new(:Set) }
+
+    it 'returns a module' do
+      subject.get_module.should be_a(Module)
+    end
+  end
+
+  describe '#define!' do
+    subject! {
+      defined?(Tree) ? Tree : Typist::Data.new(:Tree) do
+        constructor :Leaf
+        constructor :Node, :value, :left, :right
+
+        func :empty? do
+          match(Tree::Leaf) { true }
+          match(Tree::Node) { false }
+        end
+
+        func :size do
+          match(Tree::Leaf) { 0 }
+          match(Tree::Node) { (left.size + right.size).succ }
+        end
+
+        func :contains? do
+          match(Tree::Leaf) { |_| false }
+
+          match(Tree::Node) do |element|
+            case value <=> element
+            when -1
+              left.contains?(value)
+            when 1
+              right.contains?(value)
+            else
+              true
+            end
+          end
+        end
+
+        func :== do
+          match(Tree::Leaf) { |tree| tree.is_a?(Tree::Leaf) }
+          match(Tree::Node) do |tree|
+            [
+              tree.is_a?(Tree::Node),
+              value == tree.value,
+              left == tree.left,
+              right == tree.right
+            ].all?
+          end
+        end
+      end.tap(&:define!)
+    }
+
+    let(:leaf) { Tree.leaf }
+    let(:node) {
+      Tree.node(
+        :value => 4,
+        :left => Tree.leaf,
+        :right => Tree.leaf
+      )
+    }
+
+    it 'defines convenience methods' do
+      Tree.should respond_to(:node)
+      Tree.should respond_to(:leaf)
+    end
+
+    it 'defines each constructor' do
+      Tree::Node.should include(Tree)
+      Tree::Leaf.should include(Tree)
+
+      node.value.should == 4
+      node.left.should == Tree.leaf
+      node.right.should == Tree.leaf
+    end
+
+    it 'defines functions on the constructors' do
+      leaf.should be_empty
+      node.should_not be_empty
+
+      leaf.contains?(4).should be_false
+      node.contains?(4).should be_true
+      node.contains?(5).should be_false
+
+      leaf.size.should == 0
+      node.size.should == 1
+    end
+  end
+end

data/spec/lib/typist/func_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Typist::Func do
+  describe '#initialize' do
+    context 'when there is no block' do
+      subject { described_class.new(:a_function) }
+
+      it 'sets the @name instance variable to the first argument' do
+        subject.name.should == :a_function
+      end
+
+      it 'has no matches intially' do
+        subject.matches.should be_empty
+      end
+    end
+
+    context 'when there is a block' do
+      subject {
+        Typist::Func.new(:this_function) do
+          @test_var = 15
+        end
+      }
+    end
+  end
+
+  describe '#match' do
+    subject { described_class.new(:test_func) }
+
+    before { subject.match(Fixnum) { :it_works } }
+
+    it 'adds that to the @matches hash' do
+      subject.matches[Fixnum].call.should == :it_works
+    end
+  end
+
+  describe '#define!' do
+
+    context 'when an invalid class is matched against' do
+      subject {
+        module BaseModule; end
+
+        class TestClass; end
+
+        Typist::Func.new(:alpha) do
+          match(TestClass) { puts 'This should not happen!' }
+        end
+      }
+
+      it 'raises a MatchError' do
+        expect { subject.define!(BaseModule) }
+          .to raise_error(Typist::Error::MatchError)
+      end
+    end
+
+    context 'when only valid subclasses are matched against' do
+      subject {
+        module BaseModule; end
+
+        class Matches; include BaseModule; end
+        class DoesNotMatch; include BaseModule; end
+
+        Typist::Func.new(:alpha) do
+          match(Matches) { 'qt3.14' }
+        end
+      }
+
+      before { subject.define!(BaseModule) }
+
+      context 'when a subclass does not match against this function' do
+        it 'raises a PatternError' do
+          expect { DoesNotMatch.new.alpha }
+            .to raise_error(Typist::Error::PatternError)
+        end
+      end
+
+      context 'when a subclass does match against the function' do
+        it 'evaluates its match' do
+          Matches.new.alpha.should == 'qt3.14'
+        end
+      end
+    end
+  end
+end

data/spec/lib/typist/util_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Typist::Util do
+  subject { Typist::Util }
+
+  describe '#snakeify' do
+    let(:hash) {
+      {
+        'ThisString' => 'this_string',
+        'thatString' => 'that_string',
+        'HeLlO' => 'he_ll_o'
+      }
+    }
+
+    it 'converts CamelCase Strings to snake_case' do
+      hash.each { |camel, snake| subject.snakeify(camel).should == snake }
+    end
+  end
+end

data/spec/lib/typist_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Typist do
+  it { should be_a Module }
+
+  describe '#data' do
+    before do
+      extend Typist
+
+      data :Boolean do
+        constructor :True
+        constructor :False
+
+        func :to_i do
+          match(Boolean::False) { 0 }
+          match(Boolean::True) { 1 }
+        end
+      end
+    end
+
+    it 'defines a data type' do
+      Boolean.should be_a Module
+
+      Boolean.false.should be_a Boolean::False
+      Boolean.true.should be_a Boolean::True
+
+      Boolean.false.to_i.should == 0
+      Boolean.true.to_i.should == 1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rspec'
+require 'typist'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.color_enabled = true
+  config.formatter = :documentation
+  config.tty = true
+end

data/typist.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/typist/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Tom Hulihan']
+  gem.email         = %w{hulihan.tom159@gmail.com}
+  gem.description   = %q{Algebraic data types for Ruby}
+  gem.summary       = %q{Algebraic data types for Ruby}
+  gem.homepage      = 'https://github.com/nahiluhmot/typist'
+  gem.license       = 'MIT'
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = 'typist'
+  gem.require_paths = %w{lib}
+  gem.version       = Typist::VERSION
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'cane'
+  gem.add_development_dependency 'pry'
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: typist
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tom Hulihan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-21 00:00:00.000000000 Z
+dependencies:
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cane
+  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: pry
+  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'
+description: Algebraic data types for Ruby
+email:
+- hulihan.tom159@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/typist.rb
+- lib/typist/constructor.rb
+- lib/typist/data.rb
+- lib/typist/error.rb
+- lib/typist/func.rb
+- lib/typist/util.rb
+- lib/typist/version.rb
+- spec/lib/typist/constructor_spec.rb
+- spec/lib/typist/data_spec.rb
+- spec/lib/typist/func_spec.rb
+- spec/lib/typist/util_spec.rb
+- spec/lib/typist_spec.rb
+- spec/spec_helper.rb
+- typist.gemspec
+homepage: https://github.com/nahiluhmot/typist
+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.0
+signing_key: 
+specification_version: 4
+summary: Algebraic data types for Ruby
+test_files:
+- spec/lib/typist/constructor_spec.rb
+- spec/lib/typist/data_spec.rb
+- spec/lib/typist/func_spec.rb
+- spec/lib/typist/util_spec.rb
+- spec/lib/typist_spec.rb
+- spec/spec_helper.rb