zx-monads 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50a07904dbbe8ee15651293ad4e71e863fe3b32de630cdf0743ef34575351ca1
-  data.tar.gz: 11e32540d53a86ce32300fd38d95c10244c35f7601b44e8cce2728a1d83c2185
+  metadata.gz: '0391e47fa921d99cc0295cd52c3dd364a6f2bbe69af850b8cce890f7d74510ab'
+  data.tar.gz: b662943acb8c80009cc12d2322495169aca0bcda8bd52d7d1aa8ae5808f93998
 SHA512:
-  metadata.gz: 81841c32f54a4bf2c22dd33ad1f72a1561c7d29c5b53977bb9641225fbe27116886d3391765643d35b43b3c77755cf58f74360213287e3ddbe443fe9706ecd65
-  data.tar.gz: fe4d63145ecb587180a29e9880036d673d712019854098ff7842afe56a1a27c625f654f9f8dc356f6afce2983ea69e9ad87edc640dd3176e8ccef8304e861256
+  metadata.gz: 4eac7c508d2eeb24fb0cdcda5ef86fe55536773533acb22ff3e4865e0190379ddc723a00f6ed6ee2bae3183040e258cce8740e1f90931fd2064cf9a30ddb36d4
+  data.tar.gz: 47b496f06b771727f6b5d542dda7c303bb178b64253ef6dbbe9d978937671c28a78e433ca312ac488c67cbdf2385781bb5db5fb8016b48ce990d1a81bb9c64b7

data/.github/workflows/ci.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['2.7', '3.0', '3.1', '3.2']
+        ruby-version: ['2.7', '3.0', '3.1', 'head']
 
     steps:
     - uses: actions/checkout@v3

data/.rubocop.yml

@@ -7,7 +7,7 @@ Style/Documentation:
   Enabled: false
 
 Layout:
-  Enabled: false
+  Enabled: true
 
 Style/FrozenStringLiteralComment:
   Enabled: true

data/Gemfile

@@ -1,14 +1,12 @@
 source 'https://rubygems.org'
 
-gem 'base64'
-gem 'json'
 gem 'zeitwerk'
 
 group :development, :test do
+  gem 'byebug'
   gem 'rubocop', github: 'rubocop/rubocop', require: false
 end
 
 group :test do
-  gem 'byebug'
   gem 'rspec'
 end

data/lib/zx/maybe.rb

@@ -1,33 +1,199 @@
 # 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 = ->(*kwargs) { Zx::Maybe::None.new(*kwargs) }
+      Some = ->(*kwargs) { Zx::Maybe::Some.new(*kwargs) }
+      Maybe = ->(*kwargs) { Zx::Maybe.of(*kwargs) }
+
       def Maybe(*kwargs)
-        ::Maybe.of(*kwargs)
+        Zx::Maybe.of(*kwargs)
       end
-      
+
       def Some(*kwargs)
-        ::Maybe::Some.new(*kwargs)
+        Zx::Maybe::Some.new(*kwargs)
       end
-  
+
       def None(*kwargs)
-        ::Maybe::None.new(*kwargs)
+        Zx::Maybe::None.new(*kwargs)
       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
-end
+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.4'
+  VERSION = '0.0.6'
 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.4
+  version: 0.0.6
 platform: ruby
 authors:
 - Thadeu Esteves
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-25 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,170 +0,0 @@
-# frozen_string_literal: true
-
-class Maybe
-  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
-
-  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