fear 0.0.1

data/lib/fear/right.rb

@@ -0,0 +1,56 @@
+module Fear
+  class Right
+    include Either
+    include RightBiased::Right
+
+    # Returns `Left(default)` if the given predicate
+    # does not hold for the right value, otherwise, returns `Right`.
+    #
+    # @param default [Proc, any]
+    # @return [Either]
+    #
+    def detect(default)
+      if yield(value)
+        self
+      else
+        Left.new(Utils.return_or_call_proc(default))
+      end
+    end
+
+    # @return [Left] value in `Left`
+    def swap
+      Left.new(value)
+    end
+
+    # @param reduce_right [Proc] the function to apply if this is a `Right`
+    # @return [any] Applies `reduce_right` to the value.
+    #
+    def reduce(_, reduce_right)
+      reduce_right.call(value)
+    end
+
+    # Joins an `Either` through `Right`.
+    #
+    # This method requires that the right side of this `Either` is itself an
+    # Either type.
+    #
+    # This method, and `join_left`, are analogous to `Option#flatten`
+    #
+    # @return [Either]
+    # @raise [TypeError] if it does not contain `Either`.
+    #
+    def join_right
+      value.tap do |v|
+        Utils.assert_type!(v, Either)
+      end
+    end
+
+    # Joins an `Either` through `Left`.
+    #
+    # @return [self]
+    #
+    def join_left
+      self
+    end
+  end
+end

data/lib/fear/right_biased.rb

@@ -0,0 +1,155 @@
+module Fear
+  module RightBiased
+    # Performs necessary interface and type checks.
+    #
+    module Interface
+      # Returns the value from this `RightBiased::Right` or the given argument if
+      # this is a `RightBiased::Left`.
+      def get_or_else(*args, &block)
+        Utils.assert_arg_or_block!('get_or_else', *args, &block)
+        super
+      end
+
+      def flat_map
+        super.tap do |result|
+          Utils.assert_type!(result, left_class, right_class)
+        end
+      end
+
+      # Ensures that returned value either left, or right.
+      def detect(*)
+        super.tap do |result|
+          Utils.assert_type!(result, left_class, right_class)
+        end
+      end
+    end
+
+    module Right
+      class << self
+        def included(base)
+          base.prepend Interface
+        end
+      end
+
+      # @!method get_or_else(default)
+      #   @param default [any]
+      #   @return [any] the `#value`.
+      #
+      # @!method get_or_else
+      #   @return [any] the `#value`.
+      #
+      def get_or_else(*_args)
+        value
+      end
+
+      # @param [any]
+      # @return [Boolean] `true` if it has an element that is equal
+      #   (as determined by `==`) to `other_value`, `false` otherwise.
+      #
+      def include?(other_value)
+        value == other_value
+      end
+
+      # Executes the given side-effecting block.
+      #
+      # @return [self]
+      #
+      def each
+        yield(value)
+        self
+      end
+
+      # Maps the value using given block.
+      #
+      # @return [RightBiased::Right]
+      #
+      def map
+        self.class.new(yield(value))
+      end
+
+      # Binds the given function across `RightBiased::Right`.
+      #
+      # @return [RightBiased::Left, RightBiased::Right]
+      #
+      def flat_map
+        yield(value)
+      end
+
+      # @return [Array] containing value
+      def to_a
+        [value]
+      end
+
+      # @return [Option] containing value
+      def to_option
+        Some.new(value)
+      end
+
+      # @return [Boolean] true if value satisfies predicate.
+      def any?
+        yield(value)
+      end
+    end
+
+    module Left
+      prepend Interface
+      include Utils
+      # @!method get_or_else(default)
+      #   @param default [any]
+      #   @return [any] default value
+      #
+      # @!method get_or_else
+      #   @return [any] result of evaluating a block.
+      #
+      def get_or_else(*args)
+        args.fetch(0) { yield }
+      end
+
+      # @param [any]
+      # @return [false]
+      #
+      def include?(_)
+        false
+      end
+
+      # Ignores the given side-effecting block and return self.
+      #
+      # @return [RightBiased::Left]
+      #
+      def each
+        self
+      end
+
+      # Ignores the given block and return self.
+      #
+      # @return [RightBiased::Left]
+      #
+      def map
+        self
+      end
+
+      # Ignores the given block and return self.
+      #
+      # @return [RightBiased::Left]
+      #
+      def flat_map
+        self
+      end
+
+      # @return [Array] empty array
+      def to_a
+        []
+      end
+
+      # @return [None]
+      def to_option
+        None.new
+      end
+
+      # @return [false]
+      def any?
+        false
+      end
+    end
+  end
+end

data/lib/fear/some.rb

@@ -0,0 +1,42 @@
+module Fear
+  class Some
+    include Option
+    include Dry::Equalizer(:get)
+    include RightBiased::Right
+
+    attr_reader :value
+    protected :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    # @return option's value
+    def get
+      @value
+    end
+
+    # @return [Option] self if this `Option` is nonempty and
+    #   applying the `predicate` to this option's value
+    #   returns true. Otherwise, return `None`.
+    #
+    def detect
+      if yield(value)
+        self
+      else
+        None.new
+      end
+    end
+
+    # @return [Option] if applying the `predicate` to this
+    #   option's value returns false. Otherwise, return `None`.
+    #
+    def reject
+      if yield(value)
+        None.new
+      else
+        self
+      end
+    end
+  end
+end

data/lib/fear/success.rb

@@ -0,0 +1,81 @@
+module Fear
+  class Success
+    include Try
+    include Dry::Equalizer(:value)
+    include RightBiased::Right
+
+    attr_reader :value
+    protected :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def get
+      @value
+    end
+
+    def success?
+      true
+    end
+
+    # @return [Success] self
+    def or_else
+      self
+    end
+
+    # Transforms a nested `Try`, ie, a `Success` of `Success``,
+    # into an un-nested `Try`, ie, a `Success`.
+    # @return [Try]
+    #
+    def flatten
+      if value.is_a?(Try)
+        value.flatten
+      else
+        self
+      end
+    end
+
+    # Converts this to a `Failure` if the predicate
+    # is not satisfied.
+    # @yieldparam [any] value
+    # @yieldreturn [Boolean]
+    # @return [Try]
+    #
+    def detect
+      if yield(value)
+        self
+      else
+        fail NoSuchElementError, "Predicate does not hold for `#{value}`"
+      end
+    rescue => error
+      Failure.new(error)
+    end
+
+    # @return [Success] self
+    #
+    def recover_with
+      self
+    end
+
+    # @return [Success] self
+    #
+    def recover
+      self
+    end
+
+    # @return [Try]
+    def map
+      super
+    rescue => error
+      Failure.new(error)
+    end
+
+    # @return [Try]
+    def flat_map
+      super
+    rescue => error
+      Failure.new(error)
+    end
+  end
+end

data/lib/fear/try.rb

@@ -0,0 +1,127 @@
+module Fear
+  # The `Try` represents a computation that may either result
+  # in an exception, or return a successfully computed value.
+  #
+  # Instances of `Try`, are either an instance of `Success` or
+  # `Failure`.
+  #
+  # For example, `Try` can be used to perform division on a
+  # user-defined input, without the need to do explicit
+  # exception-handling in all of the places that an exception
+  # might occur.
+  #
+  # @example
+  #   dividend = Try { params[:dividend].to_i }
+  #   divisor = Try { params[:divisor].to_i }
+  #   problem = dividend.flat_map { |x| divisor.map { |y| x / y }
+  #
+  #   if problem.success?
+  #     puts "Result of #{dividend.get} / #{divisor.get} is: #{problem.get}"
+  #   else
+  #     puts "You must've divided by zero or entered something wrong. Try again"
+  #     puts "Info from the exception: #{problem.exception.message}"
+  #   end
+  #
+  # An important property of `Try` shown in the above example is its
+  # ability to `pipeline`, or chain, operations, catching exceptions
+  # along the way. The `flat_map` and `map` combinators in the above
+  # example each essentially pass off either their successfully completed
+  # value, wrapped in the `Success` type for it to be further operated
+  # upon by the next combinator in the chain, or the exception wrapped
+  # in the `Failure` type usually to be simply passed on down the chain.
+  # Combinators such as `rescue` and `recover` are designed to provide some
+  # type of default behavior in the case of failure.
+  #
+  # @note only non-fatal exceptions are caught by the combinators on `Try`.
+  # Serious system errors, on the other hand, will be thrown.
+  #
+  # @note all `Try` combinators will catch exceptions and return failure
+  # unless otherwise specified in the documentation.
+  #
+  # @example #or_else
+  #   Success(42).or_else { -1 }                 #=> Success(42)
+  #   Failure(ArgumentError.new).or_else { -1 }  #=> Success(-1)
+  #   Failure(ArgumentError.new).or_else { 1/0 } #=> Failure(ZeroDivisionError.new('divided by 0'))
+  #
+  # @example #flatten
+  #   Success(42).flatten                         #=> Success(42)
+  #   Success(Success(42)).flatten                #=> Success(42)
+  #   Success(Failure(ArgumentError.new)).flatten #=> Failure(ArgumentError.new)
+  #   Failure(ArgumentError.new).flatten { -1 }   #=> Failure(ArgumentError.new)
+  #
+  # @example #map
+  #   Success(42).map { |v| v/2 }                 #=> Success(21)
+  #   Failure(ArgumentError.new).map { |v| v/2 }  #=> Failure(ArgumentError.new)
+  #
+  # @example #detect
+  #   Success(42).detect { |v| v > 40 }
+  #     #=> Success(21)
+  #   Success(42).detect { |v| v < 40 }
+  #     #=> Failure(NoSuchElementError.new("Predicate does not hold for 42"))
+  #   Failure(ArgumentError.new).detect { |v| v < 40 }
+  #     #=> Failure(ArgumentError.new)
+  #
+  # @example #recover_with
+  #   Success(42).recover_with { |e| Success(e.massage) }
+  #     #=> Success(42)
+  #   Failure(ArgumentError.new).recover_with { |e| Success(e.massage) }
+  #     #=> Success('ArgumentError')
+  #   Failure(ArgumentError.new).recover_with { |e| fail }
+  #     #=> Failure(RuntimeError)
+  #
+  # @example #recover
+  #   Success(42).recover { |e| e.massage }
+  #     #=> Success(42)
+  #   Failure(ArgumentError.new).recover { |e| e.massage }
+  #     #=> Success('ArgumentError')
+  #   Failure(ArgumentError.new).recover { |e| fail }
+  #     #=> Failure(RuntimeError)
+  #
+  # @author based on Twitter's original implementation.
+  # @see https://github.com/scala/scala/blob/2.11.x/src/library/scala/util/Try.scala
+  #
+  module Try
+    def left_class
+      Failure
+    end
+
+    def right_class
+      Success
+    end
+
+    # @return [true, false] `true` if the `Try` is a `Failure`,
+    #   `false` otherwise.
+    #
+    def failure?
+      !success?
+    end
+
+    module Mixin
+      # Constructs a `Try` using the block. This
+      # method will ensure any non-fatal exception is caught and a
+      # `Failure` object is returned.
+      # @return [Try]
+      #
+      def Try
+        Success.new(yield)
+      rescue StandardError => error
+        Failure.new(error)
+      end
+
+      # @param exception [StandardError]
+      # @return [Failure]
+      #
+      def Failure(exception)
+        fail TypeError, "not an error: #{exception}" unless exception.is_a?(StandardError)
+        Failure.new(exception)
+      end
+
+      # @param value [any]
+      # @return [Success]
+      #
+      def Success(value)
+        Success.new(value)
+      end
+    end
+  end
+end

data/lib/fear/utils.rb

@@ -0,0 +1,25 @@
+module Fear
+  module Utils
+    extend self
+
+    def assert_arg_or_block!(method_name, *args)
+      unless block_given? ^ args.any?
+        fail ArgumentError, "##{method_name} accepts either one argument or block"
+      end
+    end
+
+    def assert_type!(value, *types)
+      if types.none? { |type| value.is_a?(type) }
+        fail TypeError, "expected `#{value}` to be of #{types.join(', ')} class"
+      end
+    end
+
+    def return_or_call_proc(value)
+      if value.respond_to?(:call)
+        value.call
+      else
+        value
+      end
+    end
+  end
+end

data/lib/fear/version.rb

@@ -0,0 +1,3 @@
+module Fear
+  VERSION = '0.0.1'.freeze
+end

data/lib/fear.rb

@@ -0,0 +1,31 @@
+require 'dry-equalizer'
+require 'fear/version'
+
+module Fear
+  Error = Class.new(StandardError)
+  IllegalStateException = Class.new(Error)
+  NoSuchElementError = Class.new(Error)
+
+  autoload :For, 'fear/for'
+  autoload :Utils, 'fear/utils'
+  autoload :RightBiased, 'fear/right_biased'
+
+  autoload :Option, 'fear/option'
+  autoload :Some, 'fear/some'
+  autoload :None, 'fear/none'
+
+  autoload :Try, 'fear/try'
+  autoload :Success, 'fear/success'
+  autoload :Failure, 'fear/failure'
+
+  autoload :Either, 'fear/either'
+  autoload :Left, 'fear/left'
+  autoload :Right, 'fear/right'
+
+  module Mixin
+    include Either::Mixin
+    include For::Mixin
+    include Option::Mixin
+    include Try::Mixin
+  end
+end

data/spec/fear/failure_spec.rb

@@ -0,0 +1,78 @@
+RSpec.describe Fear::Failure do
+  let(:failure) { described_class.new(RuntimeError.new('error')) }
+
+  it_behaves_like Fear::RightBiased::Left do
+    let(:left) { failure }
+  end
+
+  describe '#success?' do
+    subject { failure }
+    it { is_expected.not_to be_success }
+  end
+
+  describe '#get' do
+    subject { proc { failure.get } }
+    it { is_expected.to raise_error(RuntimeError, 'error') }
+  end
+
+  describe '#or_else' do
+    context 'default does not fail' do
+      subject { failure.or_else { 'value' } }
+      it { is_expected.to eq(Fear::Success.new('value')) }
+    end
+
+    context 'default fails with error' do
+      subject(:or_else) { failure.or_else { fail 'unexpected error' } }
+      it { is_expected.to be_kind_of(described_class) }
+      it { expect { or_else.get }.to raise_error(RuntimeError, 'unexpected error') }
+    end
+  end
+
+  describe '#flatten' do
+    subject { failure.flatten }
+    it { is_expected.to eq(failure) }
+  end
+
+  describe '#detect' do
+    subject { failure.detect { |v| v == 'value' } }
+    it { is_expected.to eq(failure) }
+  end
+
+  context '#recover_with' do
+    context 'block does not fail' do
+      subject do
+        failure.recover_with do |error|
+          Fear::Success.new(error.message)
+        end
+      end
+
+      it 'returns result of evaluation of the block against the error' do
+        is_expected.to eq(Fear::Success.new('error'))
+      end
+    end
+
+    context 'block fails' do
+      subject(:recover_with) { failure.recover_with { fail 'unexpected error' } }
+
+      it { is_expected.to be_kind_of(described_class) }
+      it { expect { recover_with.get }.to raise_error(RuntimeError, 'unexpected error') }
+    end
+  end
+
+  context '#recover' do
+    context 'block does not fail' do
+      subject { failure.recover(&:message) }
+
+      it 'returns Success of evaluation of the block against the error' do
+        is_expected.to eq(Fear::Success.new('error'))
+      end
+    end
+
+    context 'block fails' do
+      subject(:recover) { failure.recover { fail 'unexpected error' } }
+
+      it { is_expected.to be_kind_of(described_class) }
+      it { expect { recover.get }.to raise_error(RuntimeError, 'unexpected error') }
+    end
+  end
+end

data/spec/fear/for_spec.rb

@@ -0,0 +1,70 @@
+RSpec.describe Fear::For do
+  include Fear::For::Mixin
+
+  context 'unary' do
+    context 'Some' do
+      subject do
+        For(a: Fear::Some.new(2)) { a * 2 }
+      end
+
+      it { is_expected.to eq(Fear::Some.new(4)) }
+    end
+
+    context 'None' do
+      subject do
+        For(a: Fear::None.new) { a * 2 }
+      end
+
+      it { is_expected.to eq(Fear::None.new) }
+    end
+  end
+
+  context 'arrays' do
+    subject do
+      For(a: [1, 2], b: [2, 3], c: [3, 4]) do
+        a * b * c
+      end
+    end
+    it { is_expected.to eq([6, 8, 9, 12, 12, 16, 18, 24]) }
+  end
+
+  context 'ternary' do
+    subject do
+      For(a: first, b: second, c: third) do
+        a * b * c
+      end
+    end
+
+    context 'all Same' do
+      let(:first) { Fear::Some.new(2) }
+      let(:second) { Fear::Some.new(3) }
+      let(:third) { Fear::Some.new(4) }
+
+      it { is_expected.to eq(Fear::Some.new(24)) }
+    end
+
+    context 'first None' do
+      let(:first) { Fear::None.new }
+      let(:second) { Fear::Some.new(3) }
+      let(:third) { Fear::Some.new(4) }
+
+      it { is_expected.to eq(Fear::None.new) }
+    end
+
+    context 'second None' do
+      let(:first) { Fear::Some.new(2) }
+      let(:second) { Fear::None.new }
+      let(:third) { Fear::Some.new(4) }
+
+      it { is_expected.to eq(Fear::None.new) }
+    end
+
+    context 'last None' do
+      let(:first) { Fear::Some.new(2) }
+      let(:second) { Fear::Some.new(3) }
+      let(:third) { Fear::None.new }
+
+      it { is_expected.to eq(Fear::None.new) }
+    end
+  end
+end