mprelude 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 19538ca2618de1e9e66da6b29c8e173ba3d1ce1e967ccaa7f87c71685f7c1e13
+  data.tar.gz: 83f2a0ae363a6227f7da56dc6e399e330a15a4eb74ca4acb6c0c1ec971db07d2
+SHA512:
+  metadata.gz: d166a903c908906e55f62e50d4fc7a3863bed413ddd15c55b923330009069b5080d9d459b14981ca5a70ead7a34e7567d81d33cc6f000b4d8e2c2b74770fe1a1
+  data.tar.gz: b11d18eac0aad4eb2a14b6d5c22c8e201b27b41769df771cd9b71ad155ad57ff4dbb14f35cc946b8724b520c9f34f0a2f4ecadd1e64dbb4b99dcff525c3171e9

data/.rspec

@@ -0,0 +1,5 @@
+--color
+--format progress
+--order random
+--require spec_helper
+--warnings

data/Gemfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'mutant',       '~> 0.8.24'
+  gem 'mutant-rspec', '~> 0.8.24'
+end
+
+gem(
+  'devtools',
+  git: 'https://github.com/mbj/devtools.git',
+  ref: '26ba0a1053e6cf7b79fc72d513a73457f9a38ead'
+)

data/Gemfile.lock

@@ -0,0 +1,184 @@
+GIT
+  remote: https://github.com/mbj/devtools.git
+  revision: 26ba0a1053e6cf7b79fc72d513a73457f9a38ead
+  ref: 26ba0a1053e6cf7b79fc72d513a73457f9a38ead
+  specs:
+    devtools (0.1.23)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      anima (~> 0.3.0)
+      concord (~> 0.1.5)
+      flay (~> 2.12.0)
+      flog (~> 4.6.2)
+      procto (~> 0.0.3)
+      rake (~> 12.3.0)
+      reek (~> 5.3.0)
+      rspec (~> 3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-its (~> 1.2.0)
+      rubocop (~> 0.61.1)
+      simplecov (~> 0.16.1)
+      yard (~> 0.9.16)
+      yardstick (~> 0.9.9)
+
+PATH
+  remote: .
+  specs:
+    mprelude (0.0.1)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      concord (~> 0.1.5)
+      equalizer (~> 0.0.9)
+      ice_nine (~> 0.11.1)
+      procto (~> 0.0.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    abstract_type (0.0.7)
+    adamantium (0.2.0)
+      ice_nine (~> 0.11.0)
+      memoizable (~> 0.4.0)
+    anima (0.3.1)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2)
+      equalizer (~> 0.0.11)
+    ast (2.4.0)
+    axiom-types (0.1.1)
+      descendants_tracker (~> 0.0.4)
+      ice_nine (~> 0.11.0)
+      thread_safe (~> 0.3, >= 0.3.1)
+    codeclimate-engine-rb (0.4.1)
+      virtus (~> 1.0)
+    coercible (1.0.0)
+      descendants_tracker (~> 0.0.1)
+    concord (0.1.5)
+      adamantium (~> 0.2.0)
+      equalizer (~> 0.0.9)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    diff-lcs (1.3)
+    docile (1.3.2)
+    equalizer (0.0.11)
+    erubis (2.7.0)
+    flay (2.12.0)
+      erubis (~> 2.7.0)
+      path_expander (~> 1.0)
+      ruby_parser (~> 3.0)
+      sexp_processor (~> 4.0)
+    flog (4.6.2)
+      path_expander (~> 1.0)
+      ruby_parser (~> 3.1, > 3.1.0)
+      sexp_processor (~> 4.8)
+    ice_nine (0.11.2)
+    jaro_winkler (1.5.3)
+    json (2.2.0)
+    kwalify (0.7.2)
+    memoizable (0.4.2)
+      thread_safe (~> 0.3, >= 0.3.1)
+    morpher (0.2.6)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      anima (~> 0.3.0)
+      ast (~> 2.2)
+      concord (~> 0.1.5)
+      equalizer (~> 0.0.9)
+      ice_nine (~> 0.11.0)
+      procto (~> 0.0.2)
+    mutant (0.8.24)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      anima (~> 0.3.0)
+      ast (~> 2.2)
+      concord (~> 0.1.5)
+      diff-lcs (~> 1.3)
+      equalizer (~> 0.0.9)
+      ice_nine (~> 0.11.1)
+      memoizable (~> 0.4.2)
+      morpher (~> 0.2.6)
+      parser (~> 2.5.1)
+      procto (~> 0.0.2)
+      regexp_parser (~> 1.2)
+      unparser (~> 0.4.2)
+    mutant-rspec (0.8.24)
+      mutant (~> 0.8.24)
+      rspec-core (>= 3.4.0, < 4.0.0)
+    parallel (1.17.0)
+    parser (2.5.3.0)
+      ast (~> 2.4.0)
+    path_expander (1.0.4)
+    powerpack (0.1.2)
+    procto (0.0.3)
+    psych (3.1.0)
+    rainbow (3.0.0)
+    rake (12.3.3)
+    reek (5.3.2)
+      codeclimate-engine-rb (~> 0.4.0)
+      kwalify (~> 0.7.0)
+      parser (>= 2.5.0.0, < 2.7, != 2.5.1.1)
+      psych (~> 3.1.0)
+      rainbow (>= 2.0, < 4.0)
+    regexp_parser (1.6.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.2)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-its (1.2.0)
+      rspec-core (>= 3.0.0)
+      rspec-expectations (>= 3.0.0)
+    rspec-mocks (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.2)
+    rubocop (0.61.1)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.5, != 2.5.1.1)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.4.0)
+    ruby-progressbar (1.10.1)
+    ruby_parser (3.13.1)
+      sexp_processor (~> 4.9)
+    sexp_processor (4.12.1)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    thread_safe (0.3.6)
+    unicode-display_width (1.4.1)
+    unparser (0.4.2)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      concord (~> 0.1.5)
+      diff-lcs (~> 1.3)
+      equalizer (~> 0.0.9)
+      parser (>= 2.3.1.2, < 2.6)
+      procto (~> 0.0.2)
+    virtus (1.0.5)
+      axiom-types (~> 0.1)
+      coercible (~> 1.0)
+      descendants_tracker (~> 0.0, >= 0.0.3)
+      equalizer (~> 0.0, >= 0.0.9)
+    yard (0.9.20)
+    yardstick (0.9.9)
+      yard (~> 0.8, >= 0.8.7.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  devtools!
+  mprelude!
+  mutant (~> 0.8.24)
+  mutant-rspec (~> 0.8.24)
+
+BUNDLED WITH
+   2.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Markus Schirp
+
+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,3 @@
+# mprelude
+
+Some foundational ruby data types.

data/lib/mprelude.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'abstract_type'
+require 'adamantium'
+require 'concord'
+
+module MPrelude
+  module Functor
+    include AbstractType
+
+    abstract_method :fmap
+
+  private
+
+    # Raise error unless block is provided
+    #
+    # @raise [MissingBlockError]
+    #   if no block is given
+    #
+    # @return [self]
+    def require_block
+      fail LocalJumpError unless block_given?
+      self
+    end
+  end # Functor
+
+  class Maybe
+    include(
+      AbstractType,
+      Adamantium::Flat,
+      Functor
+    )
+
+    class Nothing < self
+      instance = new
+
+      define_method(:new) { instance }
+
+      # Evaluate functor block
+      #
+      # @return [Maybe::Nothing]
+      def fmap(&block)
+        require_block(&block)
+      end
+
+      # Evaluate applicative block
+      #
+      # @return [Maybe::Nothing]
+      def apply(&block)
+        require_block(&block)
+      end
+    end # Nothing
+
+    class Just < self
+      include Concord.new(:value)
+
+      # Evalute functor block
+      #
+      # @return [Maybe::Just<Object>]
+      def fmap
+        Just.new(yield(value))
+      end
+
+      # Evalute applicative block
+      #
+      # @return [Maybe]
+      def apply
+        yield(value)
+      end
+    end # Just
+  end # Maybe
+
+  class Either
+    include(
+      AbstractType,
+      Adamantium::Flat,
+      Concord.new(:value),
+      Functor
+    )
+
+    # Execute block and wrap error in left
+    #
+    # @param [Class:Exception] error
+    #
+    # @return [Either<Exception, Object>]
+    def self.wrap_error(error)
+      Right.new(yield)
+    rescue error => exception
+      Left.new(exception)
+    end
+
+    class Left < self
+      # Evaluate functor block
+      #
+      # @return [Either::Left<Object>]
+      def fmap(&block)
+        require_block(&block)
+      end
+
+      # Evaluate applicative block
+      #
+      # @return [Either::Left<Object>]
+      def apply(&block)
+        require_block(&block)
+      end
+
+      # Unwrap value from left
+      #
+      # @return [Object]
+      def from_left
+        value
+      end
+
+      # Unwrap value from right
+      #
+      # @return [Object]
+      #
+      # rubocop:disable Style/GuardClause
+      def from_right
+        if block_given?
+          yield(value)
+        else
+          fail "Expected right value, got #{inspect}"
+        end
+      end
+      # rubocop:enable Style/GuardClause
+
+      # Map over left value
+      #
+      # @return [Either::Right<Object>]
+      def lmap
+        Left.new(yield(value))
+      end
+
+      # Evaluate left side of branch
+      #
+      # @param [#call] left
+      # @param [#call] _right
+      def either(left, _right)
+        left.call(value)
+      end
+    end # Left
+
+    class Right < self
+      # Evaluate functor block
+      #
+      # @return [Either::Right<Object>]
+      def fmap
+        Right.new(yield(value))
+      end
+
+      # Evaluate applicative block
+      #
+      # @return [Either<Object>]
+      def apply
+        yield(value)
+      end
+
+      # Unwrap value from left
+      #
+      # @return [Object]
+      #
+      # rubocop:disable Style/GuardClause
+      def from_left
+        if block_given?
+          yield(value)
+        else
+          fail "Expected left value, got #{inspect}"
+        end
+      end
+      # rubocop:enable Style/GuardClause
+
+      # Unwrap value from right
+      #
+      # @return [Object]
+      def from_right
+        value
+      end
+
+      # Map over left value
+      #
+      # @return [Either::Right<Object>]
+      def lmap(&block)
+        require_block(&block)
+      end
+
+      # Evaluate right side of branch
+      #
+      # @param [#call] _left
+      # @param [#call] right
+      def either(_left, right)
+        right.call(value)
+      end
+    end # Right
+  end # Either
+end # MPrelude

data/mprelude.gemspec

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |gem|
+  gem.name        = 'mprelude'
+  gem.version     = '0.0.1'
+  gem.authors     = ['Markus Schirp']
+  gem.email       = ['mbj@schirp-dso.com']
+  gem.description = 'Minimal prelude alike classes'
+  gem.summary     = 'Mostly an either type'
+  gem.homepage    = 'https://github.com/mbj/mprelude-rb'
+  gem.licenses    = 'MIT'
+
+  gem.require_paths = %w[lib]
+
+  gem.files            = `git ls-files`.split("\n")
+  gem.test_files       = `git ls-files -- spec/unit`.split("\n")
+  gem.extra_rdoc_files = %w[LICENSE]
+
+  gem.add_runtime_dependency('abstract_type',  '~> 0.0.7')
+  gem.add_runtime_dependency('adamantium',     '~> 0.2.0')
+  gem.add_runtime_dependency('concord',        '~> 0.1.5')
+  gem.add_runtime_dependency('equalizer',      '~> 0.0.9')
+  gem.add_runtime_dependency('ice_nine',       '~> 0.11.1')
+  gem.add_runtime_dependency('procto',         '~> 0.0.2')
+end

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'mprelude'
+
+RSpec.shared_examples 'no block evaluation' do
+  context 'with block' do
+    let(:block) { -> { fail } }
+
+    it 'does not evaluate block' do
+      apply
+    end
+  end
+end
+
+RSpec.shared_examples 'requires block' do
+  context 'without block' do
+    let(:block) { nil }
+
+    specify do
+      expect { apply }.to raise_error(LocalJumpError)
+    end
+  end
+end
+
+RSpec.shared_examples 'returns self' do
+  it 'returns self' do
+    expect(apply).to be(subject)
+  end
+end
+
+RSpec.shared_examples '#apply block evaluation' do
+  it 'evaluates block and returns its wrapped result' do
+    expect { expect(apply).to eql(block_result) }
+      .to change(yields, :to_a)
+      .from([])
+      .to([value])
+  end
+end
+
+RSpec.shared_examples 'Functor#fmap block evaluation' do
+  it 'evaluates block and returns its wrapped result' do
+    expect { expect(apply).to eql(described_class.new(block_result)) }
+      .to change(yields, :to_a)
+      .from([])
+      .to([value])
+  end
+end

data/spec/unit/mprelude/either_spec.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+RSpec.describe MPrelude::Either do
+  describe '.wrap_error' do
+    def apply
+      described_class.wrap_error(error, &block)
+    end
+
+    let(:error) { TestError }
+
+    class TestError < RuntimeError; end
+
+    context 'when block returns' do
+      let(:value) { instance_double(Object, 'value') }
+      let(:block) { -> { value }                     }
+
+      it 'returns right wrapping block value' do
+        expect(apply).to eql(described_class::Right.new(value))
+      end
+    end
+
+    context 'when block raises' do
+      let(:exception) { error.new             }
+      let(:block)     { -> { fail exception } }
+
+      context 'with covered exception' do
+        it 'returns left wrapping exception' do
+          expect(apply).to eql(described_class::Left.new(exception))
+        end
+      end
+
+      context 'with uncovered exception' do
+        let(:exception) { StandardError.new }
+
+        it 'returns raises error' do
+          expect { apply }.to raise_error(StandardError)
+        end
+      end
+    end
+  end
+end
+
+RSpec.describe MPrelude::Either::Left do
+  subject { described_class.new(value) }
+
+  let(:block_result) { instance_double(Object, 'block result') }
+  let(:value)        { instance_double(Object, 'value')        }
+  let(:yields)       { []                                      }
+
+  let(:block) do
+    lambda do |value|
+      yields << value
+      block_result
+    end
+  end
+
+  class TestError < RuntimeError; end
+
+  describe '#fmap' do
+    def apply
+      subject.fmap(&block)
+    end
+
+    include_examples 'no block evaluation'
+    include_examples 'requires block'
+    include_examples 'returns self'
+  end
+
+  describe '#apply' do
+    def apply
+      subject.apply(&block)
+    end
+
+    include_examples 'no block evaluation'
+    include_examples 'requires block'
+    include_examples 'returns self'
+  end
+
+  describe '#from_left' do
+    def apply
+      subject.from_left(&block)
+    end
+
+    it 'returns left value' do
+      expect(apply).to be(value)
+    end
+
+    include_examples 'no block evaluation'
+  end
+
+  describe '#from_right' do
+    def apply
+      subject.from_right(&block)
+    end
+
+    context 'without block' do
+      let(:block) { nil }
+
+      it 'raises RuntimeError error' do
+        expect { apply }.to raise_error(
+          RuntimeError,
+          "Expected right value, got #{subject.inspect}"
+        )
+      end
+    end
+
+    context 'with block' do
+      let(:yields)       { []                                      }
+      let(:block_return) { instance_double(Object, 'block-return') }
+
+      let(:block) do
+        lambda do |value|
+          yields << value
+          block_return
+        end
+      end
+
+      it 'calls block with left value' do
+        expect { apply }.to change(yields, :to_a).from([]).to([value])
+      end
+
+      it 'returns block value' do
+        expect(apply).to be(block_return)
+      end
+    end
+  end
+
+  describe '#lmap' do
+    def apply
+      subject.lmap(&block)
+    end
+
+    include_examples 'requires block'
+    include_examples 'Functor#fmap block evaluation'
+  end
+
+  describe '#either' do
+    def apply
+      subject.either(block, -> { fail })
+    end
+
+    include_examples '#apply block evaluation'
+  end
+end
+
+RSpec.describe MPrelude::Either::Right do
+  subject { described_class.new(value) }
+
+  let(:block_result) { instance_double(Object, 'block result') }
+  let(:value)        { instance_double(Object, 'value')        }
+  let(:yields)       { []                                      }
+
+  let(:block) do
+    lambda do |value|
+      yields << value
+      block_result
+    end
+  end
+
+  describe '#fmap' do
+    def apply
+      subject.fmap(&block)
+    end
+
+    include_examples 'requires block'
+    include_examples 'Functor#fmap block evaluation'
+  end
+
+  describe '#apply' do
+    def apply
+      subject.apply(&block)
+    end
+
+    include_examples 'requires block'
+    include_examples '#apply block evaluation'
+  end
+
+  describe '#from_left' do
+    def apply
+      subject.from_left(&block)
+    end
+
+    context 'without block' do
+      let(:block) { nil }
+
+      it 'raises RuntimeError error' do
+        expect { apply }.to raise_error(
+          RuntimeError,
+          "Expected left value, got #{subject.inspect}"
+        )
+      end
+    end
+
+    context 'with block' do
+      let(:yields)       { []                                      }
+      let(:block_return) { instance_double(Object, 'block-return') }
+
+      let(:block) do
+        lambda do |value|
+          yields << value
+          block_return
+        end
+      end
+
+      it 'calls block with right value' do
+        expect { apply }.to change(yields, :to_a).from([]).to([value])
+      end
+
+      it 'returns block value' do
+        expect(apply).to be(block_return)
+      end
+    end
+  end
+
+  describe '#from_right' do
+    def apply
+      subject.from_right(&block)
+    end
+
+    it 'returns right value' do
+      expect(apply).to be(value)
+    end
+
+    include_examples 'no block evaluation'
+  end
+
+  describe '#lmap' do
+    def apply
+      subject.lmap(&block)
+    end
+
+    include_examples 'requires block'
+    include_examples 'no block evaluation'
+
+    it 'returns self' do
+      expect(apply).to be(subject)
+    end
+  end
+
+  describe '#either' do
+    def apply
+      subject.either(-> { fail }, block)
+    end
+
+    include_examples '#apply block evaluation'
+  end
+end

data/spec/unit/mprelude/maybe_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+RSpec.describe MPrelude::Maybe::Nothing do
+  subject { described_class.new }
+
+  let(:block) { -> {} }
+
+  describe '#fmap' do
+    def apply
+      subject.fmap(&block)
+    end
+
+    include_examples 'no block evaluation'
+    include_examples 'requires block'
+    include_examples 'returns self'
+  end
+
+  describe '#apply' do
+    def apply
+      subject.apply(&block)
+    end
+
+    include_examples 'no block evaluation'
+    include_examples 'requires block'
+    include_examples 'returns self'
+  end
+end
+
+RSpec.describe MPrelude::Maybe::Just do
+  subject { described_class.new(value) }
+
+  let(:block_result) { instance_double(Object, 'block result') }
+  let(:value)        { instance_double(Object, 'value')        }
+  let(:yields)       { []                                      }
+
+  let(:block) do
+    lambda do |value|
+      yields << value
+      block_result
+    end
+  end
+
+  describe '#fmap' do
+    def apply
+      subject.fmap(&block)
+    end
+
+    include_examples 'requires block'
+    include_examples 'Functor#fmap block evaluation'
+  end
+
+  describe '#apply' do
+    def apply
+      subject.apply(&block)
+    end
+
+    include_examples 'requires block'
+    include_examples '#apply block evaluation'
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: mprelude
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Markus Schirp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: abstract_type
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+- !ruby/object:Gem::Dependency
+  name: adamantium
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: concord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+- !ruby/object:Gem::Dependency
+  name: equalizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+- !ruby/object:Gem::Dependency
+  name: ice_nine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.1
+- !ruby/object:Gem::Dependency
+  name: procto
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+description: Minimal prelude alike classes
+email:
+- mbj@schirp-dso.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+files:
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lib/mprelude.rb
+- mprelude.gemspec
+- spec/spec_helper.rb
+- spec/unit/mprelude/either_spec.rb
+- spec/unit/mprelude/maybe_spec.rb
+homepage: https://github.com/mbj/mprelude-rb
+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: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Mostly an either type
+test_files:
+- spec/unit/mprelude/either_spec.rb
+- spec/unit/mprelude/maybe_spec.rb