functional-light-service 0.4.4 → 6.0.0

data/lib/functional-light-service/functional/monad.rb

@@ -1,66 +1,77 @@
-module FunctionalLightService
-  module Monad
-    class NotMonadError < StandardError; end
-
-    # Basicly the `pure` function
-    def initialize(init)
-      @value = join(init)
-    end
-
-    # If the passed value is monad already, get the value to avoid nesting
-    # M[M[A]] is equivalent to M[A]
-    def join(other)
-      if other.is_a? self.class
-        other.value
-      else
-        other
-      end
-    end
-
-    # The functor: takes a function (a -> b) and applies it to the inner value of the monad (Ma),
-    # boxes it back to the same monad (Mb)
-    # fmap :: (a -> b) -> M a -> M b
-    def fmap(proc = nil, &block)
-      result = (proc || block).call(value)
-      self.class.new(result)
-    end
-
-    # The monad: takes a function which returns a monad (of the same type), applies the function
-    # bind :: (a -> Mb) -> M a  -> M b
-    # the self.class, i.e. the containing monad is passed as a second (optional) arg to the function
-    def bind(proc = nil, &block)
-      (proc || block).call(value).tap do |result|
-        # rubocop:disable Style/CaseEquality
-        parent = self.class.superclass === Object ? self.class : self.class.superclass
-        # rubocop:enable Style/CaseEquality
-        unless result.is_a? parent
-          raise NotMonadError, "Expected #{result.inspect} to be an #{parent}"
-        end
-      end
-    end
-    alias :'>>=' :bind
-
-    # Get the underlying value, return in Haskell
-    # return :: M a -> a
-    def value
-      @value
-    end
-
-    def to_s
-      value.to_s
-    end
-
-    # Two monads are equivalent if they are of the same type and when their values are equal
-    def ==(other)
-      return false unless other.is_a? self.class
-
-      @value == other.instance_variable_get(:@value)
-    end
-
-    # Return the string representation of the Monad
-    def inspect
-      pretty_class_name = self.class.name.split('::')[-1]
-      "#{pretty_class_name}(#{value.inspect})"
-    end
-  end
-end
+# frozen_string_literal: true
+
+module FunctionalLightService
+  module Monad
+    class NotMonadError < StandardError; end
+
+    # Basicly the `pure` function
+    def initialize(init)
+      @value = join(init)
+    end
+
+    # If the passed value is monad already, get the value to avoid nesting
+    # M[M[A]] is equivalent to M[A]
+    def join(other)
+      if other.is_a? self.class
+        other.value
+      else
+        other
+      end
+    end
+
+    # The functor: takes a function (a -> b) and applies it to the inner value of the monad (Ma),
+    # boxes it back to the same monad (Mb)
+    # fmap :: (a -> b) -> M a -> M b
+    def fmap(proc = nil, &block)
+      result = (proc || block).call(value)
+      self.class.new(result)
+    end
+
+    # The monad: takes a function which returns a monad (of the same type), applies the function
+    # bind :: (a -> Mb) -> M a  -> M b
+    # the self.class, i.e. the containing monad is passed as a second (optional) arg to the function
+    def bind(proc = nil, &block)
+      (proc || block).call(value).tap do |result|
+        # rubocop:disable Style/CaseEquality
+        parent = self.class.superclass === Object ? self.class : self.class.superclass
+        # rubocop:enable Style/CaseEquality
+        unless result.is_a? parent
+          raise NotMonadError, "Expected #{result.inspect} to be an #{parent}"
+        end
+      end
+    end
+    # rubocop:disable Naming/MethodName
+    alias :'>>=' :bind
+    # rubocop:enable Naming/MethodName
+
+    # Get the underlying value, return in Haskell
+    # return :: M a -> a
+    def value
+      @value
+    end
+
+    def to_s
+      value.to_s
+    end
+
+    # Two monads are equivalent if they are of the same type and when their values are equal
+    def ==(other)
+      return false unless other.is_a? self.class
+
+      @value == other.monad_value
+    end
+
+    # Reader protetto: #value e' privato nelle varianti Nullary (es. None),
+    # ma il confronto tra monadi dello stesso tipo deve poter leggere il valore
+    def monad_value
+      @value
+    end
+    protected :monad_value
+
+    # Return the string representation of the Monad
+    def inspect
+      pretty_class_name = self.class.name.split('::')[-1]
+      "#{pretty_class_name}(#{value.inspect})"
+    end
+  end
+end

data/lib/functional-light-service/functional/null.rb

@@ -1,74 +1,88 @@
-# The simplest NullObject there can be
-class Null
-  class << self
-    def method_missing(m, *args)
-      if m == :new
-        super
-      else
-        Null.instance
-      end
-    end
-
-    def instance
-      @instance ||= new([])
-    end
-
-    def null?
-      true
-    end
-
-    def some?
-      false
-    end
-
-    def mimic(klas)
-      new(klas.instance_methods(false))
-    end
-
-    def ==(other)
-      other.respond_to?(:null?) && other.null?
-    end
-  end
-  private_class_method :new
-
-  def initialize(methods)
-    @methods = methods
-  end
-
-  # implicit conversions
-  def to_str
-    ''
-  end
-
-  def to_ary
-    []
-  end
-
-  def method_missing(m, *args)
-    return self if respond_to?(m)
-
-    super
-  end
-
-  def null?
-    true
-  end
-
-  def some?
-    false
-  end
-
-  def respond_to?(m)
-    return true if @methods.empty? || @methods.include?(m)
-
-    super
-  end
-
-  def inspect
-    'Null'
-  end
-
-  def ==(other)
-    other.respond_to?(:null?) && other.null?
-  end
-end
+# frozen_string_literal: true
+
+# The simplest NullObject there can be
+class Null
+  class << self
+    def method_missing(m, *args)
+      if m == :new
+        super
+      else
+        Null.instance
+      end
+    end
+
+    def respond_to_missing?(m, _include_all = false)
+      m != :new || super
+    end
+
+    def instance
+      FunctionalLightService::Deprecations.warn(
+        "Maybe()/Null are deprecated and will be removed in a future release; " \
+        "use FunctionalLightService::Option (Some/None) instead"
+      )
+      @instance ||= new([])
+    end
+
+    def null?
+      true
+    end
+
+    def some?
+      false
+    end
+
+    def mimic(klas)
+      FunctionalLightService::Deprecations.warn(
+        "Maybe()/Null are deprecated and will be removed in a future release; " \
+        "use FunctionalLightService::Option (Some/None) instead"
+      )
+      new(klas.instance_methods(false))
+    end
+
+    def ==(other)
+      other.respond_to?(:null?) && other.null?
+    end
+  end
+  private_class_method :new
+
+  def initialize(methods)
+    @methods = methods
+  end
+
+  # implicit conversions
+  def to_str
+    ''
+  end
+
+  def to_ary
+    []
+  end
+
+  def method_missing(m, *args)
+    return self if respond_to_missing?(m)
+
+    super
+  end
+
+  def null?
+    true
+  end
+
+  def some?
+    false
+  end
+
+  # Convenzione Ruby: si estende respond_to_missing?, mai respond_to?
+  # (il vecchio override aveva anche la firma sbagliata: mancava include_all)
+  def respond_to_missing?(m, _include_all = false)
+    @methods.empty? || @methods.include?(m) || super
+  end
+
+  def inspect
+    'Null'
+  end
+
+  def ==(other)
+    other.respond_to?(:null?) && other.null?
+  end
+end

data/lib/functional-light-service/functional/option.rb

@@ -1,97 +1,100 @@
-module FunctionalLightService
-  Option = FunctionalLightService.enum do
-    Some(:s)
-    None()
-  end
-
-  class Option
-    class << self
-      def some?(expr)
-        to_option(expr) { expr.nil? }
-      end
-
-      def any?(expr)
-        to_option(expr) { expr.nil? || (expr.respond_to?(:empty?) && expr.empty?) }
-      end
-
-      def to_option(expr)
-        yield(expr) ? None.new : Some.new(expr)
-      end
-
-      def try!
-        yield
-      rescue StandardError
-        None.new
-      end
-    end
-  end
-
-  # rubocop:disable Metrics/BlockLength
-  impl(Option) do
-    def fmap
-      match do
-        Some() { |s| self.class.new(yield(s)) }
-        None() { self }
-      end
-    end
-
-    def map(&fn)
-      match do
-        Some() { |_s| bind(&fn) }
-        None() { self }
-      end
-    end
-
-    def some?
-      is_a? Option::Some
-    end
-
-    def none?
-      is_a? Option::None
-    end
-
-    alias :empty? :none?
-
-    def value_or(n)
-      match do
-        Some() { |s| s }
-        None() { n }
-      end
-    end
-
-    def value_to_a
-      @value
-    end
-
-    def +(other)
-      match do
-        None() { other }
-        Some(where { !other.is_a?(Option) }) { |_| raise TypeError, "Other must be an #{Option}" }
-        Some(where { other.some? }) { |s| Option::Some.new(s + other.value) }
-        Some() { |_| self }
-      end
-    end
-  end
-  # rubocop:enable Metrics/BlockLength
-
-  module Prelude
-    module Option
-      None = FunctionalLightService::Option::None.new
-      Option = FunctionalLightService::Option
-      # rubocop:disable Naming/MethodName
-      def Some(s)
-        FunctionalLightService::Option::Some.new(s)
-      end
-
-      def None
-        FunctionalLightService::Prelude::Option::None
-      end
-
-      def Option
-        FunctionalLightService::Option
-      end
-      # rubocop:enable Naming/MethodName
-      # include Option
-    end
-  end
-end
+# frozen_string_literal: true
+
+module FunctionalLightService
+  Option = FunctionalLightService.enum do
+    Some(:s)
+    None()
+  end
+
+  class Option
+    class Some
+      def initialize(init)
+        raise ArgumentError, "Some cannot wrap nil: use None instead" if init.nil?
+
+        super
+      end
+    end
+
+    class << self
+      def some?(expr)
+        to_option(expr) { expr.nil? }
+      end
+
+      def any?(expr)
+        to_option(expr) { expr.nil? || (expr.respond_to?(:empty?) && expr.empty?) }
+      end
+
+      def to_option(expr)
+        yield(expr) ? None.new : Some.new(expr)
+      end
+
+      def try!
+        yield
+      rescue StandardError
+        None.new
+      end
+    end
+  end
+
+  # Le operazioni usano il dispatch diretto invece del motore match:
+  # stessa semantica, ~2 ordini di grandezza piu veloce (audit, finding 3.1)
+  impl(Option) do
+    def fmap
+      some? ? self.class.new(yield(@value)) : self
+    end
+
+    def map(&fn)
+      some? ? bind(&fn) : self
+    end
+
+    def some?
+      is_a? Option::Some
+    end
+
+    def none?
+      is_a? Option::None
+    end
+
+    alias :empty? :none?
+
+    def value_or(n)
+      some? ? @value : n
+    end
+
+    def value_to_a
+      @value
+    end
+
+    def +(other)
+      FunctionalLightService::Deprecations.warn(
+        "Option#+ is deprecated and will be removed in a future release; " \
+        "combine the two options explicitly"
+      )
+      return other if none?
+      raise TypeError, "Other must be an #{Option}" unless other.is_a?(Option)
+
+      other.some? ? Option::Some.new(@value + other.value) : self
+    end
+  end
+
+  module Prelude
+    module Option
+      None = FunctionalLightService::Option::None.new
+      Option = FunctionalLightService::Option
+      # rubocop:disable Naming/MethodName
+      def Some(s)
+        FunctionalLightService::Option::Some.new(s)
+      end
+
+      def None
+        FunctionalLightService::Prelude::Option::None
+      end
+
+      def Option
+        FunctionalLightService::Option
+      end
+      # rubocop:enable Naming/MethodName
+      # include Option
+    end
+  end
+end