unsound 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d3d6412d4eda965925cd704816c57bf93db662b
-  data.tar.gz: 58e1df47db4ad389b2ce8663123d874ed7e9445c
+  metadata.gz: 3c645e777dc983c390c247a59c5f2de02727346b
+  data.tar.gz: a316ea5ccba27d63f3a823344e7c256f36056f1c
 SHA512:
-  metadata.gz: ee1992f01cf105fb33b2ab67e9264ce1922d612060b375cda2925c45e9266a6d0b2ee5c35aaeb38ff7f343010625012434a685608f8283bd412ea49b4e7f4552
-  data.tar.gz: bb75c7554b7a173b1bb5588588ee534f46d0baeb05d2643e6f321455de19ff0b6a1c0c9ec20185576db87274b59e7607c488f7a1e82082b16e7e05e97caa39e1
+  metadata.gz: 0c2101d6baca2654803b9edcca62d5f2e7967a29114f252a7e1c7dbef763ffaa98c0bcaa00e042cf524014a04f13c46de7a7962f43e1857792a24f5921f221c0
+  data.tar.gz: 59979f8819eff54c06cab5d71eb3a8e27e2e555b1185a6721df4235d1512bd443affd17ed3a0a1adea2b6ae7609442ae0bf9e6feddd12c88e69cdc29e40477de

data/lib/unsound/data.rb

@@ -1,101 +1,2 @@
-require "abstract_type"
-require "concord"
-
-module Unsound
-  module Data
-    # @abstract
-    class Either
-      include AbstractType
-      include Concord::Public.new(:value)
-
-      # Wraps a raw value in a {Data::Right}
-      #
-      # @param value [Any] the value to wrap
-      # @return [Data::Right]
-      def self.of(value)
-        Right.new(value)
-      end
-
-      abstract_method :fmap
-      abstract_method :>>
-
-      abstract_method :either
-      abstract_method :and_then
-      abstract_method :or_else
-
-      private
-
-      def of(value)
-        self.class.of(value)
-      end
-    end
-
-    class Left < Either
-      # A Noop
-      #
-      # @return [Data::Left]
-      def fmap(*)
-        self
-      end
-
-      # A Noop
-      #
-      # @return [Data::Left]
-      def >>(*)
-        self
-      end
-      alias :and_then :>>
-
-      # Chain another operation which can result in a {Data::Either}
-      #
-      # @param f[#call] the next operation
-      # @return [Data::Left, Data::Right]
-      def or_else(f = nil, &blk)
-        (f || blk)[value]
-      end
-
-      # Call a function on the value in the {Data::Left}
-      #
-      # @param f [#call] a function capable of processing the value
-      # @param _ [#call] a function that will never be called
-      def either(f, _)
-        f[value]
-      end
-    end
-
-    class Right < Either
-      # Apply a function to a value contained in a {Data::Right}
-      #
-      # @param f [#call] the function to apply
-      # @return [Data::Right] the result of applying the function
-      #   wrapped in a {Data::Right}
-      def fmap(f = nil, &blk)
-        self >> Composition.compose(method(:of), (f || blk))
-      end
-
-      # Chain another operation which can result in a {Data::Either}
-      #
-      # @param f[#call] the next operation
-      # @return [Data::Left, Data::Right]
-      def >>(f = nil, &blk)
-        (f || blk)[value]
-      end
-      alias :and_then :>>
-
-      # A Noop
-      #
-      # @return [Data::Right]
-      def or_else(*)
-        self
-      end
-
-      # Call a function on the value in the {Data::Right}
-      #
-      # @param _ [#call] a function that will never be called
-      # @param f [#call] a function capable of processing the value
-      def either(_, f)
-        f[value]
-      end
-    end
-  end
-end
+require_relative "data/either"
+require_relative "data/maybe"

data/lib/unsound/data/either.rb

@@ -0,0 +1,101 @@
+require "abstract_type"
+require "concord"
+
+module Unsound
+  module Data
+    # @abstract
+    class Either
+      include AbstractType
+      include Concord::Public.new(:value)
+
+      # Wraps a raw value in a {Data::Right}
+      #
+      # @param value [Any] the value to wrap
+      # @return [Data::Right]
+      def self.of(value)
+        Right.new(value)
+      end
+
+      abstract_method :fmap
+      abstract_method :>>
+
+      abstract_method :either
+      abstract_method :and_then
+      abstract_method :or_else
+
+      private
+
+      def of(value)
+        self.class.of(value)
+      end
+    end
+
+    class Left < Either
+      # A Noop
+      #
+      # @return [Data::Left]
+      def fmap(*)
+        self
+      end
+
+      # A Noop
+      #
+      # @return [Data::Left]
+      def >>(*)
+        self
+      end
+      alias :and_then :>>
+
+      # Chain another operation which can result in a {Data::Either}
+      #
+      # @param f[#call] the next operation
+      # @return [Data::Left, Data::Right]
+      def or_else(f = nil, &blk)
+        (f || blk)[value]
+      end
+
+      # Call a function on the value in the {Data::Left}
+      #
+      # @param f [#call] a function capable of processing the value
+      # @param _ [#call] a function that will never be called
+      def either(f, _)
+        f[value]
+      end
+    end
+
+    class Right < Either
+      # Apply a function to a value contained in a {Data::Right}
+      #
+      # @param f [#call] the function to apply
+      # @return [Data::Right] the result of applying the function
+      #   wrapped in a {Data::Right}
+      def fmap(f = nil, &blk)
+        self >> Composition.compose(method(:of), (f || blk))
+      end
+
+      # Chain another operation which can result in a {Data::Either}
+      #
+      # @param f[#call] the next operation
+      # @return [Data::Left, Data::Right]
+      def >>(f = nil, &blk)
+        (f || blk)[value]
+      end
+      alias :and_then :>>
+
+      # A Noop
+      #
+      # @return [Data::Right]
+      def or_else(*)
+        self
+      end
+
+      # Call a function on the value in the {Data::Right}
+      #
+      # @param _ [#call] a function that will never be called
+      # @param f [#call] a function capable of processing the value
+      def either(_, f)
+        f[value]
+      end
+    end
+  end
+end

data/lib/unsound/data/maybe.rb

@@ -0,0 +1,87 @@
+require "abstract_type"
+require "equalizer"
+
+module Unsound
+  module Data
+    # @abstract
+    class Maybe
+      include AbstractType
+
+      # Wraps a raw value in a {Data::Just}
+      #
+      # @param value [Any] the value to wrap
+      # @return [Data::Just]
+      def self.of(value)
+        Just.new(value)
+      end
+
+      abstract_method :fmap
+      abstract_method :>>
+
+      abstract_method :and_then
+      abstract_method :or_else
+
+      private
+
+      def of(value)
+        self.class.of(value)
+      end
+    end
+
+    class Nothing < Maybe
+      include Equalizer.new
+
+      # A Noop
+      #
+      # @return [Data::Nothing]
+      def fmap(*)
+        self
+      end
+
+      # A Noop
+      #
+      # @return [Data::Nothing]
+      def >>(*)
+        self
+      end
+      alias :and_then :>>
+
+      # Chain another operation which can result in a {Data::Maybe}
+      #
+      # @param f[#call] the next operation
+      # @return [Data::Nothing, Data::Just]
+      def or_else(f = nil, &blk)
+        (f || blk).call
+      end
+    end
+
+    class Just < Maybe
+      include Concord::Public.new(:value)
+
+      # Apply a function to a value contained in a {Data::Just}
+      #
+      # @param f [#call] the function to apply
+      # @return [Data::Just] the result of applying the function
+      #   wrapped in a {Data::Just}
+      def fmap(f = nil, &blk)
+        self >> Composition.compose(method(:of), (f || blk))
+      end
+
+      # Chain another operation which can result in a {Data::Maybe}
+      #
+      # @param f[#call] the next operation
+      # @return [Data::Nothing, Data::Just]
+      def >>(f = nil, &blk)
+        (f || blk)[value]
+      end
+      alias :and_then :>>
+
+      # A Noop
+      #
+      # @return [Data::Just]
+      def or_else(*)
+        self
+      end
+    end
+  end
+end

data/lib/unsound/version.rb

@@ -1,3 +1,3 @@
 module Unsound
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/spec/unit/unsound/data/maybe_spec.rb

@@ -0,0 +1,92 @@
+require "shared/functor_examples"
+require "shared/monad_examples"
+
+require "unsound"
+
+RSpec.describe Unsound::Data::Maybe do
+  let(:value) { double(:value) }
+
+  let(:instances) do
+    [
+      Unsound::Data::Nothing.new,
+      Unsound::Data::Just.new(value)
+    ]
+  end
+
+  it "has an abstract base class" do
+    expect {
+      Unsound::Data::Maybe.new
+    }.to raise_error(NotImplementedError)
+  end
+
+  it_behaves_like "a Functor"
+
+  it_behaves_like "a Monad" do
+    let(:type) { Unsound::Data::Maybe }
+
+    specify { expect(type.of(value)).to eq(Unsound::Data::Just.new(value)) }
+  end
+
+  describe "#and_then" do
+    let(:and_then) do
+      ->(value) { Unsound::Data::Just.new([value, value]) }
+    end
+
+    context "a just" do
+      let(:just) { Unsound::Data::Just.new(value) }
+      let(:value) { double(:value) }
+
+      context "a function" do
+        it "applies the function over the value" do
+          expect(just.and_then(and_then)).to eq(and_then.call(value))
+        end
+      end
+
+      context "a block" do
+        it "applies the block over the value" do
+          expect(just.and_then(&and_then)).to eq(and_then.call(value))
+        end
+      end
+    end
+
+    context "a nothing" do
+      let(:nothing) { Unsound::Data::Nothing.new }
+      let(:error) { double(:error) }
+
+      it "is a noop returning self" do
+        expect(nothing.and_then(and_then)).to eq(nothing)
+      end
+    end
+  end
+
+  describe "#or_else" do
+    let(:or_else) do
+      -> { Unsound::Data::Nothing.new }
+    end
+
+    context "a just" do
+      let(:just) { Unsound::Data::Right.new(value) }
+      let(:value) { double(:value) }
+
+      it "is a noop returning self" do
+        expect(just.or_else(or_else)).to eq(just)
+      end
+    end
+
+    context "a nothing" do
+      let(:nothing) { Unsound::Data::Nothing.new }
+
+      context "a function" do
+        it "calls the function" do
+          expect(nothing.or_else(or_else)).to eq(or_else.call)
+        end
+      end
+
+      context "a block" do
+        it "yields to the block" do
+          expect(nothing.or_else(&or_else)).to eq(or_else.call)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unsound
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Peter Swan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-10 00:00:00.000000000 Z
+date: 2015-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concord
@@ -86,6 +86,8 @@ files:
 - lib/unsound/composition.rb
 - lib/unsound/control.rb
 - lib/unsound/data.rb
+- lib/unsound/data/either.rb
+- lib/unsound/data/maybe.rb
 - lib/unsound/version.rb
 - spec/integration/try_spec.rb
 - spec/shared/functor_examples.rb
@@ -93,6 +95,7 @@ files:
 - spec/spec_helper.rb
 - spec/unit/unsound/control_spec.rb
 - spec/unit/unsound/data/either_spec.rb
+- spec/unit/unsound/data/maybe_spec.rb
 - unsound.gemspec
 homepage: https://github.com/pdswan/unsound
 licenses:
@@ -125,3 +128,4 @@ test_files:
 - spec/spec_helper.rb
 - spec/unit/unsound/control_spec.rb
 - spec/unit/unsound/data/either_spec.rb
+- spec/unit/unsound/data/maybe_spec.rb