ksr-maybe 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b9b624308416ed8b74db359022fe3cbc65c63e5b
+  data.tar.gz: d03ab54204740c3c608e4bc5faea88952cb373de
+SHA512:
+  metadata.gz: 67d3f7414267af4083a86ad199fbabf76eefcd5414edb62345141b9c848c686bdc59f4e0bce496e13b6aacb8e4097c095fe895f26bf9e44bb3f7dfab73155651
+  data.tar.gz: dcb5d360e0475ffdcdbd7c222b1f25e23d2e5f1f3b73fa9a4747511cdb72a543752fc292cf721f37a2694f765776163a7d45cc7b1c9f4106ec76dfe290ac26c0

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright Kickstarter, PBC.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/NOTICE.md

@@ -0,0 +1,25 @@
+# contracts.ruby (dependency)
+
+Copyright (c) 2012-2016 Aditya Bhargava
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,16 @@
+# ksr-maybe
+
+This gem provides a `Maybe` type. The `Maybe` type either contains a value
+(represented as `Just`) or it is empty (represented as `Nothing`).
+
+
+## Contracts
+
+This gem utilizes the ['contracts.ruby' gem][contracts], which adds dynamic type-checking to the 'ruby-maybe' codebase. By default, the 'contracts.ruby' gem will `raise` an error during runtime upon a type mismatch. To override this error throwing behavior, see [this 'contracts.ruby' documentation][contracts-override].
+
+## Licenses
+
+See [LICENSES.md](./LICENSES.md).
+
+[contracts]: http://egonschiele.github.io/contracts.ruby/
+[contracts-override]: https://github.com/egonSchiele/contracts.ruby/blob/master/TUTORIAL.md#failure-callbacks

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/**/*_test.rb"
+end

data/circle.yml

@@ -0,0 +1,10 @@
+version: 2
+jobs:
+  build:
+    working_directory: ~/ksr-maybe
+    docker:
+      - image: ruby:2.2
+    steps:
+      - checkout
+      - run: bundle install
+      - run: bundle exec rake test

data/ksr-maybe.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name = 'ksr-maybe'
+  s.version = '0.1.0'
+  s.summary = 'A library providing the optional type \'Maybe\''
+  s.authors = ['Ryan Closner', 'Corey Farwell']
+  s.email = 'eng@kickstarter.com'
+  s.files = `git ls-files`.split("\n")
+  s.homepage = 'http://github.com/kickstarter/ruby-maybe'
+  s.license = 'Apache-2.0'
+
+  s.add_dependency 'contracts', '~> 0.16.0'
+
+  s.add_development_dependency 'shoulda-context', '~> 1.2'
+  s.add_development_dependency 'minitest', '~> 5.10'
+  s.add_development_dependency 'rake', '~> 12.0'
+end

data/lib/maybe.rb

@@ -0,0 +1,418 @@
+require "contracts"
+
+class MaybeOf < Contracts::CallableClass
+  def initialize(*values)
+    @values = values
+  end
+
+  def valid?(obj)
+    obj.is_a?(Nothing) || obj.is_a?(Just) && @values.any? {|v| Contract.valid?(obj.get, v) }
+  end
+end
+
+# NOTE: Nothing and Just need to be initialized ahead of time so they're available
+# for Contract definitions below.
+
+Nothing = Class.new
+Just = Class.new
+
+# Maybe is a union type that is expressed in terms of Nothing and Just. It is
+# useful for gracefully handling potentially null values:
+#
+# @example when value is non-null
+#   User.create!(email: "john@doe.com", name: "John Doe")
+#
+#   Maybe
+#     .from_nullable(User.find_by(email: "john@doe.com"))
+#     .map {|user| user.name }
+#     .get_or_else { "NO NAME" }
+#
+#   #=> "John Doe"
+#
+# @example when value is null
+#   Maybe
+#     .from_nullable(User.find_by(email: "not@present.com"))
+#     .map {|user| user.name }
+#     .get_or_else { "NO NAME" }
+#
+#   #=> "NO NAME"
+#
+module Maybe
+  include Contracts::Core
+  C = Contracts
+  private_constant :C
+
+  # An alias for instantiating a Nothing object
+  #
+  # @example
+  #   Maybe.Nothing
+  #   #=> Nothing
+  #
+  # @returns [Nothing] an instance of Nothing
+  Contract C::None => Nothing
+  def self.Nothing
+    Nothing.instance
+  end
+
+  # An alias for instantiating a Just object
+  #
+  # @example
+  #   Maybe.Just(1)
+  #   #=> Just(1)
+  #
+  # @param value [Any] the value to wrap
+  # @returns [Just<Any>] an instance of Just wrapping some object
+  Contract C::Any => Just
+  def self.Just(value)
+    Just.new(value)
+  end
+
+  # An alias for instantiating a Just object
+  #
+  # @example
+  #   Maybe.of(1)
+  #   #=> Just(1)
+  #
+  # @param value [Any] the value to wrap
+  # @returns [Just<Any>] an instance of Just wrapping the value
+  Contract C::Any => Just
+  def self.of(value)
+    Just.new(value)
+  end
+
+  # Takes a nullable object and returns either an instance of Just wrapping
+  # the object in the case that the object is non-null, or an instance of
+  # Nothing in the case that the object is null.
+  #
+  # @example with a non-null value
+  #   User.create(email: "john@doe.com")
+  #
+  #   Maybe.from_nullable(User.find_by(email: "john@doe.com"))
+  #   #=> Just(1)
+  #
+  # @example with a null value
+  #   Maybe.from_nullable(User.find_by(email: "not@present.com"))
+  #   #=> Nothing
+  #
+  # @param value [Any] the value to wrap
+  # @returns [Just<Any>,Nothing] either an instance of Just wrapping the value,
+  # or an instance of Nothing
+  Contract C::Any => Maybe
+  def self.from_nullable(value)
+    value.nil? ? Nothing.instance : Just.new(value)
+  end
+
+  # Takes a set of Maybes, and attempts to combine their values, and wrap them
+  # into a single Maybe.
+  #
+  # @example with a single instance of Just
+  #   Maybe.zip(Maybe.Just(1))
+  #   #=> Just(1)
+  #
+  # @example with a single instance of Nothing
+  #   Maybe.zip(Maybe.Nothing)
+  #   #=> Nothing
+  #
+  # @example with multiple instances of Just
+  #   Maybe.zip(Maybe.Just(1), Maybe.Just(2))
+  #   #=> Just([1,2])
+  #
+  # @example with multiple instances of Nothing
+  #   Maybe.zip(Maybe.Nothing, Maybe.Nothing)
+  #   #=> Nothing
+  #
+  # @example a mixture of Just and Nothing instances
+  #   Maybe.zip(Maybe.Just(1), Maybe.Nothing, Maybe.Just(2))
+  #   #=> Nothing
+  #
+  # @param m [Array<Just<Any>>, Array<Nothing>] a collection of Maybes
+  # @return [Just<Any>,Nothing] either a combined Just, or Nothing
+  Contract C::Args[Maybe] => C::Or[Maybe]
+  def self.zip(fst, snd, *rest)
+    [fst, snd, *rest].reduce(of([])) do |accum, maybe|
+      accum.flat_map do |accum_|
+        maybe.map {|maybe_| accum_ + [maybe_] }
+      end
+    end
+  end
+end
+
+# Nothing is a member of the Maybe union type that represents a null value.
+# It's used in conjunction with the Just type to allow one to gracefully handle
+# null values without having to create a large amount of conditional logic.
+class Nothing
+  include Maybe
+  include Contracts::Core
+  C = Contracts
+  private_constant :C
+
+  NothingError = Class.new(RuntimeError)
+
+  def self.instance
+    @instance ||= new
+  end
+  private_class_method :new
+
+  # Attempts to return the value wrapped by the Maybe type. In the case of a
+  # Nothing, however, it will raise due to the fact that Nothing cannot hold a
+  # value.
+  #
+  # @example
+  #   Maybe.Nothing.get
+  #   #=> Nothing::NothingError: cannot get the value of Nothing.
+  #
+  # @raises [Nothing::NothingError] an error raised when one attempts to fetch the value
+  Contract C::None => C::None
+  def get
+    raise NothingError, "cannot get the value of Nothing."
+  end
+
+  # Attempts to either return the value wrapped by the Maybe type (in the case
+  # of a Just), or provide an alternative value when the instance is a Nothing.
+  #
+  # @example
+  #   Maybe.Nothing.get_or_else { "NO NAME" }
+  #   #=> "NO NAME"
+  #
+  # @yield [] the alternative value when called on an instance of Nothing
+  # @return [Any] either the value contained by the Maybe or the value
+  # returned by the block passed.
+  Contract C::Func[C::None => C::Any] => C::Any
+  def get_or_else(&f)
+    f.call
+  end
+
+  # A convenience method for determining whether a Maybe type is an instance
+  # of Just.
+  # @return [Boolean] whether or not the value is a Just
+  Contract C::None => C::Bool
+  def just?
+    false
+  end
+
+  # A convenience method for determining whether a Maybe type is an instance
+  # of Nothing.
+  # @return [Boolean] whether or not the value is a Nothing
+  Contract C::None => C::Bool
+  def nothing?
+    true
+  end
+
+  # Transforms a Maybe type into a Maybe of the same type. When called on an
+  # instance of Just it will apply the block with its value as an argument, and
+  # re-wrap the result of the block in another Just. When called on an instance
+  # of Nothing, however, the method will no-op and simply return itself.
+  #
+  # @example
+  #   Maybe.Nothing.map {|num| num + 1 }
+  #   #=> Nothing
+  #
+  # @yield [value] the block to apply
+  # @yieldparam [Any] the value wrapped by the Maybe type
+  # @yieldreturn [Any] the value returned by the block
+  # @return [Nothing] the instance of Nothing
+  Contract C::Func[C::Any => C::Any] => Nothing
+  def map(&f)
+    self
+  end
+
+  # Transforms a Maybe type into another Maybe (not necessarily of the same type).
+  # When called on an instance of Just it will will apply the block with its value
+  # as the argument (it differs from Maybe#map in that it is the responsibility
+  # of the caller to rewrap the result in a Maybe type). When called on an instance
+  # of Nothing the method will no-op and simply return itself.
+  #
+  # @example
+  #   Maybe.Nothing.flat_map {|num| num == 0 ? Maybe.Just(num) : Maybe.Nothing }
+  #   #=> Nothing
+  #
+  # @yield [value] the block to apply
+  # @yieldparam [Any] the value wrapped by the Maybe type
+  # @yieldreturn [Nothing, Just<Any>] the Maybe returned by the block
+  # @return [Nothing] the Maybe returned by the block
+  Contract C::Func[C::Any => Maybe] => Nothing
+  def flat_map(&f)
+    self
+  end
+
+  # Applies the function inside a Maybe type to another applicative type.
+  #
+  # @example
+  #   Maybe.Nothing.ap( Maybe.of(->(str){ str.upcase }) )
+  #   #=> Nothing
+  #
+  # @param m [Just<Proc>, Nothing] an instance of the Maybe type to apply
+  # @return [Nothing] the result of applying the function wrapped in a Maybe
+  Contract MaybeOf[Proc] => Nothing
+  def ap(m)
+    self
+  end
+  alias apply ap
+
+  # An equality operator
+  #
+  # @example
+  #   Maybe.Nothing == Maybe.Nothing
+  #   #=> true
+  #
+  # @param m [Any] the object to compare against
+  # @return [Boolean] whether or not the object is equal
+  Contract C::Any => C::Bool
+  def ==(m)
+    m.is_a?(Nothing)
+  end
+
+  # Overrides the default print behavior
+  #
+  # @example
+  #   puts(Maybe.Nothing)
+  #   #=> "Nothing"
+  #
+  # @return [String] the String to print
+  Contract C::None => String
+  def inspect
+    "Nothing"
+  end
+end
+
+# Just is a member of the Maybe union type that represents a non-null value.
+# It's used in conjunction with the Nothing type to allow one to gracefully
+# handle null values without having to create a large amount of conditional
+# logic.
+class Just
+  include Maybe
+  include Contracts::Core
+  C = Contracts
+  private_constant :C
+
+  def initialize(value)
+    @value = value
+  end
+
+  # Attempts to return the value wrapped by the Maybe type. In the case of a
+  # Nothing, however, it will raise due to the fact that Nothing cannot hold a
+  # value.
+  #
+  # @example
+  #   Maybe.Just(1).get
+  #   #=> 1
+  #
+  # @return [Any] the value wrapped by the Maybe object
+  Contract C::None => C::Any
+  def get
+    @value
+  end
+
+  # Attempts to either return the value wrapped by the Maybe type (in the case
+  # of a Just), or provide an alternative value when the instance is a Nothing.
+  #
+  # @example
+  #   Maybe.Just("John Doe").get_or_else { "NO NAME" }
+  #   #=> "John Doe"
+  #
+  # @yield [] the alternative value when called on an instance of Nothing
+  # @return [Any] the value wrapped by the Maybe object
+  Contract C::Func[C::None => C::Any] => C::Any
+  def get_or_else(&f)
+    @value
+  end
+
+  # A convenience method for determining whether a Maybe type is an instance
+  # of Just.
+  # @return [Boolean] whether or not the value is a Just
+  Contract C::None => C::Bool
+  def just?
+    true
+  end
+
+  # A convenience method for determining whether a Maybe type is an instance
+  # of Nothing.
+  # @return [Boolean] whether or not the value is a Nothing
+  Contract C::None => C::Bool
+  def nothing?
+    false
+  end
+
+  # Transforms a Maybe type into a Maybe of the same type. When called on an
+  # instance of Just it will apply the block with its value as an argument, and
+  # re-wrap the result of the block in another Just. When called on an instance
+  # of Nothing, however, the method will no-op and simply return itself.
+  #
+  # @example
+  #   Maybe.Just(1).map {|num| num + 1 }
+  #   #=> Just(2)
+  #
+  # @yield [value] the block to apply
+  # @yieldparam [Any] the value wrapped by the Maybe type
+  # @yieldreturn [Any] the value returned by the block
+  # @return [Just<Any>] the value returned by the block and wrapped by a Maybe
+  Contract C::Func[C::Any => C::Any] => Just
+  def map(&f)
+    flat_map {|value| Maybe.of(f.call(value)) }
+  end
+
+  # Transforms a Maybe type into another Maybe (not necessarily of the same type).
+  # When called on an instance of Just it will will apply the block with its value
+  # as the argument (it differs from Maybe#map in that it is the responsibility
+  # of the caller to rewrap the result in a Maybe type). When called on an instance
+  # of Nothing the method will no-op and simply return itself.
+  #
+  # @example
+  #   User.create!(email: "john@doe.com", slug: "johndoe")
+  #   Maybe
+  #     .from_nullable(User.find_by(email: "john@doe.com"))
+  #     .flat_map {|u| u.slug == "johndoe" ? Maybe.Just(u) : Maybe.Nothing }
+  #
+  #   #=> Just(#<User email: "john@doe.com", slug: "johndoe">)
+  #
+  # @yield [value] the block to apply
+  # @yieldparam [Any] the value wrapped by the Maybe type
+  # @yieldreturn [Nothing, Just<Any>] the Maybe returned by the block
+  # @return [Nothing, Just<Any>] the Maybe returned by the block
+  Contract C::Func[C::Any => Maybe] => Maybe
+  def flat_map(&f)
+    f.call(@value)
+  end
+
+  # Applies the function inside a Maybe type to another applicative type.
+  #
+  # @example
+  #   Maybe.of("hello, world!").ap( Maybe.of(->(str){ str.upcase }) )
+  #   #=> Just("HELLO, WORLD!")
+  #
+  # @param m [Just<Proc>, Nothing] an instance of the Maybe type to apply
+  # @return [Just<Any>, Nothing] the result of applying the function wrapped in a Maybe
+  Contract MaybeOf[Proc] => Maybe
+  def ap(m)
+    m.flat_map {|f| map(&f) }
+  end
+  alias apply ap
+
+  # An equality operator
+  #
+  # @example
+  #   Maybe.Just(1) == Maybe.Just(1)
+  #   #=> true
+  #
+  #   Maybe.Just(0) == Maybe.Just(1)
+  #   #=> false
+  #
+  # @param m [Any] the object to compare against
+  # @return [Boolean] whether or not the object is equal
+  Contract C::Any => C::Bool
+  def ==(m)
+    m.is_a?(Just) && m.get == get
+  end
+
+  # Overrides the default print behavior
+  #
+  # @example
+  #   puts(Maybe.Just(1))
+  #   #=> "Just(1)"
+  #
+  # @return [String] the String to print
+  Contract C::None => String
+  def inspect
+    "Just(#{@value.inspect})"
+  end
+end

data/test/maybe_test.rb

@@ -0,0 +1,249 @@
+require 'minitest/autorun'
+require 'shoulda/context'
+
+require_relative "../lib/maybe"
+
+class MaybeTest < Minitest::Test
+  context ".Nothing" do
+    should "return an instance of Nothing" do
+      assert_equal Nothing.instance, Maybe.Nothing
+    end
+  end
+
+  context ".Just" do
+    should "return an instance of Just" do
+      assert_equal Maybe.of(1), Maybe.Just(1)
+    end
+  end
+
+  context ".of" do
+    should "return an instance of Just" do
+      assert_equal Just.new(1), Maybe.of(1)
+    end
+  end
+
+  context ".from_nullable" do
+    context "when value is `nil`" do
+      should "return an instance of Nothing" do
+        assert_equal Nothing.instance, Maybe.from_nullable(nil)
+      end
+    end
+
+    context "when value is not `nil`" do
+      should "return an instance of Just" do
+        assert_equal Maybe.of(1), Maybe.from_nullable(1)
+      end
+    end
+  end
+
+  context ".zip" do
+    setup do
+      @just = Maybe.of(1)
+      @nothing = Nothing.instance
+    end
+
+    context "with only Just values" do
+      should "return an instance of Just" do
+        assert_equal Maybe.of([1,1]), Maybe.zip(@just, @just)
+      end
+    end
+
+    context "with only Nothing values" do
+      should "return an instance of Nothing" do
+        assert_equal Nothing.instance, Maybe.zip(@nothing, @nothing)
+      end
+    end
+
+    context "with a mixture of Just and Nothing values" do
+      should "return an instance of Nothing" do
+        assert_equal Nothing.instance, Maybe.zip(@just, @nothing, @just)
+      end
+    end
+  end
+
+  context "Nothing" do
+    subject do
+      Nothing.instance
+    end
+
+    context "#get" do
+      should "raise an error" do
+        assert_raises(Nothing::NothingError) { subject.get }
+      end
+    end
+
+    context "#get_or_else" do
+      should "call the block" do
+        assert_equal 1, subject.get_or_else { 1 }
+      end
+    end
+
+    context "#just?" do
+      should "return false" do
+        refute subject.just?
+      end
+    end
+
+    context "#nothing?" do
+      should "return true" do
+        assert subject.nothing?
+      end
+    end
+
+    context "#map" do
+      should "return self" do
+        assert_equal subject, subject.map {|_n| 1 }
+      end
+    end
+
+    context "#flat_map" do
+      should "return self" do
+        assert_equal subject, subject.flat_map {|_n| 1 }
+      end
+    end
+
+    context "#ap" do
+      should "return self" do
+        assert_equal subject, subject.ap(Maybe.of(->(x){ x + 1 }))
+      end
+    end
+
+    context "#==" do
+      context "when object is a Nothing" do
+        should "return true" do
+          assert_equal subject, Nothing.instance
+        end
+      end
+
+      context "when object is a Just" do
+        should "return false" do
+          refute_equal subject, Maybe.of(1)
+        end
+      end
+    end
+
+    context "#inspect" do
+      should "return the correct String" do
+        assert_equal "Nothing", subject.inspect
+      end
+    end
+  end
+
+  context "Just" do
+    subject do
+      Maybe.of(1)
+    end
+
+    context "#get" do
+      should "return the value" do
+        assert_equal 1, subject.get
+      end
+    end
+
+    context "#get_or_else" do
+      should "return the value" do
+        assert_equal 1, subject.get_or_else { 2 }
+      end
+    end
+
+    context "#just?" do
+      should "return true" do
+        assert subject.just?
+      end
+    end
+
+    context "#nothing?" do
+      should "return false" do
+        refute subject.nothing?
+      end
+    end
+
+    context "#map" do
+      setup do
+        @f = ->(n){ n + 1 }
+        @g = ->(n){ n * 2 }
+      end
+
+      should "hold to the law of identity" do
+        assert_equal subject, subject.map {|x| x }
+      end
+
+      should "hold to the law of composition" do
+        assert_equal subject.map(&@g).map(&@f), subject.map {|n| @f.call(@g.call(n)) }
+      end
+    end
+
+    context "#flat_map" do
+      setup do
+        @f = ->(n) { Maybe.of(n + 1) }
+        @g = ->(n) { Maybe.of(n * 2) }
+      end
+
+      should "fail if the function does not rewrap the value" do
+        assert_raises(ReturnContractError) { subject.flat_map {|x| x } }
+      end
+
+      should "be equivalent to calling the function with the held value" do
+        assert_equal @f.call(subject.get), subject.flat_map(&@f)
+      end
+
+      should "be equivalent when the function merely rewraps" do
+        assert_equal subject, subject.flat_map(&Maybe.method(:of))
+      end
+
+      should "hold to the law of associativity" do
+        assert_equal subject.flat_map(&@f).flat_map(&@g), subject.flat_map {|v| @f.call(v).flat_map(&@g) }
+      end
+    end
+
+    context "#ap" do
+      setup do
+        @identity = ->(x){ x }
+        @upcase = ->(str){ str.upcase }
+        @add = ->(n){ n + 1 }
+      end
+
+      should "raise if argument is not an instance of Maybe" do
+        assert_raises(ContractError) { Maybe.of(1).ap(->(x){ x + 1 }) }
+      end
+
+      should "raise if argument is not a Maybe holding a function" do
+        assert_raises(ContractError) { Maybe.of(1).ap(Maybe.of(1)) }
+      end
+
+      should "work when given a Maybe holding a function" do
+        assert_equal Maybe.of("HELLO, WORLD!"), Maybe.of("hello, world!").ap(Maybe.of(@upcase))
+      end
+
+      should "hold to the law of identity" do
+        assert_equal Maybe.of(1), Maybe.of(1).ap(Maybe.of(@identity))
+      end
+    end
+
+    context "#==" do
+      context "when object is a Just that is equivalent" do
+        should "return true" do
+          assert_equal Maybe.of(1), Maybe.of(1)
+        end
+      end
+
+      context "when object is a Just that is equivalent" do
+        should "return false" do
+          refute_equal Maybe.of(1), Maybe.of(2)
+        end
+      end
+
+      context "when object is a Nothing" do
+        should "return false" do
+          refute_equal Nothing.instance, Maybe.of(1)
+        end
+      end
+    end
+
+    context "#inspect" do
+      should "return the correct String" do
+        assert_equal "Just(1)", Maybe.of(1).inspect
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: ksr-maybe
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ryan Closner
+- Corey Farwell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: contracts
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '12.0'
+description: 
+email: eng@kickstarter.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- NOTICE.md
+- README.md
+- Rakefile
+- circle.yml
+- ksr-maybe.gemspec
+- lib/maybe.rb
+- test/maybe_test.rb
+homepage: http://github.com/kickstarter/ruby-maybe
+licenses:
+- Apache-2.0
+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.0.14.1
+signing_key: 
+specification_version: 4
+summary: A library providing the optional type 'Maybe'
+test_files: []