zx-monads 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92ddc57d4126dfd37ebaeeb3695eeb9bd32dfedd4a1a973b1eefe6cc9f082f88
-  data.tar.gz: 1baafdd45d22c064368e9a8bd789fed4b23cc4cffb493d903441442e26e47502
+  metadata.gz: 6fad11ef006f65fc1217e5bbf480844d4367b3d7d8f72f486af7c8b3601de4cb
+  data.tar.gz: fca3ee13b064db8da1a706ad749e8af4a3f9ceddfd19876be49eaec28dcadc93
 SHA512:
-  metadata.gz: 9969b07e28b5a4ca988e416bddcde3360e51c6f572b0712c247aedb7f78717e23e9821c2c83a4fafa4bea660e7c20ada2a43c75d07ec6159c09984f27941d471
-  data.tar.gz: 3fffca4170917b53e657cb010727cbdc3fd94f4f752893f01f61022714b5e9fda604b9dac1de3ec11dd642d451ccc6a41427e410894e8105dab63cc05e4c6cb9
+  metadata.gz: 2ccf1a54176be479cb0e09ad8c2bab177668e8d9219bbc4dbe113ee855231d11cb79c3dbc5ece68b9a2d7ab2208b17cb005eb3eb4beff1ef8ee9b21faae9ff6f
+  data.tar.gz: 27430e4a6472dabc923357276cd3c39ca55814ddec4c7f0b6c012f60fedd3bc61080ce9d82428ed095992c96b8087d987a403d30a2fe3abc8cad7c25484c7a29

data/README.md

@@ -68,11 +68,11 @@ class Order
 end
 
 class Order
-  include Zx::Maybe
+  include Zx::Maybeable
 end
 
 class ProcessOrder < Zx::Steps
-  # Maybe included now!
+  # include Zx::Maybeable included now!
 end
 ```
 
@@ -102,35 +102,35 @@ end
 ### ZX::Maybe
 
 ```ruby
-result = Maybe[1] # or Maybe.of(1)
+result = Zx::Maybe[1] # or Maybe.of(1)
 ```
 
 ```ruby
-result = Maybe[nil] # or Maybe.of(nil)
+result = Zx::Maybe[nil] # or Maybe.of(nil)
 ```
 
 ```ruby
-result = Maybe[1].map{ _1 + 2}
+result = Zx::Maybe[1].map{ _1 + 2}
 # -> Some(3)
 ```
 
 ```ruby
-result = Maybe[nil].map{ _1 + 2}
+result = Zx::Maybe[nil].map{ _1 + 2}
 # -> None
 ```
 
 ```ruby
-result = Maybe.of(1).or(2)
+result = Zx::Maybe.of(1).or(2)
 result.or(2) # 1
 ```
 
 ```ruby
-result = Maybe.of(' ').or(2)
+result = Zx::Maybe.of(' ').or(2)
 result.or(2) # 2
 ```
 
 ```ruby
-result = Maybe.of(' ').or(2)
+result = Zx::Maybe.of(' ').or(2)
 result.or(2) # 2
 ```
 
@@ -143,7 +143,7 @@ order = {
   }
 }
 
-price =  Maybe[order]
+price =  Zx::Maybe[order]
   .map { _1[:shopping] }
   .map { _1[:banana] }
   .map { _1[:price] }
@@ -152,13 +152,13 @@ price =  Maybe[order]
 
 # or using #dig
 
-price =  Maybe[order].dig(:shopping, :banana, :price)
+price =  Zx::Maybe[order].dig(:shopping, :banana, :price)
 # -> Some(10.0)
 
-price_none =  Maybe[order].dig(:shopping, :banana, :price_non_exists)
+price_none =  Zx::Maybe[order].dig(:shopping, :banana, :price_non_exists)
 # -> None
 
-price_or =  Maybe[order].dig(:shopping, :banana, :price_non_exists).or(10.0)
+price_or =  Zx::Maybe[order].dig(:shopping, :banana, :price_non_exists).or(10.0)
 # -> Some(10.0)
 ```
 
@@ -167,11 +167,11 @@ class Response
   attr_reader :body
 
   def initialize(new_body)
-    @body = Maybe[new_body]
+    @body = Zx::Maybe[new_body]
   end
 
   def change(new_body)
-    @body = Maybe[new_body]
+    @body = Zx::Maybe[new_body]
   end
 end
 
@@ -182,7 +182,7 @@ response.change({ status: 200 })
 expect(response.body).to be_some
 
 response_status = response.body.match(
-  some: ->(body) { Maybe[body].map { _1.fetch(:status) }.unwrap },
+  some: ->(body) { Zx::Maybe[body].map { _1.fetch(:status) }.unwrap },
   none: -> {}
 )
 ```
@@ -196,7 +196,7 @@ response = Response.new(dump) # It's receive an JSON stringified
 
 module StatusCodeUnwrapModule
   def self.call(body)
-    Maybe[body]
+    Zx::Maybe[body]
       .map{ JSON(_1, symbolize_names: true) }
       .dig(:status, :code)
       .apply(&:to_i)
@@ -215,11 +215,11 @@ expect(response_status).to eq(300)
 You can use `>>` to compose many callables, like this.
 
 ```rb
-sum = ->(x) { Maybe::Some[x + 1] }
+sum = ->(x) { Zx::Maybe::Some[x + 1] }
 
-subtract = ->(x) { Maybe::Some[x - 1] }
+subtract = ->(x) { Zx::Maybe::Some[x - 1] }
 
-result = Maybe[1] >> \
+result = Zx::Maybe[1] >> \
   sum >> \
   subtract
 
@@ -229,11 +229,11 @@ expect(result.unwrap).to eq(1)
 If handle None, no worries.
 
 ```rb
-sum = ->(x) { Maybe::Some[x + 1] }
+sum = ->(x) { Zx::Maybe::Some[x + 1] }
 
-subtract = ->(_) { Maybe::None.new }
+subtract = ->(_) { Zx::Maybe::None.new }
 
-result = Maybe[1] \
+result = Zx::Maybe[1] \
   >> sum \
   >> subtract
 
@@ -243,7 +243,7 @@ expect(result.unwrap).to be_nil
 ```rb
 class Order
   def self.sum(x)
-    Maybe[{ number: x + 1 }]
+    Zx::Maybe[{ number: x + 1 }]
   end
 end
 
@@ -258,7 +258,7 @@ expect(result.unwrap).to be(2)
 
 ```rb
 class Order
-  include Zx::Maybe
+  include Zx::Maybeable
 
   def self.sum(x)
     new.sum(x)
@@ -280,7 +280,7 @@ expect(result.unwrap).to be(2)
 
 ```rb
 class Order
-  include Zx::Maybe
+  include Zx::Maybeable
 
   def self.sum(x)
     new.sum(x)
@@ -305,7 +305,7 @@ expect(number.unwrap).to be(0) # nil.to_i == 0
 
 ```rb
 class Order
-  include Zx::Maybe
+  include Zx::Maybeable
 
   def self.sum(x)
     new.sum(x)
@@ -327,7 +327,7 @@ With default value, in None case.
 
 ```rb
 class Order
-  include Zx::Maybe
+  include Zx::Maybeable
 
   def self.sum(x)
     new.sum(x)
@@ -347,7 +347,7 @@ expect(result.unwrap).to be(2)
 
 ```rb
 class Order
-  include Zx::Maybe
+  include Zx::Maybeable
 
   def self.sum(x)
     new.sum(x)

data/lib/zx/maybe.rb

@@ -1,34 +1,202 @@
 # frozen_string_literal: true
 
 module Zx
-  module Maybe
-    module Maybeable
-      None = ->(*kwargs) { ::Maybe::None.new(*kwargs) }
-      Some = ->(*kwargs) { ::Maybe::Some.new(*kwargs) }
-      Maybe = ->(*kwargs) { ::Maybe.of(*kwargs) }
+  class Maybe
+    attr_reader :value
+
+    IsBlank = ->(value) { value.nil? || value.to_s.strip&.empty? || !value }
+
+    def self.of(...)
+      new.of(...)
+    end
+
+    def self.[](...)
+      of(...)
+    end
+
+    def of(value)
+      return None.new if IsBlank[value]
+
+      Some.new(value)
+    rescue StandardError
+      None.new
+    end
+
+    def type
+      to_s.downcase.to_sym
+    end
+
+    def some?
+      type == :some
+    end
+
+    def none?
+      type == :none
+    end
+
+    def unwrap
+      @value
+    end
+
+    def or(value)
+      IsBlank[@value] ? value : @value
+    end
+
+    def >>(other)
+      self > other
+    end
+    alias | >>
+
+    def fmap(_)
+      self
+    end
+
+    def >(_other)
+      self
+    end
+
+    def map(arg = nil, &block)
+      return Maybe[block.call(@value)] if block_given?
+      return Maybe[arg.arity > 1 ? arg.curry.call(@value) : arg.call(@value)] if arg.respond_to?(:call)
+
+      case arg
+      in None then self
+      in Symbol | String then dig(arg)
+      end
+    rescue StandardError => e
+      None.new(e.message)
+    end
+    alias apply map
+
+    def map!(&block)
+      @value = block.call(@value)
+
+      Maybe[@value]
+    end
+
+    def apply!(...)
+      apply(...).unwrap
+    end
+
+    def dig(...)
+      Maybe[@value&.dig(...)]
+    end
+
+    def dig!(...)
+      dig(...).unwrap
+    end
+
+    def match(some:, none:)
+      case self
+      in Some then some.call(@value)
+      else none.call
+      end
+    end
+
+    def on_success(&block)
+      return self if none?
+
+      block.call(Some[@value])
+
+      self
+    end
+
+    def on_failure(&block)
+      return self if some?
+
+      block.call(None[@value])
+
+      self
+    end
+
+    def on(ontype, &block)
+      case ontype.to_sym
+      when :success then on_success(&block)
+      when :failure then on_failure(&block)
+      end
+    end
+
+    class Some < Maybe
+      def self.[](...)
+        new(...)
+      end
+
+      def initialize(value = nil)
+        @value = value
+      end
+
+      def deconstruct
+        [@value]
+      end
+
+      def inspect
+        format("#<Zx::Maybe::#{self}:0x%x value=%s>", object_id, @value.inspect)
+      end
+
+      def to_s
+        'Some'
+      end
+
+      def >(other)
+        other.respond_to?(:call) ? other.call(@value) : other
+      end
+
+      def fmap(&block)
+        Maybe[block.call(@value)]
+      end
+    end
+
+    class None < Maybe
+      def self.[](...)
+        new(...)
+      end
+
+      def initialize(value = nil)
+        @value = value
+      end
+
+      def deconstruct
+        [nil]
+      end
+
+      def inspect
+        format("#<Zx::Maybe::#{self}:0x%x value=%s>", object_id, @value.inspect)
+      end
+
+      def to_s
+        'None'
+      end
+
+      def map
+        self
+      end
+    end
+
+    module ClassMethods
+      None = ->(value = nil) { Zx::Maybe::None.new(value) }
+      Some = ->(*kwargs) { Zx::Maybe::Some.new(*kwargs) }
+      Maybe = ->(*kwargs) { Zx::Maybe.of(*kwargs) }
 
       def Maybe(*kwargs)
-        ::Maybe.of(*kwargs)
+        Maybe[*kwargs]
       end
 
       def Some(*kwargs)
-        ::Maybe::Some.new(*kwargs)
+        Some[*kwargs]
       end
 
-      def None(*kwargs)
-        ::Maybe::None.new(*kwargs)
+      def None(value = nil)
+        Zx::Maybe.of(value)
       end
 
       def Try(default = nil, options = {})
-        Some yield
+        Some[yield]
       rescue StandardError => e
         None[default || options.fetch(:or, nil)]
       end
     end
-
-    def self.included(klass)
-      klass.include(Maybeable)
-      klass.extend(Maybeable)
-    end
   end
+
+  include Maybe::ClassMethods
+  extend Maybe::ClassMethods
 end

data/lib/zx/maybeable.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Zx::Maybeable
+  include Zx::Maybe::ClassMethods
+  extend Zx::Maybe::ClassMethods
+end

data/lib/zx/steps.rb

@@ -2,7 +2,7 @@
 
 module Zx
   class Steps
-    include Maybe
+    include Zx::Maybeable
 
     class << self
       def step(step)
@@ -19,4 +19,4 @@ module Zx
       list.reduce(Some()) { |result, step| result >> send(step) }
     end
   end
-end
+end

data/lib/zx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zx
-  VERSION = '0.0.5'
+  VERSION = '0.0.7'
 end

data/lib/zx.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 
 module Zx
-  def self.included(klass)
-    klass.include(Maybe::Maybeable)
-    klass.extend(Maybe::Maybeable)
-  end
 end
 
 require 'zeitwerk'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zx-monads
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Thadeu Esteves
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-28 00:00:00.000000000 Z
+date: 2023-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -85,9 +85,9 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- lib/maybe.rb
 - lib/zx.rb
 - lib/zx/maybe.rb
+- lib/zx/maybeable.rb
 - lib/zx/steps.rb
 - lib/zx/version.rb
 - zx-monads.gemspec

data/lib/maybe.rb

@@ -1,173 +0,0 @@
-# frozen_string_literal: true
-
-class Maybe
-  attr_reader :value
-
-  IsBlank = ->(value) { value.nil? || value.to_s.strip&.empty? || !value }
-
-  def self.of(...)
-    new.of(...)
-  end
-
-  def self.[](...)
-    of(...)
-  end
-
-  def of(value)
-    return None.new if IsBlank[value]
-
-    Some.new(value)
-  rescue StandardError
-    None.new
-  end
-
-  def type
-    to_s.downcase.to_sym
-  end
-
-  def some?
-    type == :some
-  end
-
-  def none?
-    type == :none
-  end
-
-  def unwrap
-    @value
-  end
-
-  def or(value)
-    IsBlank[@value] ? value : @value
-  end
-
-  def >>(other)
-    self > other
-  end
-  alias | >>
-
-  def fmap(_)
-    self
-  end
-
-  def >(_other)
-    self
-  end
-
-  def map(arg = nil, &block)
-    return Maybe[block.call(@value)] if block_given?
-    return Maybe[arg.arity > 1 ? arg.curry.call(@value) : arg.call(@value)] if arg.respond_to?(:call)
-
-    case arg
-    in None then self
-    in Symbol | String then dig(arg)
-    end
-  rescue StandardError => e
-    None.new(e.message)
-  end
-  alias apply map
-
-  def map!(&block)
-    @value = block.call(@value)
-
-    Maybe[@value]
-  end
-
-  def apply!(...)
-    apply(...).unwrap
-  end
-
-  def dig(...)
-    Maybe[@value&.dig(...)]
-  end
-
-  def dig!(...)
-    dig(...).unwrap
-  end
-
-  def match(some:, none:)
-    case self
-    in Some then some.call(@value)
-    else none.call
-    end
-  end
-
-  def on_success(&block)
-    return self if none?
-
-    block.call(Some[@value])
-
-    self
-  end
-
-  def on_failure(&block)
-    return self if some?
-
-    block.call(None[@value])
-
-    self
-  end
-
-  def on(ontype, &block)
-    case ontype.to_sym
-    when :success then on_success(&block)
-    when :failure then on_failure(&block)
-    end
-  end
-
-  class Some < Maybe
-    def self.[](...)
-      new(...)
-    end
-
-    def initialize(value = nil)
-      @value = value
-    end
-
-    def deconstruct
-      [@value]
-    end
-
-    def inspect
-      format("#<Zx::Maybe::#{self}:0x%x value=%s>", object_id, @value.inspect)
-    end
-
-    def to_s
-      'Some'
-    end
-
-    def >(other)
-      other.respond_to?(:call) ? other.call(@value) : other
-    end
-
-    def fmap(&block)
-      Maybe[block.call(@value)]
-    end
-  end
-
-  class None < Maybe
-    def self.[](...)
-      new(...)
-    end
-
-    def initialize(value = nil)
-      @value = value
-    end
-
-    def deconstruct
-      [nil]
-    end
-
-    def inspect
-      format("#<Zx::Maybe::#{self}:0x%x value=%s>", object_id, @value.inspect)
-    end
-
-    def to_s
-      'None'
-    end
-
-    def map
-      self
-    end
-  end
-end