8000 GitHub - nahiluhmot/typist: Algebraically-defined Data Types (ADTs) for Ruby · GitHub
[go: up one dir, main page]

Skip to content
nahiluhmotPublic

About

Algebraically-defined Data Types (ADTs) for Ruby

Resources

Stars

2 stars

Watchers

2 watching

Forks

Latest commit

 

History

20 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

typist

Gem Version Build Status Code Climate

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.

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:

$ gem install typist

From a Gemfile:

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:

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:

module Test
  extend Typist

  data :Tree do
    ...
  end
end

Type constructors may be defined using the constructor function.

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).

The DSL also 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:

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.

Finally, you can define "class methods" upon the data type using the data_func function. For example:

module Test
  extend Typist

  data :Tree do
    constructor :Leaf
    constructor :Node, :value, :left, :right

    data_func :singleton do |value|
      Tree.node(:value => value, :left => Tree.leaf, :right => Tree.leaf)
    end

    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

Example usage:

leaf = Test::Tree.leaf
node = Test::Tree.singleton('a')

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

About

Algebraically-defined Data Types (ADTs) for Ruby

Resources

Stars

2 stars

Watchers

2 watching

Forks

Releases

Packages

Used by

Contributors

Languages

0