create reflect class and add zeitwerk autoloader

Gemfile

@@ -10,4 +10,5 @@ group :test do
   gem 'simplecov', require: false
 end
 
+gem 'zeitwerk'
 gem 'rubocop', github: 'rubocop/rubocop', require: false

lib/zx.rb

@@ -1,21 +1,10 @@
 # frozen_string_literal: true
 
-require 'zx/result'
-
 module Zx
-  module Extendable
-    Success = ->(*kwargs) { Result.Success(*kwargs) }
-    Failure = ->(*kwargs) { Result.Failure(*kwargs) }
-
-    def Success(...)
-      Result.Success(...)
-    end
+end
 
-    def Failure(...)
-      Result.Failure(...)
-    end
-  end
+require 'zeitwerk'
 
-  include Extendable
-  extend Extendable
-end
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.setup
+loader.eager_load

lib/zx/mixin.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Zx
+  module Mixin
+    Success = ->(value = nil, options = {}) { Zx::Result.new.success!(value, options) }
+    Failure = ->(value = nil, options = {}) { Zx::Result.new.failure!(value, options) }
+
+    def Success(value = nil, options = {})
+      Zx::Result.new.success!(value, type: options.fetch(:type, :ok))
+    end
+
+    def Failure(value = nil, options = {})
+      Zx::Result.new.failure!(value, type: options.fetch(:type, :error))
+    end
+
+    def Try(default = nil, options = {})
+      Success[yield]
+    rescue StandardError => e
+      Failure[default || options.fetch(:or, nil)]
+    end
+  end
+end

lib/zx/reflect.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Zx
+  class Reflect
+    attr_accessor :result, :tag
+
+    def initialize(result, tag)
+      self.result = result
+      self.tag = tag
+    end
+
+    def apply(&block)
+      return block.call(result.value, [result.type, result.success?]) if tag.nil?
+
+      block.call(result.value, [result.type, result.success?]) if result.type == tag.to_sym
+    end
+
+    def self.apply(result, tag, &block)
+      new(result, tag).apply(&block)
+    end
+  end
+end

lib/zx/result.rb

@@ -38,23 +38,23 @@ def deconstruct_keys(_)
     end
 
     def on_unknown(&block)
-      __execute__(nil, &block)
+      Reflect.apply(self, nil, &block)
 
       self
     end
 
     def on_success(tag = nil, &block)
       return self if failure?
 
-      __execute__(tag, &block)
+      Reflect.apply(self, tag, &block)
 
       self
     end
 
     def on_failure(tag = nil, &block)
       return self if success?
 
-      __execute__(tag, &block)
+      Reflect.apply(self, tag, &block)
 
       self
     end
@@ -108,46 +108,10 @@ def success!(value = nil, type: :ok)
       self
     end
 
-    def __execute__(tag = nil, &block)
-      return block.call(@value, [@type, @success]) if tag.nil?
-
-      block.call(@value, [@type, @success]) if @type == tag.to_sym
-    end
-    private :__execute__
-
-    def Success(value = nil, options = {})
-      success!(value, type: options.fetch(:type, :ok))
-    end
-
-    def Success!(value = nil, options = {})
-      success!(value, type: options.fetch(:type, :ok))
-    end
-
-    def Failure(value = nil, options = {})
-      failure!(value, type: options.fetch(:type, :error))
-    end
-
-    def Failure!(value = nil, options = {})
-      failure!(value, type: options.fetch(:type, :error))
-    end
-
-    def self.Success(value = nil, options = {})
-      new.success!(value, type: options.fetch(:type, :ok))
-    end
-
-    def self.Success!(...)
-      Success(...)
-    end
-
-    def self.Failure(value = nil, options = {})
-      new.failure!(value, type: options.fetch(:type, :error))
-    end
-
-    def self.Failure!(...)
-      Failure(...)
-    end
-
-    Success = ->(*kwargs) { Success(*kwargs) }
-    Failure = ->(*kwargs) { Failure(*kwargs) }
+    include Mixin
+    extend Mixin
   end
+
+  include Mixin
+  extend Mixin
 end

spec/lib/zx_spec.rb

@@ -10,9 +10,9 @@ def initialize(tax: 0.1)
   def apply(value)
     price = value + (value * @tax)
 
-    return Failure! :priceless if price < 100
+    return Failure :priceless if price < 100
 
-    Success! price: price
+    Success price: price
   end
 end