bcdd-result 0.6.0 → 0.8.0

data/sig/bcdd/result.rbs

@@ -6,16 +6,19 @@ end
 
 class BCDD::Result
   private attr_accessor unknown: bool
-  private attr_reader type_checker: BCDD::Result::Expectations::TypeChecker
+  private attr_reader type_checker: BCDD::Result::Contract::TypeChecker
 
   attr_reader data: BCDD::Result::Data
   attr_reader subject: untyped
 
+  def self.config: -> BCDD::Result::Config
+  def self.configuration: { (BCDD::Result::Config) -> void } -> BCDD::Result::Config
+
   def initialize: (
     type: Symbol,
     value: untyped,
     ?subject: untyped,
-    ?expectations: BCDD::Result::Expectations::Contract::Evaluator
+    ?expectations: BCDD::Result::Contract::Evaluator
   ) -> void
 
   def type: -> Symbol
@@ -31,7 +34,7 @@ class BCDD::Result
   def on_failure: (*Symbol) { (untyped, Symbol) -> void } -> BCDD::Result
   def on_unknown: () { (untyped, Symbol) -> void } -> BCDD::Result
 
-  def and_then: (?Symbol method_name, ?untyped context) ?{ (untyped) -> untyped } -> BCDD::Result
+  def and_then: (?Symbol method_name, ?untyped context) ?{ (untyped) -> untyped } -> untyped
 
   def handle: () { (BCDD::Result::Handler) -> void } -> untyped
 
@@ -54,21 +57,50 @@ class BCDD::Result
 end
 
 class BCDD::Result
-  class Failure < BCDD::Result
+  class Success < BCDD::Result
+    module Methods
+      def success?: (?Symbol type) -> bool
+      def failure?: (?Symbol type) -> bool
+      def value_or: { () -> untyped } -> untyped
+      def value: -> untyped
+
+      private
+      def name: -> Symbol
+      def type_checker: -> BCDD::Result::Contract::TypeChecker
+    end
+
+    include Methods
   end
 
-  def self.Success: (Symbol type, ?untyped value) -> BCDD::Result::Success
+  def self.Failure: (Symbol type, ?untyped value) -> BCDD::Result::Failure
 end
 
+
 class BCDD::Result
-  class Success < BCDD::Result
+  class Failure < BCDD::Result
+    module Methods
+      def success?: (?Symbol type) -> bool
+      def failure?: (?Symbol type) -> bool
+      def value_or: { (untyped) -> untyped } -> untyped
+      def value: -> untyped
+
+      private
+      def name: -> Symbol
+      def type_checker: -> BCDD::Result::Contract::TypeChecker
+    end
+
+    include Methods
   end
 
-  def self.Failure: (Symbol type, ?untyped value) -> BCDD::Result::Failure
+  def self.Success: (Symbol type, ?untyped value) -> BCDD::Result::Success
 end
 
 class BCDD::Result
   module Mixin
+    module Factory
+      def self.module!: -> Module
+    end
+
     module Methods
       def Success: (Symbol type, ?untyped value) -> BCDD::Result::Success
 
@@ -79,16 +111,22 @@ class BCDD::Result
       module Continuable
         include BCDD::Result::Mixin::Methods
 
-        private def Continue: (untyped) -> BCDD::Result::Success
+        private
+
+        def Continue: (untyped) -> BCDD::Result::Success
       end
 
       OPTIONS: Hash[Symbol, Module]
 
-      def self.options: (Array[Symbol]) -> Array[Module]
+      def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Array[Module]
     end
   end
 
-  def self.mixin: (?with: Array[Symbol]) -> Module
+  def self.mixin: (?config: Hash[Symbol, Hash[Symbol, bool]]) -> Module
+
+  def self.mixin_module: -> singleton(BCDD::Result::Mixin)
+
+  def self.result_factory: -> singleton(BCDD::Result)
 end
 
 class BCDD::Result
@@ -109,7 +147,7 @@ class BCDD::Result
 end
 
 class BCDD::Result
-  class Error < ::StandardError
+  class Error < StandardError
     def self.build: (**untyped) -> BCDD::Result::Error
 
     class NotImplemented < BCDD::Result::Error
@@ -119,18 +157,18 @@ class BCDD::Result
     end
 
     class UnexpectedOutcome < BCDD::Result::Error
-      def self.build: (outcome: untyped, origin: Symbol)
+      def self.build: (outcome: untyped, origin: Symbol, ?expected: String)
           -> BCDD::Result::Error::UnexpectedOutcome
     end
 
-    class WrongResultSubject < BCDD::Result::Error
+    class InvalidResultSubject < BCDD::Result::Error
       def self.build: (given_result: BCDD::Result, expected_subject: untyped)
-          -> BCDD::Result::Error::WrongResultSubject
+          -> BCDD::Result::Error::InvalidResultSubject
     end
 
-    class WrongSubjectMethodArity < BCDD::Result::Error
-      def self.build: (subject: untyped, method: ::Method)
-        -> BCDD::Result::Error::WrongSubjectMethodArity
+    class InvalidSubjectMethodArity < BCDD::Result::Error
+      def self.build: (subject: untyped, method: Method, max_arity: Integer)
+        -> BCDD::Result::Error::InvalidSubjectMethodArity
     end
 
     class UnhandledTypes < BCDD::Result::Error
@@ -146,7 +184,7 @@ class BCDD::Result
 
     def initialize: (
       BCDD::Result,
-      type_checker: BCDD::Result::Expectations::TypeChecker
+      type_checker: BCDD::Result::Contract::TypeChecker
     ) -> void
 
     def []: (*Symbol) { (untyped, Symbol) -> void } -> untyped
@@ -170,10 +208,10 @@ end
 class BCDD::Result::Handler
   class AllowedTypes
     attr_reader unchecked: Set[Symbol]
-    attr_reader type_checker: BCDD::Result::Expectations::TypeChecker
+    attr_reader type_checker: BCDD::Result::Contract::TypeChecker
 
     def initialize: (
-      BCDD::Result::Expectations::TypeChecker
+      BCDD::Result::Contract::TypeChecker
     ) -> void
 
     def allow?: (Array[Symbol]) -> bool
@@ -188,69 +226,32 @@ class BCDD::Result::Handler
   end
 end
 
-class BCDD::Result::Expectations
-  MIXIN_METHODS: String
-
-  def self.mixin: (
-    ?success: Hash[Symbol, untyped] | Array[Symbol],
-    ?failure: Hash[Symbol, untyped] | Array[Symbol]
-  ) -> Module
+module BCDD::Result::Contract
+  NONE: BCDD::Result::Contract::Evaluator
 
   def self.evaluate: (
     BCDD::Result::Data,
-    BCDD::Result::Expectations::Contract::Evaluator
-  ) -> BCDD::Result::Expectations::TypeChecker
-
-  def initialize: (
-    ?subject: untyped,
-    ?success: Hash[Symbol, untyped] | Array[Symbol],
-    ?failure: Hash[Symbol, untyped] | Array[Symbol],
-    ?contract: BCDD::Result::Expectations::Contract::Evaluator
-  ) -> void
-
-  def Success: (Symbol, ?untyped) -> BCDD::Result::Success
-  def Failure: (Symbol, ?untyped) -> BCDD::Result::Failure
-
-  private
-
-  attr_reader subject: untyped
-  attr_reader contract: BCDD::Result::Expectations::Contract::Evaluator
-end
-
-module BCDD::Result::Expectations::Mixin
-  METHODS: String
-
-  module Addons
-    module Continuable
-      private def Continue: (untyped) -> BCDD::Result::Success
-    end
-
-    OPTIONS: Hash[Symbol, Module]
-
-    def self.options: (Array[Symbol]) -> Array[Module]
-  end
-end
+    BCDD::Result::Contract::Evaluator
+  ) -> BCDD::Result::Contract::TypeChecker
 
-module BCDD::Result::Expectations::Contract
-  NONE: BCDD::Result::Expectations::Contract::Evaluator
-
-  ToEnsure: ^(Hash[Symbol, untyped] | Array[Symbol])
-    -> BCDD::Result::Expectations::Contract::Evaluator
+  ToEnsure: ^(Hash[Symbol, untyped] | Array[Symbol], Hash[Symbol, Hash[Symbol, bool]])
+    -> BCDD::Result::Contract::Interface
 
   def self.new: (
     success: Hash[Symbol, untyped] | Array[Symbol],
-    failure: Hash[Symbol, untyped] | Array[Symbol]
-  ) -> BCDD::Result::Expectations::Contract::Evaluator
+    failure: Hash[Symbol, untyped] | Array[Symbol],
+    config: Hash[Symbol, Hash[Symbol, bool]]
+  ) -> BCDD::Result::Contract::Evaluator
 end
 
-class BCDD::Result::Expectations
+module BCDD::Result::Contract
   class TypeChecker
     attr_reader result_type: Symbol
-    attr_reader expectations: BCDD::Result::Expectations::Contract::Evaluator
+    attr_reader expectations: BCDD::Result::Contract::Evaluator
 
     def initialize: (
       Symbol,
-      expectations: BCDD::Result::Expectations::Contract::Evaluator
+      expectations: BCDD::Result::Contract::Evaluator
     ) -> void
 
     def allow?: (Array[Symbol]) -> bool
@@ -261,27 +262,27 @@ class BCDD::Result::Expectations
 
     def validate: (
       Array[Symbol],
-      expected: BCDD::Result::Expectations::Contract::Interface,
+      expected: BCDD::Result::Contract::Interface,
       allow_empty: bool
     ) -> bool
   end
 end
 
-class BCDD::Result::Expectations::Error < BCDD::Result::Error
-  class UnexpectedType < BCDD::Result::Expectations::Error
+class BCDD::Result::Contract::Error < BCDD::Result::Error
+  class UnexpectedType < BCDD::Result::Contract::Error
     def self.build: (type: Symbol, allowed_types: Set[Symbol])
-        -> BCDD::Result::Expectations::Error::UnexpectedType
+        -> BCDD::Result::Contract::Error::UnexpectedType
   end
 
-  class UnexpectedValue < BCDD::Result::Expectations::Error
-    def self.build: (type: Symbol, value: untyped)
-      -> BCDD::Result::Expectations::Error::UnexpectedValue
+  class UnexpectedValue < BCDD::Result::Contract::Error
+    def self.build: (type: Symbol, value: untyped, ?cause: Exception)
+      -> BCDD::Result::Contract::Error::UnexpectedValue
   end
 end
 
-module BCDD::Result::Expectations::Contract
+module BCDD::Result::Contract
   module Interface
-    def ==: (BCDD::Result::Expectations::Contract::Interface) -> bool
+    def ==: (BCDD::Result::Contract::Interface) -> bool
 
     def allowed_types: -> Set[Symbol]
 
@@ -295,7 +296,7 @@ module BCDD::Result::Expectations::Contract
   end
 end
 
-module BCDD::Result::Expectations::Contract
+module BCDD::Result::Contract
   module Disabled
     extend Interface
 
@@ -303,7 +304,7 @@ module BCDD::Result::Expectations::Contract
   end
 end
 
-module BCDD::Result::Expectations::Contract
+module BCDD::Result::Contract
   class ForTypes
     include Interface
 
@@ -311,29 +312,280 @@ module BCDD::Result::Expectations::Contract
   end
 end
 
-module BCDD::Result::Expectations::Contract
+module BCDD::Result::Contract
   class ForTypesAndValues
     include Interface
 
-    def initialize: (Hash[Symbol, untyped]) -> void
+    def initialize: (
+      Hash[Symbol, untyped],
+      Hash[Symbol, Hash[Symbol, bool]]
+    ) -> void
+
+    private
+
+    def nil_as_valid_value_checking?: -> bool
   end
 end
 
-module BCDD::Result::Expectations::Contract
+module BCDD::Result::Contract
   class Evaluator
     include Interface
 
     attr_reader allowed_types: Set[Symbol]
-    attr_reader success: BCDD::Result::Expectations::Contract::Interface
-    attr_reader failure: BCDD::Result::Expectations::Contract::Interface
+    attr_reader success: BCDD::Result::Contract::Interface
+    attr_reader failure: BCDD::Result::Contract::Interface
 
     def initialize: (
-      BCDD::Result::Expectations::Contract::Interface,
-      BCDD::Result::Expectations::Contract::Interface
+      BCDD::Result::Contract::Interface,
+      BCDD::Result::Contract::Interface
     ) -> void
 
     private
 
-    def for: (BCDD::Result::Data) -> BCDD::Result::Expectations::Contract::Interface
+    def for: (BCDD::Result::Data) -> BCDD::Result::Contract::Interface
+  end
+end
+
+class BCDD::Result::Expectations
+  def self.mixin: (
+    ?config: Hash[Symbol, Hash[Symbol, bool]],
+    ?success: Hash[Symbol, untyped] | Array[Symbol],
+    ?failure: Hash[Symbol, untyped] | Array[Symbol]
+  ) -> Module
+
+  def self.mixin!: (
+    ?config: Hash[Symbol, Hash[Symbol, bool]],
+    ?success: Hash[Symbol, untyped] | Array[Symbol],
+    ?failure: Hash[Symbol, untyped] | Array[Symbol]
+  ) -> Module
+
+  def self.mixin_module: -> singleton(BCDD::Result::Expectations::Mixin)
+
+  def self.result_factory_without_expectations: -> singleton(BCDD::Result)
+
+  def self.new: (
+    ?subject: untyped,
+    ?success: Hash[Symbol, untyped] | Array[Symbol],
+    ?failure: Hash[Symbol, untyped] | Array[Symbol],
+    ?contract: BCDD::Result::Contract::Evaluator,
+    ?config: Hash[Symbol, Hash[Symbol, bool]]
+  ) -> (BCDD::Result::Expectations | untyped)
+
+  def initialize: (
+    ?subject: untyped,
+    ?success: Hash[Symbol, untyped] | Array[Symbol],
+    ?failure: Hash[Symbol, untyped] | Array[Symbol],
+    ?contract: BCDD::Result::Contract::Evaluator,
+    ?config: Hash[Symbol, Hash[Symbol, bool]]
+  ) -> void
+
+  def Success: (Symbol, ?untyped) -> BCDD::Result::Success
+  def Failure: (Symbol, ?untyped) -> BCDD::Result::Failure
+
+  def with: (subject: untyped) -> BCDD::Result::Expectations
+
+  private
+
+  attr_reader subject: untyped
+  attr_reader contract: BCDD::Result::Contract::Evaluator
+end
+
+module BCDD::Result::Expectations::Mixin
+  module Factory
+    def self.module!: -> Module
   end
+
+  METHODS: String
+
+  module Addons
+    module Continuable
+      private def Continue: (untyped) -> BCDD::Result::Success
+    end
+
+    OPTIONS: Hash[Symbol, Module]
+
+    def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Array[Module]
+  end
+end
+
+class BCDD::Result::Context < BCDD::Result
+  EXPECTED_OUTCOME: String
+
+  SubjectMethodArity: ^(Method) -> Integer
+
+  attr_reader acc: Hash[Symbol, untyped]
+
+  def initialize: (
+    type: Symbol,
+    value: untyped,
+    ?subject: untyped,
+    ?expectations: BCDD::Result::Contract::Evaluator
+  ) -> void
+
+  def and_then: (?Symbol, **untyped) ?{ (Hash[Symbol, untyped]) -> untyped } -> BCDD::Result::Context
+
+  private
+
+  def call_subject_method: (Symbol, Hash[Symbol, untyped]) -> BCDD::Result::Context
+  def ensure_result_object: (untyped, origin: Symbol) -> BCDD::Result::Context
+
+  def raise_unexpected_outcome_error: (BCDD::Result::Context | untyped, Symbol) -> void
+end
+
+class BCDD::Result::Context
+  class Success < BCDD::Result::Context
+    include BCDD::Result::Success::Methods
+
+    def and_expose: (Symbol, Array[Symbol]) -> BCDD::Result::Context::Success
+  end
+
+  def self.Success: (Symbol, **untyped) -> BCDD::Result::Context::Success
+end
+
+class BCDD::Result::Context
+  class Failure < BCDD::Result::Context
+    include BCDD::Result::Failure::Methods
+
+    def and_expose: (Symbol, Array[Symbol]) -> BCDD::Result::Context::Failure
+  end
+
+  def self.Failure: (Symbol, **untyped) -> BCDD::Result::Context::Failure
+end
+
+class BCDD::Result::Context
+  module Mixin
+    Factory: singleton(BCDD::Result::Mixin::Factory)
+
+    module Methods
+      def Success: (Symbol, **untyped) -> BCDD::Result::Context::Success
+
+      def Failure: (Symbol, **untyped) -> BCDD::Result::Context::Failure
+    end
+
+    module Addons
+      module Continuable
+        include BCDD::Result::Context::Mixin::Methods
+
+        private
+
+        def Continue: (**untyped) -> BCDD::Result::Context::Success
+      end
+
+      OPTIONS: Hash[Symbol, Module]
+
+      def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Array[Module]
+    end
+  end
+
+  def self.mixin_module: -> singleton(BCDD::Result::Context::Mixin)
+
+  def self.result_factory: -> singleton(BCDD::Result::Context)
+end
+
+class BCDD::Result::Context::Expectations < BCDD::Result::Expectations
+  def self.mixin_module: -> singleton(BCDD::Result::Context::Expectations::Mixin)
+
+  def self.result_factory_without_expectations: -> singleton(BCDD::Result)
+
+  def Success: (Symbol, **untyped) -> BCDD::Result::Context::Success
+  def Failure: (Symbol, **untyped) -> BCDD::Result::Context::Failure
+end
+
+module BCDD::Result::Context::Expectations::Mixin
+  METHODS: String
+  Factory: singleton(BCDD::Result::Expectations::Mixin::Factory)
+
+  module Addons
+    module Continuable
+      private def Continue: (**untyped) -> BCDD::Result::Context::Success
+    end
+
+    OPTIONS: Hash[Symbol, Module]
+
+    def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Array[Module]
+  end
+end
+
+class BCDD::Result::Config
+  include Singleton
+
+  ADDON: Hash[Symbol, Hash[Symbol, untyped]]
+  FEATURE: Hash[Symbol, Hash[Symbol, untyped]]
+  PATTERN_MATCHING: Hash[Symbol, Hash[Symbol, untyped]]
+
+  attr_reader addon: BCDD::Result::Config::Switcher
+  attr_reader feature: BCDD::Result::Config::Switcher
+  attr_reader constant_alias: BCDD::Result::Config::Switcher
+  attr_reader pattern_matching: BCDD::Result::Config::Switcher
+
+  def self.instance: -> BCDD::Result::Config
+
+  def initialize: -> void
+
+  def freeze: -> BCDD::Result::Config
+  def options: -> Hash[Symbol, BCDD::Result::Config::Switcher]
+  def to_h: -> Hash[Symbol, Hash[Symbol | String, bool]]
+end
+
+class BCDD::Result::Config::Switcher
+  private attr_reader _affects: Hash[Symbol | String, Array[String]]
+  private attr_reader _options: Hash[Symbol | String, bool]
+  private attr_reader listener: Proc
+
+  def initialize: (
+    options: Hash[Symbol | String, Hash[Symbol, untyped]],
+    ?listener: Proc
+  ) -> void
+
+  def freeze: -> BCDD::Result::Config::Switcher
+
+  def to_h: -> Hash[Symbol | String, bool]
+
+  def options: -> Hash[Symbol | String, Hash[Symbol, untyped]]
+
+  def enabled?: (Symbol | String) -> bool
+
+  def enable!: (*(Symbol | String)) -> Hash[Symbol | String, Hash[Symbol, untyped]]
+
+  def disable!: (*(Symbol | String)) -> Hash[Symbol | String, Hash[Symbol, untyped]]
+
+  private
+
+  def set_many: (Array[Symbol | String], to: bool) -> Hash[Symbol | String, Hash[Symbol, untyped]]
+
+  def set_one: (Symbol | String, bool) -> void
+
+  def require_option!: (Array[Symbol | String]) -> void
+
+  def validate_option!: (Symbol | String) -> void
+
+  def available_options_message: -> String
+end
+
+module BCDD::Result::Config::ConstantAlias
+  RESULT: String
+
+  OPTIONS: Hash[String, Hash[Symbol, untyped]]
+  MAPPING: Hash[String, Hash[Symbol, untyped]]
+  Listener: Proc
+
+  def self.switcher: -> BCDD::Result::Config::Switcher
+end
+
+module BCDD::Result::Config::Options
+  def self.with_defaults: (
+    Hash[Symbol, Hash[Symbol, bool]],
+    Symbol
+  ) -> Hash[Symbol, bool]
+
+  def self.filter_map: (
+    Hash[Symbol, Hash[Symbol, bool]],
+    config: Symbol,
+    from: Hash[Symbol, untyped]
+  ) -> Array[untyped]
+
+  def self.addon: (
+    map: Hash[Symbol, Hash[Symbol, bool]],
+    from: Hash[Symbol, Module]
+  ) -> Array[Module]
 end

metadata

@@ -1,19 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: bcdd-result
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-11 00:00:00.000000000 Z
+date: 2023-12-11 00:00:00.000000000 Z
 dependencies: []
-description: |-
-  Empower Ruby apps with a pragmatic use of Railway Oriented Programming.
-
-  It's a general-purpose result monad that allows you to create objects representing a success (BCDD::Result::Success) or failure (BCDD::Result::Failure).
+description: Empower Ruby apps with pragmatic use of Result monad, Railway Oriented
+  Programming, and B/CDD.
 email:
 - rodrigo.serradura@gmail.com
 executables: []
@@ -28,26 +26,38 @@ files:
 - README.md
 - Rakefile
 - Steepfile
+- lib/bcdd-result.rb
 - lib/bcdd/result.rb
+- lib/bcdd/result/config.rb
+- lib/bcdd/result/config/constant_alias.rb
+- lib/bcdd/result/config/options.rb
+- lib/bcdd/result/config/switcher.rb
+- lib/bcdd/result/context.rb
+- lib/bcdd/result/context/expectations.rb
+- lib/bcdd/result/context/expectations/mixin.rb
+- lib/bcdd/result/context/failure.rb
+- lib/bcdd/result/context/mixin.rb
+- lib/bcdd/result/context/success.rb
+- lib/bcdd/result/contract.rb
+- lib/bcdd/result/contract/disabled.rb
+- lib/bcdd/result/contract/error.rb
+- lib/bcdd/result/contract/evaluator.rb
+- lib/bcdd/result/contract/for_types.rb
+- lib/bcdd/result/contract/for_types_and_values.rb
+- lib/bcdd/result/contract/interface.rb
+- lib/bcdd/result/contract/type_checker.rb
 - lib/bcdd/result/data.rb
 - lib/bcdd/result/error.rb
 - lib/bcdd/result/expectations.rb
-- lib/bcdd/result/expectations/contract.rb
-- lib/bcdd/result/expectations/contract/disabled.rb
-- lib/bcdd/result/expectations/contract/evaluator.rb
-- lib/bcdd/result/expectations/contract/for_types.rb
-- lib/bcdd/result/expectations/contract/for_types_and_values.rb
-- lib/bcdd/result/expectations/contract/interface.rb
-- lib/bcdd/result/expectations/error.rb
 - lib/bcdd/result/expectations/mixin.rb
-- lib/bcdd/result/expectations/type_checker.rb
 - lib/bcdd/result/failure.rb
+- lib/bcdd/result/failure/methods.rb
 - lib/bcdd/result/handler.rb
 - lib/bcdd/result/handler/allowed_types.rb
 - lib/bcdd/result/mixin.rb
 - lib/bcdd/result/success.rb
+- lib/bcdd/result/success/methods.rb
 - lib/bcdd/result/version.rb
-- lib/result.rb
 - sig/bcdd/result.rbs
 homepage: https://github.com/b-cdd/result
 licenses:
@@ -76,5 +86,6 @@ requirements: []
 rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
-summary: A pragmatic result abstraction (monad based) for Ruby.
+summary: Empower Ruby apps with pragmatic use of Result monad, Railway Oriented Programming,
+  and B/CDD.
 test_files: []

data/lib/bcdd/result/expectations/contract/for_types_and_values.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-class BCDD::Result::Expectations
-  class Contract::ForTypesAndValues
-    include Contract::Interface
-
-    def initialize(types_and_values)
-      @types_and_values = types_and_values.transform_keys(&:to_sym)
-
-      @types_contract = Contract::ForTypes.new(@types_and_values.keys)
-    end
-
-    def allowed_types
-      @types_contract.allowed_types
-    end
-
-    def type?(type)
-      @types_contract.type?(type)
-    end
-
-    def type!(type)
-      @types_contract.type!(type)
-    end
-
-    def type_and_value!(data)
-      type = data.type
-      value = data.value
-      allowed_value = @types_and_values[type!(type)]
-
-      return value if allowed_value === value
-
-      raise Error::UnexpectedValue.build(type: type, value: value)
-    rescue NoMatchingPatternError
-      raise Error::UnexpectedValue.build(type: data.type, value: data.value)
-    end
-  end
-end