mal 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 460e0eb3883bf8c602f014845e5b878d8e07abbc
+  data.tar.gz: 52f32e1f129c60b75edfe5f4e4b8b2f979895e00
+SHA512:
+  metadata.gz: 453e66b57683c0afc28c7a5ec1a28ae721208d4e113701e685cfc2e475c03e9edca0a06c27d95e949a9912172a6060b05aaca89d9116c64f07e4e6d12d20b9b9
+  data.tar.gz: cbfeb3a92260eeeb93639471b86e83b18efbd2f7da9f532b866f850cd6ab53446c0eaa3f830bb483b499781cf48cea74f7b1a3e22c8e4c7d82fb9bf2316b00db

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

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

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+group :development do
+  gem 'rack', '~> 1'
+  gem "rspec", "~> 3.2"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 2.0.1"
+  gem "simplecov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2016 Julik Tarkhanov
+
+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,46 @@
+# mal
+
+Minuscule (Type) Algerba - a type-matching thing for Ruby.
+
+The library allows you to do simple type matching based on _any_ Ruby types that support the "triqual"
+operator (type equality). It is distantly related to libraries like rb_dry_types
+
+A basic building block for these checks can be any object that supports `===`.
+For example, to verify that a certain variable is either a String or a Numeric
+
+    Mal.Either(Numeric, String) === "ohai" # => true
+    Mal.Either(Numeric, String) === false  # => false
+
+Where this gets interesting is when you use combinations and unions. For instance, you can check if an
+Array only contains booleans:
+
+    Mal.ArrayOf(Mal.Either(true, false)) === [true, false, false] #=> true
+
+You can also match Hashes, which lends itself to JSON assertions quite nicely:
+
+    Mal.HashOf(name: String, age: Numeric) === {name: 'Jane', age: 22, accepted_license_agreement: true} #=> true
+
+You can also use these type matchers for case statements:
+
+    case fetch_api_response
+    when Mal.HashWith(error: Mal.Anything())
+      raise ...
+    when Mal.HashWith(inserted: Mal.Boolean())
+      # insert successful
+    end
+
+## Contributing to mal
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2016 Julik Tarkhanov. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+require_relative 'lib/mal'
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.version = Mal::VERSION
+  gem.name = "mal"
+  gem.homepage = "http://github.com/julik/mal"
+  gem.license = "MIT"
+  gem.summary = 'Minuscule algebraic types for Ruby'
+  gem.description = 'Minuscule algebraic types for Ruby'
+  gem.email = "me@julik.nl"
+  gem.authors = ["Julik Tarkhanov"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['spec'].execute
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "mal #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/mal.rb

@@ -0,0 +1,215 @@
+module Mal
+  VERSION = '0.0.1'
+  
+  class AnythingT
+    def ===(value)
+      true
+    end
+    def inspect
+      'Anything()'
+    end
+  end
+
+  class OnlyT
+    def initialize(matchable)
+      @matchable = matchable
+    end
+
+    def ===(value)
+      @matchable === value
+    end
+
+    def inspect
+      'Only(%s)' % @matchable.inspect
+    end
+  end
+
+  class NilT < OnlyT
+    def inspect; 'Nil()'; end
+  end
+
+  class HashT
+    def initialize(**required_keys_to_matchers)
+      @required_keys_to_matchers = required_keys_to_matchers
+    end
+  
+    def ===(value)
+      return false unless value.is_a?(Hash)
+      @required_keys_to_matchers.each_pair do |k,value_matcher|
+        return false unless value.key? k
+        return false unless value_matcher === value[k]
+      end
+      true
+    end
+
+    def inspect
+      'HashWith(%s)' % @required_keys_to_matchers.inspect[1..-2]
+    end
+  end
+  
+  class HashOfOnlyT < HashT
+    def ===(value)
+      return false unless super
+      @required_keys_to_matchers.keys == value.keys
+    end
+    
+    def inspect
+      'HashOf(%s)' % @required_keys_to_matchers.inspect[1..-2]
+    end
+  end
+  
+  class ArrayT < OnlyT
+    def initialize(matcher_for_each_array_element)
+      @matcher_for_each_array_element = matcher_for_each_array_element
+    end
+  
+    def ===(value)
+      return false unless Array === value
+      return false unless value.any?
+      value.each do |value_element|
+        return false unless @matcher_for_each_array_element === value_element
+      end
+      true
+    end
+  
+    def inspect
+      'ArrayOf(%s)' % @matcher_for_each_array_element.inspect
+    end
+  end
+
+  class LengthT < OnlyT
+    def initialize(desired_length)
+      @desired_length = length
+    end
+    
+    def ===(value)
+      return false unless value.respond_to? :length
+      @desired_length == value.length
+    end
+  end
+
+  class MinLengthT < LengthT
+    def ===(value)
+      return false unless value.respond_to? :length
+      @desired_length >= value.length
+    end
+    def inspect; 'OfAtLeastElements(%d)' % @desired_length; end
+  end
+
+  class MaxLengthT < LengthT
+    def ===(value)
+      return false unless value.respond_to? :length
+      @desired_length <= value.length
+    end
+    def inspect; 'OfAtMostElements(%d)' % @desired_length; end
+  end
+
+  class EitherT < OnlyT
+    def initialize(*types)
+      @types = types
+    end
+  
+    def ===(value)
+      @types.any? {|type| type === value }
+    end
+  
+    def inspect
+      'Either(%s)' % @types.map{|e| e.inspect }.join(', ')
+    end
+  end
+
+  class UnionT < OnlyT
+    def initialize(*types)
+      @types = types
+    end
+  
+    def ===(value)
+      @types.all? {|type| type === value}
+    end
+  
+    def inspect
+      'Both(%s)' % @types.map{|e| e.inspect }.join(', ')
+    end
+  end
+
+  class MaybeT < EitherT
+    def inspect; 'Maybe(%s)' % @types[1].inspect; end
+  end
+  
+  class BoolT < EitherT
+    def initialize; super(TrueClass, FalseClass); end
+    def inspect; 'Bool()'; end
+  end
+  
+  private_constant :NilT, :BoolT, :EitherT, :MaybeT, :ArrayT, :HashT, :BoolT, :HashOfOnlyT, :MaxLengthT, :MinLengthT
+  
+  # Specifies a value that may only ever be `nil` and nothing else
+  def Nil()
+    NilT.new(NilClass)
+  end
+
+  # Specifies a value that is either `true` or `false` (truthy or falsy values do not work)
+  def Bool()
+    BoolT.new
+  end
+
+  # Specifies a value that matches only the given matcher
+  def Only(matchable)
+    OnlyT.new(matchable)
+  end
+
+  # Specifies a value that matches both the given matchers. For instance,
+  # can be a matcher for both a String and a Regexp
+  def Both(*matchables)
+    UnionT.new(*matchables)
+  end
+  
+  # Specifies a value that matches either one of the given speciciers
+  def Either(*matchables)
+    EitherT.new(*matchables)
+  end
+
+  # Specifies a value that is either matching the given typespec, or is nil
+  def Maybe(matchable)
+    MaybeT.new(NilClass, matchable)
+  end
+
+  # Specifies an Array of at least 1 element, where each element matches the
+  # typespec for the array element 
+  def ArrayOf(typespec_for_array_element)
+    ArrayT.new(typespec_for_array_element)
+  end
+
+  # Specifies a Hash containing at least the given keys, with values at those
+  # keys matching the given matchers. For example, for a Hash having at
+  # least the `:name` key with a corresponding value that is a String:
+  #   HashOf(name: String)
+  # Since the match is non-strict, it will also match a Hash having more keys
+  #   HashOf(name: String) === {name: 'John Doe', age: 21} #=> true
+  def HashWith(**keys_to_values)
+    HashT.new(**keys_to_values)
+  end
+  
+  def OfAtLeastElements(n)
+    MinLengthT.new(n)
+  end
+
+  def OfAtMostElements(n)
+    MaxLengthT.new(n)
+  end
+  
+  # Specifies a Hash containing only the given keys, with values at those
+  # keys matching the given matchers. For example, for a Hash having at
+  # the `:name` key with a corresponding value that is a String:
+  #
+  #   HashOfOnly(name: String)
+  #
+  # Because the match is-strict, it will not match a Hash having additional keys
+  #
+  #   HashOf(name: String) === {name: 'John Doe', age: 21} #=> false
+  def HashOf(**keys_to_values)
+    HashOfOnlyT.new(**keys_to_values)
+  end
+  
+  extend self
+end

data/mal.gemspec

@@ -0,0 +1,62 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: mal 0.0.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "mal"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Julik Tarkhanov"]
+  s.date = "2016-09-16"
+  s.description = "Minuscule algebraic types for Ruby"
+  s.email = "me@julik.nl"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "lib/mal.rb",
+    "mal.gemspec",
+    "spec/mal_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/julik/mal"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.5.1"
+  s.summary = "Minuscule algebraic types for Ruby"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rack>, ["~> 1"])
+      s.add_development_dependency(%q<rspec>, ["~> 3.2"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+    else
+      s.add_dependency(%q<rack>, ["~> 1"])
+      s.add_dependency(%q<rspec>, ["~> 3.2"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rack>, ["~> 1"])
+    s.add_dependency(%q<rspec>, ["~> 3.2"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+  end
+end
+

data/spec/mal_spec.rb

@@ -0,0 +1,221 @@
+require_relative 'spec_helper'
+
+describe 'Mal' do
+  include Mal
+  
+  def expect_match_of(typespec, value)
+    match_v = typespec === value
+    expect(match_v).to eq(true), "Expected #{value.inspect} to match #{typespec.inspect}"
+  end
+
+  def expect_no_match_of(typespec, value)
+    match_v = typespec === value
+    expect(match_v).to eq(false), "Expected #{value.inspect} not to match #{typespec.inspect}"
+  end
+
+  describe 'Nil()' do
+    it 'provides a good inspect' do
+      expect(Nil().inspect).to eq('Nil()')
+    end
+    
+    it 'matches nil only' do
+      expect_match_of(Nil(), nil)
+      expect_no_match_of(Nil(), 0)
+      expect_no_match_of(Nil(), Object.new)
+      expect_no_match_of(Nil(), self)
+    end
+  end
+
+  describe 'Bool()' do
+    it 'provides a good inspect' do
+      expect(Bool().inspect).to eq('Bool()')
+    end
+    
+    it 'matches only true and false' do
+      expect_match_of(Bool(), true)
+      expect_match_of(Bool(), false)
+      expect_no_match_of(Bool(), nil)
+      expect_no_match_of(Bool(), self)
+      expect_no_match_of(Bool(), 'hello world')
+      expect_no_match_of(Bool(), 123)
+    end
+  end
+  
+  describe 'Either()' do
+    it 'provides a good inspect' do
+      expect(Either(String, Hash).inspect).to eq('Either(String, Hash)')
+    end
+
+    it 'matches either of given' do
+      m = Either(String, TrueClass)
+      expect_match_of(m, 'hello world')
+      expect_match_of(m, true)
+      expect_no_match_of(m, false)
+      expect_no_match_of(m, nil)
+      expect_no_match_of(m, self)
+    end
+  end
+
+  describe 'Maybe()' do
+    it 'provides a good inspect' do
+      expect(Maybe(String).inspect).to eq('Maybe(String)')
+    end
+
+    it 'matches a nil or a given type' do
+      m = Maybe(String)
+      expect_match_of(m, nil)
+      expect_match_of(m, 'foo')
+      expect_no_match_of(m, false)
+      expect_no_match_of(m, self)
+    end
+  end
+  
+  describe 'ArrayOf()' do
+    it 'provides a good inspect' do
+      expect(ArrayOf(Maybe(Fixnum)).inspect).to eq('ArrayOf(Maybe(Fixnum))')
+    end
+    
+    it 'does not match objects of other types' do
+      expect_no_match_of(ArrayOf(TrueClass), nil)
+      expect_no_match_of(ArrayOf(TrueClass), false)
+      expect_no_match_of(ArrayOf(TrueClass), self)
+      expect_no_match_of(ArrayOf(TrueClass), 123)
+    end
+    
+    it 'does not match an empty Array' do
+      expect_no_match_of(ArrayOf(TrueClass), [])
+    end
+    
+    it 'matches an Array containing objects of matching types' do
+      m = ArrayOf(Fixnum)
+      expect_no_match_of(m, [true, false, 1, 'foo'])
+      expect_match_of(m, [1, 78451, 546])
+    end
+    
+    it 'matches an Array of elements parametrized via union types' do
+      m = ArrayOf(Either(Fixnum, Bool()))
+      expect_no_match_of(m, [true, false, 1, 'foo'])
+      expect_match_of(m, [true, false, 1])
+    end
+  end
+
+  describe 'Both()' do
+    it 'provides a good inspect' do
+      m = Both(String, /abc/)
+      expect(m.inspect).to eq("Both(String, /abc/)")
+    end
+
+    it 'provides matching against all the elements' do
+      m = Both(String, /abc/)
+      expect_match_of(m, 'this is an abc string')
+      expect_no_match_of(m, 'this is a string that does match the second parameter')
+    end
+  end
+
+  describe 'HashWith()' do
+    it 'provides a good inspect' do
+      m = HashWith(foo: Maybe(Fixnum))
+      expect(m.inspect).to eq("HashWith(:foo=>Maybe(Fixnum))")
+    end
+    
+    it 'does not match other types' do
+      m = HashWith(foo: Symbol)
+      expect_no_match_of(m, nil)
+      expect_no_match_of(m, [])
+      expect_no_match_of(m, self)
+    end
+    
+    it 'does match an empty Hash when asked to' do
+      m = HashWith({})
+      expect_match_of(m, {})
+    end
+    
+    it 'does not match a Hash whose value does not satisfy the matcher' do
+      m = HashWith(some_key: Nil())
+      expect_no_match_of(m, {some_key: true})
+    end
+    
+    it 'does match a Hash whose keys/values do satisfy the matcher' do
+      m = HashWith(some_key: Maybe(String))
+      expect_match_of(m, {some_key: nil})
+      expect_match_of(m, {some_key: 'hello world'})
+    end
+
+    it 'does match a Hash that has more keys than requested' do
+      m = HashWith(name: String)
+      expect_match_of(m, {name: 'John Doe', age: 21})
+    end
+  end
+  
+  describe 'HashOf()' do
+    it 'provides a good inspect' do
+      m = HashOf(foo: Maybe(Fixnum))
+      expect(m.inspect).to eq("HashOf(:foo=>Maybe(Fixnum))")
+    end
+    
+    it 'does not match other types' do
+      m = HashOf(foo: Symbol)
+      expect_no_match_of(m, nil)
+      expect_no_match_of(m, [])
+      expect_no_match_of(m, self)
+    end
+    
+    it 'does match an empty Hash when asked to' do
+      m = HashOf({})
+      expect_match_of(m, {})
+    end
+    
+    it 'does not match a Hash whose value does not satisfy the matcher' do
+      m = HashOf(some_key: Nil())
+      expect_no_match_of(m, {some_key: true})
+    end
+    
+    it 'does match a Hash whose keys/values do satisfy the matcher' do
+      m = HashOf(some_key: Maybe(String))
+      expect_match_of(m, {some_key: nil})
+      expect_match_of(m, {some_key: 'hello world'})
+    end
+
+    it 'does not match a Hash that has more keys than requested' do
+      m = HashOf(name: String)
+      expect_no_match_of(m, {name: 'John Doe', age: 21})
+    end
+  end
+  
+  describe 'HashOf with complex nested matchers' do
+    it 'matches the User response' do
+      m = Mal::HashWith(
+        user: Mal::HashWith(
+          active_subscription: Mal::Bool(),
+          profile_picture_url: Mal::Maybe(String),
+          full_name: String,
+          id: Integer
+        )
+      )
+      
+      expect_match_of(m, {user: {
+        id: 123, 
+        active_subscription: true,
+        profile_picture_url: 'http://url.com',
+        full_name: 'John Doe',
+      }})
+      
+      expect_match_of(m, {user: {
+        id: 123, 
+        interests: ['Fishing', 'Hiking'],
+        active_subscription: true,
+        profile_picture_url: 'http://url.com',
+        full_name: 'John Doe',
+      }})
+      
+      expect_no_match_of(m, {user: {
+        # skip the "id" field and let the matcher fail
+        interests: ['Fishing', 'Hiking'],
+        active_subscription: true,
+        profile_picture_url: 'http://url.com',
+        full_name: 'John Doe',
+      }})
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rspec'
+
+RSpec.configure do |config|
+  config.order = 'random'
+end
+
+require 'simplecov'
+SimpleCov.start
+require_relative '../lib/mal'

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: mal
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Julik Tarkhanov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: Minuscule algebraic types for Ruby
+email: me@julik.nl
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mal.rb
+- mal.gemspec
+- spec/mal_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/julik/mal
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Minuscule algebraic types for Ruby
+test_files: []