fear 1.0.0 → 2.0.0

data/lib/fear/success.rb

@@ -1,17 +1,11 @@
+# frozen_string_literal: true
+
 module Fear
   class Success
     include Try
     include RightBiased::Right
     include SuccessPatternMatch.mixin
 
-    EXTRACTOR = proc do |try|
-      if Fear::Success === try
-        Fear.some([try.get])
-      else
-        Fear.none
-      end
-    end
-
     attr_reader :value
     protected :value
 
@@ -104,5 +98,10 @@ module Fear
 
     # @return [String]
     alias to_s inspect
+
+    # @return [<any>]
+    def deconstruct
+      [value]
+    end
   end
 end

data/lib/fear/success_pattern_match.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # @api private
   class SuccessPatternMatch < Fear::TryPatternMatch
@@ -7,4 +9,6 @@ module Fear
       self
     end
   end
+
+  private_constant :SuccessPatternMatch
 end

data/lib/fear/try.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # The +Try+ represents a computation that may either result
   # in an exception, or return a successfully computed value. Instances of +Try+,
@@ -112,7 +114,7 @@ module Fear
   #   this is a +Failure+.
   #   @return [Option]
   #   @example
-  #     Fear.success(42).to_option                 #=> Fear.some(21)
+  #     Fear.success(42).to_option                 #=> Fear.some(42)
   #     Fear.failure(ArgumentError.new).to_option  #=> Fear.none()
   #
   # @!method any?(&predicate)
@@ -170,7 +172,7 @@ module Fear
   #   @return [Try]
   #   @example
   #     Fear.success(42).select { |v| v > 40 }
-  #       #=> Fear.success(21)
+  #       #=> Fear.success(42)
   #     Fear.success(42).select { |v| v < 40 }
   #       #=> Fear.failure(Fear::NoSuchElementError.new("Predicate does not hold for 42"))
   #     Fear.failure(ArgumentError.new).select { |v| v < 40 }
@@ -315,3 +317,7 @@ module Fear
     end
   end
 end
+
+require "fear/try_pattern_match"
+require "fear/success"
+require "fear/failure"

data/lib/fear/try_api.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "fear/try"
+
 module Fear
   module TryApi
     # Constructs a +Try+ using the block. This

data/lib/fear/try_pattern_match.rb

@@ -1,18 +1,19 @@
+# frozen_string_literal: true
+
+require "fear/pattern_match"
+
 module Fear
   # Try pattern matcher
   #
   # @note it has two optimized subclasses +Fear::SuccessPatternMatch+ and +Fear::FailurePatternMatch+
   # @api private
   class TryPatternMatch < Fear::PatternMatch
-    SUCCESS_EXTRACTOR = :get.to_proc
-    FAILURE_EXTRACTOR = :exception.to_proc
-
     # Match against +Fear::Success+
     #
     # @param conditions [<#==>]
     # @return [Fear::TryPatternMatch]
     def success(*conditions, &effect)
-      branch = Fear.case(Fear::Success, &SUCCESS_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
+      branch = Fear.case(Fear::Success, &:get).and_then(Fear.case(*conditions, &effect))
       or_else(branch)
     end
 
@@ -21,8 +22,11 @@ module Fear
     # @param conditions [<#==>]
     # @return [Fear::TryPatternMatch]
     def failure(*conditions, &effect)
-      branch = Fear.case(Fear::Failure, &FAILURE_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
+      branch = Fear.case(Fear::Failure, &:exception).and_then(Fear.case(*conditions, &effect))
       or_else(branch)
     end
   end
 end
+
+require "fear/success_pattern_match"
+require "fear/failure_pattern_match"

data/lib/fear/unit.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # Represents lack of value. It's typically returned when function completed without a value.
   #
@@ -17,12 +19,14 @@ module Fear
   Unit = Object.new.tap do |unit|
     # @return [String]
     def unit.to_s
-      '#<Fear::Unit>'
+      "#<Fear::Unit>"
     end
 
     # @return [String]
     def unit.inspect
-      '#<Fear::Unit>'
+      "#<Fear::Unit>"
     end
   end.freeze
+
+  public_constant :Unit
 end

data/lib/fear/utils.rb

@@ -1,7 +1,19 @@
+# frozen_string_literal: true
+
 module Fear
   # @private
   module Utils
+    EMPTY_STRING = ""
+    public_constant :EMPTY_STRING
+
     UNDEFINED = Object.new.freeze
+    public_constant :UNDEFINED
+
+    EMPTY_HASH = {}.freeze
+    public_constant :EMPTY_HASH
+
+    EMPTY_ARRAY = [].freeze
+    public_constant :EMPTY_ARRAY
 
     class << self
       def assert_arg_or_block!(method_name, *args)
@@ -20,13 +32,13 @@ module Fear
 
       def assert_type!(value, *types)
         if types.none? { |type| value.is_a?(type) }
-          raise TypeError, "expected `#{value.inspect}` to be of #{types.join(', ')} class"
+          raise TypeError, "expected `#{value.inspect}` to be of #{types.join(", ")} class"
         end
       end
 
       def return_or_call_proc(value)
         if value.respond_to?(:call)
-          value.call
+          value.()
         else
           value
         end

data/lib/fear/version.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 module Fear
-  VERSION = '1.0.0'.freeze
+  VERSION = "2.0.0"
+  public_constant :VERSION
 end

data/lib/fear.rb

@@ -1,66 +1,48 @@
-require 'fear/either_api'
-require 'fear/extractor_api'
-require 'fear/for_api'
-require 'fear/future_api'
-require 'fear/option_api'
-require 'fear/pattern_matching_api'
-require 'fear/try_api'
-require 'fear/version'
+# frozen_string_literal: true
+
+require "fear/utils"
+require "fear/right_biased"
+require "fear/struct"
+require "fear/unit"
+require "fear/either_api"
+require "fear/for_api"
+require "fear/future_api"
+require "fear/option_api"
+require "fear/pattern_matching_api"
+require "fear/try_api"
+require "fear/version"
 
 module Fear
   Error = Class.new(StandardError)
+  public_constant :Error
+
   IllegalStateException = Class.new(Error)
+  public_constant :IllegalStateException
+
   MatchError = Class.new(Error)
+  public_constant :MatchError
+
   NoSuchElementError = Class.new(Error)
+  public_constant :NoSuchElementError
+
   PatternSyntaxError = Class.new(Error)
+  public_constant :PatternSyntaxError
 
   extend EitherApi
-  extend ExtractorApi
   extend ForApi
   extend FutureApi
   extend OptionApi
   extend PatternMatchingApi
   extend TryApi
 
-  autoload :EmptyPartialFunction, 'fear/empty_partial_function'
-  autoload :PartialFunction, 'fear/partial_function'
-  autoload :PartialFunctionClass, 'fear/partial_function_class'
-  autoload :PatternMatch, 'fear/pattern_match'
-  autoload :Extractor, 'fear/extractor'
-
-  autoload :Unit, 'fear/unit'
-  autoload :For, 'fear/for'
-  autoload :RightBiased, 'fear/right_biased'
-  autoload :Utils, 'fear/utils'
-
-  autoload :None, 'fear/none'
-  autoload :NoneClass, 'fear/none'
-  autoload :NonePatternMatch, 'fear/none_pattern_match'
-  autoload :Option, 'fear/option'
-  autoload :OptionPatternMatch, 'fear/option_pattern_match'
-  autoload :Some, 'fear/some'
-  autoload :SomePatternMatch, 'fear/some_pattern_match'
-
-  autoload :Failure, 'fear/failure'
-  autoload :FailurePatternMatch, 'fear/failure_pattern_match'
-  autoload :Success, 'fear/success'
-  autoload :SuccessPatternMatch, 'fear/success_pattern_match'
-  autoload :Try, 'fear/try'
-  autoload :TryPatternMatch, 'fear/try_pattern_match'
-
-  autoload :Either, 'fear/either'
-  autoload :EitherPatternMatch, 'fear/either_pattern_match'
-  autoload :Left, 'fear/left'
-  autoload :LeftPatternMatch, 'fear/left_pattern_match'
-  autoload :Right, 'fear/right'
-  autoload :RightPatternMatch, 'fear/right_pattern_match'
-
-  autoload :Future, 'fear/future'
-
   module Mixin
     include Either::Mixin
     include For::Mixin
     include Option::Mixin
     include Try::Mixin
   end
+
+  class << self
+    include Mixin
+  end
 end

data/spec/dry/types/fear/option/constrained_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "support/dry_types"
+
+RSpec.describe Dry::Types::Constrained, :option do
+  context "with a option type" do
+    subject(:type) do
+      Dry::Types["nominal.string"].constrained(size: 4).option
+    end
+
+    it_behaves_like "Dry::Types::Nominal without primitive"
+
+    it "passes when constraints are not violated" do
+      expect(type[nil]).to be_none
+      expect(type["hell"]).to be_some_of("hell")
+    end
+
+    it "raises when a given constraint is violated" do
+      expect { type["hel"] }.to raise_error(Dry::Types::ConstraintError, /hel/)
+    end
+  end
+end

data/spec/dry/types/fear/option/core_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "support/dry_types"
+
+RSpec.describe Dry::Types::Nominal, :option do
+  describe "with opt-in option types" do
+    context "with strict string" do
+      let(:string) { Dry::Types["option.strict.string"] }
+
+      it_behaves_like "Dry::Types::Nominal without primitive" do
+        let(:type) { string }
+      end
+
+      it "accepts nil" do
+        expect(string[nil]).to be_none
+      end
+
+      it "accepts a string" do
+        expect(string["something"]).to be_some_of("something")
+      end
+    end
+
+    context "with coercible string" do
+      let(:string) { Dry::Types["option.coercible.string"] }
+
+      it_behaves_like "Dry::Types::Nominal without primitive" do
+        let(:type) { string }
+      end
+
+      it "accepts nil" do
+        expect(string[nil]).to be_none
+      end
+
+      it "accepts a string" do
+        expect(string[:something]).to be_some_of("something")
+      end
+    end
+  end
+
+  describe "defining coercible Option String" do
+    let(:option_string) { Dry::Types["coercible.string"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive" do
+      let(:type) { option_string }
+    end
+
+    it "accepts nil" do
+      expect(option_string[nil]).to be_none
+    end
+
+    it "accepts an object coercible to a string" do
+      expect(option_string[123]).to be_some_of("123")
+    end
+  end
+
+  describe "defining Option String" do
+    let(:option_string) { Dry::Types["strict.string"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive" do
+      let(:type) { option_string }
+    end
+
+    it "accepts nil and returns None instance" do
+      value = option_string[nil]
+
+      expect(value).to be_none
+      expect(value.map(&:downcase).map(&:upcase)).to be_none
+    end
+
+    it "accepts a string and returns Some instance" do
+      value = option_string["SomeThing"]
+
+      expect(value).to be_some_of("SomeThing")
+      expect(value.map(&:downcase).map(&:upcase)).to be_some_of("SOMETHING")
+    end
+  end
+end

data/spec/dry/types/fear/option/default_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "support/dry_types"
+
+RSpec.describe Dry::Types::Nominal, "#default", :option do
+  context "with a maybe" do
+    subject(:type) { Dry::Types["strict.integer"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive" do
+      let(:type) { Dry::Types["strict.integer"].option.default(0) }
+    end
+
+    it "does not allow nil" do
+      expect { type.default(nil) }.to raise_error(ArgumentError, /nil/)
+    end
+
+    it "accepts a non-nil value" do
+      expect(type.default(0)[0]).to be_some_of(0)
+    end
+  end
+end

data/spec/dry/types/fear/option/hash_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "support/dry_types"
+
+RSpec.describe Dry::Types::Hash, :option do
+  let(:email) { Dry::Types["option.strict.string"] }
+
+  context "Symbolized constructor" do
+    subject(:hash) do
+      Dry::Types["nominal.hash"].schema(
+        name: "string",
+        email: email,
+      ).with_key_transform(&:to_sym)
+    end
+
+    describe "#[]" do
+      it "sets None as a default value for option" do
+        result = hash["name" => "Jane"]
+
+        expect(result[:email]).to be_none
+      end
+    end
+  end
+
+  context "Schema constructor" do
+    subject(:hash) do
+      Dry::Types["nominal.hash"].schema(
+        name: "string",
+        email: email,
+      )
+    end
+
+    describe "#[]" do
+      it "sets None as a default value for option types" do
+        result = hash[name: "Jane"]
+
+        expect(result[:email]).to be_none
+      end
+    end
+  end
+
+  context "Strict with defaults" do
+    subject(:hash) do
+      Dry::Types["nominal.hash"].schema(
+        name: "string",
+        email: email,
+      )
+    end
+
+    describe "#[]" do
+      it "sets None as a default value for option types" do
+        result = hash[name: "Jane"]
+
+        expect(result[:email]).to be_none
+      end
+    end
+  end
+end

data/spec/dry/types/fear/option/option_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "support/dry_types"
+
+RSpec.describe Dry::Types::Nominal, "#option", :option do
+  context "with a nominal" do
+    subject(:type) { Dry::Types["nominal.string"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive"
+
+    it "returns None when value is nil" do
+      expect(type[nil]).to be_none
+    end
+
+    it "returns Some when value exists" do
+      expect(type["hello"]).to be_some_of("hello")
+    end
+
+    it "returns original if input is already a option" do
+      expect(type[Fear.some("hello")]).to be_some_of("hello")
+    end
+
+    it "aliases #[] as #call" do
+      expect(type.("hello")).to be_some_of("hello")
+    end
+
+    it "does not have primitive" do
+      expect(type).to_not respond_to(:primitive)
+    end
+  end
+
+  context "with a strict type" do
+    subject(:type) { Dry::Types["strict.integer"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive"
+
+    it "returns None when value is nil" do
+      expect(type[nil]).to be_none
+    end
+
+    it "returns Some when value exists" do
+      expect(type[231]).to be_some_of(231)
+    end
+  end
+
+  context "with a sum" do
+    subject(:type) { Dry::Types["nominal.bool"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive"
+
+    it "returns None when value is nil" do
+      expect(type[nil]).to be_none
+    end
+
+    it "returns Some when value exists" do
+      expect(type[true]).to be_some_of(true)
+      expect(type[false]).to be_some_of(false)
+    end
+
+    it "does not have primitive" do
+      expect(type).to_not respond_to(:primitive)
+    end
+  end
+
+  context "with keys" do
+    subject(:type) do
+      Dry::Types["hash"].schema(foo: Dry::Types["integer"]).key(:foo)
+    end
+
+    it "gets wrapped by key type" do
+      expect(type.option).to be_a(Dry::Types::Schema::Key)
+      expect(type.option[nil]).to be_none
+      expect(type.option[1]).to be_some_of(1)
+    end
+  end
+
+  describe "#try" do
+    subject(:type) { Dry::Types["coercible.integer"].option }
+
+    it "maps successful result" do
+      expect(type.try("1")).to eq(Dry::Types::Result::Success.new(Fear.some(1)))
+      expect(type.try(nil)).to eq(Dry::Types::Result::Success.new(Fear.none))
+      expect(type.try("a")).to be_a(Dry::Types::Result::Failure)
+    end
+  end
+
+  describe "#call" do
+    describe "safe calls" do
+      subject(:type) { Dry::Types["coercible.integer"].option }
+
+      specify do
+        expect(type.("a") { :fallback }).to be(:fallback)
+        expect(type.(Fear.some(1)) { :fallback }).to eq(Fear.some(1))
+      end
+    end
+  end
+end

data/spec/fear/awaitable_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "fear/awaitable"
+
+RSpec.describe Fear::Awaitable do
+  subject(:awaitable) { Object.new.extend(Fear::Awaitable) }
+
+  describe "#__ready__" do
+    it "must implement the method" do
+      expect { awaitable.__ready__(1) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#__result__" do
+    it "must implement the method" do
+      expect { awaitable.__result__(1) }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/fear/done_spec.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Unit do
-  describe '#to_s' do
+  describe "#to_s" do
     subject { described_class.to_s }
 
-    it { is_expected.to eq('#<Fear::Unit>') }
+    it { is_expected.to eq("#<Fear::Unit>") }
   end
 
-  describe '#inspect' do
+  describe "#inspect" do
     subject { described_class.inspect }
 
-    it { is_expected.to eq('#<Fear::Unit>') }
+    it { is_expected.to eq("#<Fear::Unit>") }
   end
 
-  describe '#==' do
+  describe "#==" do
     it { is_expected.to eq(described_class) }
   end
 end

data/spec/fear/either/mixin_spec.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Either::Mixin do
   include Fear::Either::Mixin
 
-  describe 'Left()' do
+  describe "Left()" do
     subject { Left(42) }
 
     it { is_expected.to eq(Fear::Left.new(42)) }
   end
 
-  describe 'Right()' do
+  describe "Right()" do
     subject { Right(42) }
 
     it { is_expected.to eq(Fear::Right.new(42)) }

data/spec/fear/either_pattern_match_spec.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::EitherPatternMatch do
-  context 'Right' do
+  context "Right" do
     let(:matcher) do
       described_class.new do |m|
         m.right(:even?.to_proc) { |x| "#{x} is even" }
@@ -8,15 +10,15 @@ RSpec.describe Fear::EitherPatternMatch do
     end
 
     it do
-      expect(matcher.call(Fear.right(4))).to eq('4 is even')
-      expect(matcher.call(Fear.right(3))).to eq('3 is odd')
+      expect(matcher.(Fear.right(4))).to eq("4 is even")
+      expect(matcher.(Fear.right(3))).to eq("3 is odd")
       expect do
-        matcher.call(Fear.left(44))
+        matcher.(Fear.left(44))
       end.to raise_error(Fear::MatchError)
     end
   end
 
-  context 'Left' do
+  context "Left" do
     let(:matcher) do
       described_class.new do |m|
         m.left(:even?.to_proc) { |x| "#{x} is even" }
@@ -25,10 +27,10 @@ RSpec.describe Fear::EitherPatternMatch do
     end
 
     it do
-      expect(matcher.call(Fear.left(4))).to eq('4 is even')
-      expect(matcher.call(Fear.left(3))).to eq('3 is odd')
+      expect(matcher.(Fear.left(4))).to eq("4 is even")
+      expect(matcher.(Fear.left(3))).to eq("3 is odd")
       expect do
-        matcher.call(Fear.right(44))
+        matcher.(Fear.right(44))
       end.to raise_error(Fear::MatchError)
     end
   end