ramda-ruby 0.12.0 → 0.14.0

data/lib/ramda/internal/integrations.rb

@@ -0,0 +1,48 @@
+# module Ramda
+#   module Internal
+#     module Integrations
+#       module Comparable
+#         def ===(other)
+#           specifications.find(&other.method(:respond_to?))
+#         end
+#       end
+#
+#       class DryMonadsType
+#         extend Comparable
+#
+#         def self.specifications
+#           @specifications ||= [
+#             :bind,
+#             :fmap,
+#             :pure,
+#           ]
+#         end
+#       end
+#
+#       class RamdaFantasyRubyType
+#         extend Comparable
+#
+#         def self.specifications
+#           @specifications ||= [
+#             :ap,
+#             :chain,
+#             :map,
+#             :of
+#           ]
+#         end
+#       end
+#
+#       class KleisliType
+#         extend Comparable
+#
+#         def self.specifications
+#           @specifications ||= [
+#             :'>->',
+#             :*,
+#             :fmap
+#           ]
+#         end
+#       end
+#     end
+#   end
+# end

data/lib/ramda/internal/transducers.rb

@@ -5,36 +5,7 @@ module Ramda
     # Signature: (*, reducing_fn) -> Proc((acc, input) -> acc)
     #
     module Transducers
-      # predicate - fn with 1 arity
-      def self.filter(predicate, reducer)
-        lambda do |acc, x|
-          if predicate.call(x)
-            reducer.call(acc, x)
-          else
-            acc
-          end
-        end
-      end
-
-      # transformer - fn with 1 arity
-      def self.map(transformer, reducer)
-        lambda do |acc, x|
-          reducer.call(acc, transformer.call(x))
-        end
-      end
-
-      # limit - number
-      def self.take(limit, reducer)
-        count = 0
-        lambda do |acc, x|
-          count += 1
-          if limit >= count
-            reducer.call(acc, x)
-          else
-            acc
-          end
-        end
-      end
+      Dir["#{File.dirname(__FILE__)}/transducers/*"].each { |file| require file }
     end
   end
 end

data/lib/ramda/internal/transducers/drop_repeats_transducer.rb

@@ -0,0 +1,19 @@
+module Ramda
+  module Internal
+    module Transducers
+      # Removes repeats from list
+      class DropRepeatsTransducer
+        # No arguments
+        def call(reducer)
+          lambda do |acc, x|
+            if acc.any? && acc.last == x
+              acc
+            else
+              reducer.call(acc, x)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramda/internal/transducers/drop_repeats_with_transducer.rb

@@ -0,0 +1,19 @@
+module Ramda
+  module Internal
+    module Transducers
+      # Remove repeats with based on predicate which receives a, b
+      class DropRepeatsWithTransducer
+        # predicate - fn with 2 arity
+        def call(predicate, reducer)
+          lambda do |acc, x|
+            if acc.any? && predicate.call(acc.last, x)
+              acc
+            else
+              reducer.call(acc, x)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramda/internal/transducers/filter_transdurer.rb

@@ -0,0 +1,19 @@
+module Ramda
+  module Internal
+    module Transducers
+      # Filter list based on predicate which receives x
+      class FilterTransducer
+        # predicate - fn with 1 arity
+        def call(predicate, reducer)
+          lambda do |acc, x|
+            if predicate.call(x)
+              reducer.call(acc, x)
+            else
+              acc
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramda/internal/transducers/map_transducer.rb

@@ -0,0 +1,15 @@
+module Ramda
+  module Internal
+    module Transducers
+      # Transform collection based on transformer
+      class MapTransducer
+        # transformer - fn with 1 arity
+        def call(transformer, reducer)
+          lambda do |acc, x|
+            reducer.call(acc, transformer.call(x))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramda/internal/transducers/take_transducer.rb

@@ -0,0 +1,21 @@
+module Ramda
+  module Internal
+    module Transducers
+      # Returns a head of collection
+      class TakeTransducer
+        # limit - number
+        def call(limit, reducer)
+          count = 0
+          lambda do |acc, x|
+            count += 1
+            if limit >= count
+              reducer.call(acc, x)
+            else
+              acc
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramda/list.rb

@@ -6,11 +6,21 @@ module Ramda
   # List functions
   # rubocop:disable Metrics/ModuleLength
   module List
-    Transducer = ->(method) { ::Ramda::Internal::Transducers.method(method) }
-
     extend ::Ramda::Internal::CurriedMethod
     extend ::Ramda::Internal::Dispatchable
 
+    Trans = ::Ramda::Internal::Transducers
+
+    # Applies a function to the value at the given index of an array,
+    # returning a new copy of the array with the element at the given
+    # index replaced with the result of the function application.
+    #
+    # (a -> a) -> Number -> [a] -> [a]
+    #
+    curried_method(:adjust) do |f, idx, xs|
+      xs.dup.tap { |a| a[idx] = f.call(a[idx]) }
+    end
+
     # Returns true if all elements of the list match the predicate,
     # false if there are any that don't.
     #
@@ -65,7 +75,7 @@ module Ramda
     #
     # Chain m => (a -> m b) -> m a -> m b
     #
-    curried(:chain, &dispatchable([:chain, :bind], ::Array) do |f, xs|
+    curried(:chain, &dispatchable([:chain, :bind, :'>'], ::Array) do |f, xs|
       xs.flat_map(&f)
     end)
 
@@ -105,6 +115,34 @@ module Ramda
       xs[num..-1] || xs.class.new
     end)
 
+    # Returns a new list without any consecutively repeating elements.
+    # R.equals is used to determine equality.
+    #
+    # Acts as a transducer if a transformer is given in list position.
+    #
+    # [a] -> [a]
+    #
+    curried_method(:drop_repeats,
+                   &dispatchable1([], ::Array, Trans::DropRepeatsTransducer.new) do |xs|
+                      xs.chunk { |n| n }.map(&:first)
+                    end)
+
+    # Returns a new list without any consecutively repeating elements.
+    # Equality is determined by applying the supplied predicate to each
+    # pair of consecutive elements.
+    # The first element in a series of equal elements will be preserved.
+    #
+    # Acts as a transducer if a transformer is given in list position.
+    #
+    # (a, a -> Boolean) -> [a] -> [a]
+    #
+    curried_method(:drop_repeats_with,
+                   &dispatchable([], [::Array], Trans::DropRepeatsWithTransducer.new) do |f, xs|
+                      xs.each_with_object([]) do |a, acc|
+                        acc.push(a) unless acc.any? && f.call(acc.last, a)
+                      end
+                    end)
+
     # Returns a new list excluding the leading elements of a given list which
     # satisfy the supplied predicate function. It passes each value to the
     # supplied predicate function, skipping elements while the predicate
@@ -130,13 +168,14 @@ module Ramda
     #
     # Filterable f => (a -> Boolean) -> f a -> f a
     #
-    curried(:filter, &dispatchable(:filter, [::Array, ::Hash], Transducer[:filter]) do |f, xs|
-      if xs.is_a?(Hash)
-        xs.select { |_, value| f.call(value) }
-      else
-        xs.select(&f)
-      end
-    end)
+    curried(:filter,
+            &dispatchable(:filter, [::Array, ::Hash], Trans::FilterTransducer.new) do |f, xs|
+               if xs.is_a?(Hash)
+                 xs.select { |_, value| f.call(value) }
+               else
+                 xs.select(&f)
+               end
+             end)
 
     # Creates a new object from a list key-value pairs. If a key appears in
     # multiple pairs, the rightmost pair is included in the object.
@@ -270,6 +309,19 @@ module Ramda
       xs.dup.insert(index, *elts)
     end
 
+    # Creates a new list with the separator interposed between elements.
+    #
+    # Dispatches to the intersperse method of the second argument, if present.
+    #
+    # a -> [a] -> [a]
+    #
+    curried_method(:intersperse, &dispatchable([:intersperse], ::Array) do |sep, xs|
+      xs.reduce([]) do |acc, a|
+        acc << sep if acc.any?
+        acc << a
+      end
+    end)
+
     # Transforms the items of the list with the transducer and appends
     # the transformed items to the accumulator using an appropriate iterator
     # function based on the accumulator type.
@@ -293,16 +345,13 @@ module Ramda
     curried_method(:into) do |acc, xf, xs|
       rx = case acc
            when ::Array
-             lambda { |arr, x|
-               arr.push(x)
-               arr
-             }
+             ->(arr, x) { arr << x }
            when ::String
              ->(str, x) { "#{str}#{x}" }
            when ::Object
              ->(obj, x) { obj.merge(x) }
            else
-             raise ArgumetError, "Cannot create transformer for #{acc}"
+             raise ArgumetError, "Cannot create default transformer for #{acc}"
            end
       xs.reduce(acc, &xf.call(rx))
     end
@@ -349,14 +398,15 @@ module Ramda
     #
     # Functor f => (a -> b) -> f a -> f b
     #
-    curried(:map, &dispatchable(:map, [::Hash, ::Array], Transducer[:map]) do |f, xs|
-      case xs
-      when ::Hash
-        Hash[xs.map { |k, v| [k, f.call(v)] }]
-      when ::Array
-        xs.map(&f)
-      end
-    end)
+    curried(:map,
+            &dispatchable([:map, :fmap], [::Hash, ::Array], Trans::MapTransducer.new) do |f, xs|
+               case xs
+               when ::Hash
+                 Hash[xs.map { |k, v| [k, f.call(v)] }]
+               when ::Array
+                 xs.map(&f)
+               end
+             end)
 
     # The mapAccum function behaves like a combination of map and reduce;
     # it applies a function to each element of a list, passing
@@ -426,7 +476,7 @@ module Ramda
     # Functor f => k -> f {k: v} -> f v
     #
     curried_method(:pluck) do |key, xs|
-      xs.map { |x| x[key] }
+      Ramda.map(->(x) { x[key] }, xs)
     end
 
     # Returns a new list with the given element at the front, followed by the
@@ -557,9 +607,10 @@ module Ramda
     # Number -> [a] -> [a]
     # Number -> String -> String
     #
-    curried(:take, &dispatchable(:take, [::Array, ::String], Transducer[:take]) do |num, xs|
-      xs[0, num]
-    end)
+    curried(:take,
+            &dispatchable(:take, [::Array, ::String], Trans::TakeTransducer.new) do |num, xs|
+               xs[0, num]
+             end)
 
     # Returns a new list containing the first n elements of a given list,
     # passing each value to the supplied predicate function, and terminating

data/lib/ramda/logic.rb

@@ -51,7 +51,11 @@ module Ramda
     # (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
     #
     curried_method(:both) do |fa, fb|
-      ->(*args) { fa.call(*args) && fb.call(*args) }
+      if fa.is_a?(Proc)
+        ->(*args) { fa.call(*args) && fb.call(*args) }
+      else
+        Ramda.lift(Ramda.and, fa, fb)
+      end
     end
 
     # Takes a function f and returns a function g such that if called with
@@ -63,9 +67,13 @@ module Ramda
     # (*... -> *) -> (*... -> Boolean)
     #
     curried_method(:complement) do |fn|
-      ::Ramda::Internal::FunctionWithArity.call(fn.arity) do |*args|
-        !fn.call(*args)
-      end.curry
+      if fn.is_a?(Proc)
+        ::Ramda::Internal::FunctionWithArity.call(fn.arity) do |*args|
+          !fn.call(*args)
+        end.curry
+      else
+        Ramda.lift(Ramda.not, fn)
+      end
     end
 
     # Returns a function, fn, which encapsulates if/else, if/else, ...
@@ -105,7 +113,11 @@ module Ramda
     # (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean))
     #
     curried_method(:either) do |fa, fb|
-      ->(*args) { fa.call(*args) || fb.call(*args) }
+      if fa.is_a?(Proc)
+        ->(*args) { fa.call(*args) || fb.call(*args) }
+      else
+        ::Ramda.lift(Ramda.or, fa, fb)
+      end
     end
 
     # Creates a function that will process either the onTrue or the onFalse

data/lib/ramda/math.rb

@@ -26,7 +26,7 @@ module Ramda
     # Number -> Number -> Number
     #
     curried_method(:divide) do |a, b|
-      a.to_f / b
+      a.fdiv(b)
     end
 
     # Increments its argument.
@@ -43,6 +43,37 @@ module Ramda
       #  return ((m % p) + p) % p;
     end
 
+    # Returns the mean of the given list of numbers.
+    #
+    # [Number] -> Number
+    #
+    curried_method(:mean) do |xs|
+      size = xs.size
+
+      if size.zero?
+        Float::NAN
+      else
+        xs.reduce(&:+).fdiv(size)
+      end
+    end
+
+    # Returns the median of the given list of numbers.
+    #
+    # [Number] -> Number
+    #
+    curried_method(:median) do |xs|
+      sorted = xs.sort
+      size = sorted.size
+
+      if size.zero?
+        Float::NAN
+      elsif size.odd?
+        sorted[size / 2]
+      else
+        sorted[size / 2 - 1, 2].reduce(&:+).fdiv(2)
+      end
+    end
+
     # Divides the first parameter by the second and returns the remainder.
     #
     # Number -> Number -> Number