ramda-ruby 0.12.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b89810eb9aeb97f4360a2ef5cdfff495a46d2495
-  data.tar.gz: 0ef2de2a457e9b889311f4af94a1b7f52c122abf
+  metadata.gz: a9c61500382b8a30650338a2359340adaa39ed58
+  data.tar.gz: b80d5832f21113ddb52436deecdde3971a44f2b4
 SHA512:
-  metadata.gz: e7b826795f824e977f6f9c0b8d8d87bb482bc96b861f3c2ce4e0aa9d81c4c4f15efe3b5f5f0d32ee9abbb8f45342c9d0c548b0fdd9f579453508f8906edb7e12
-  data.tar.gz: cd22adad8b7b4ce649844de486c1a0f6f67daebdd9901a5a9cf9ed8f2d50fab7895b5d903ff39990fd3f1723ebb9a1ef92cc5f7f9a2544ba7615c8074d821317
+  metadata.gz: 11b0927aa3a7d6170bebbf1f5e337d8df033701fa71261c01a55d5e9cbfb31cc72c2a78c7019dcdad7e503368a37165a1bae2cb15681a7f16027ed37f4347fe1
+  data.tar.gz: ef83e01457589590d595e90d78c1a67b283489fd33a4532c21d10f497471994d7660d24868b604767d2cecd5a3b7b65add056cf57d80111448e2314e95d00389

data/CHANGELOG.md

@@ -1,6 +1,18 @@
 Not Released
 ---------------
 
+Added:
+
+* (pending) uncurry_n
+* [adjust](http://ramdajs.com/docs/#adjust)
+* [drop_repeats](http://ramdajs.com/docs/#dropRepeats)
+* [drop_repeats_with](http://ramdajs.com/docs/#dropRepeatsWith)
+* [intersperse](http://ramdajs.com/docs/#intersperse)
+* [mean](http://ramdajs.com/docs/#mean)
+* [median](http://ramdajs.com/docs/#median)
+* [to_string](http://ramdajs.com/docs/#toString)
+* [where_eq](http://ramdajs.com/docs/#whereEq)
+
 Release 0.12.0
 ---------------
 

data/README.md

@@ -4,7 +4,7 @@ Ramda Ruby
 This is a ruby version of [Ramda Js](http://ramdajs.com) library.
 
 [![Gem Version](https://badge.fury.io/rb/ramda-ruby.svg)](http://badge.fury.io/rb/ramda-ruby)
-[![Functions](https://img.shields.io/badge/Functions-178-green.svg)](docs/FUNCTIONS.md)
+[![Functions](https://img.shields.io/badge/Functions-184-green.svg)](docs/FUNCTIONS.md)
 [![Travis badge](https://travis-ci.org/lazebny/ramda-ruby.svg?branch=master)](https://travis-ci.org/lazebny/ramda-ruby)
 [![AppVeyor status](https://ci.appveyor.com/api/projects/status/ponccdax7aj4ufw2?svg=true)](https://ci.appveyor.com/project/lazebny/ramda-ruby)
 [![Coverage Status](https://coveralls.io/repos/lazebny/ramda-ruby/badge.png)](https://coveralls.io/r/lazebny/ramda-ruby)
@@ -59,6 +59,45 @@ Documentation
 You can use Ramda [docs](http://ramdajs.com/docs/) as a documentation
 or to check Ruby [examples](spec/ramda).
 
+
+Algebraic structures
+-------------
+
+Methods which supports algebraic types:
+
+* ap
+* both
+* chain
+* complement
+* either
+* lift
+* lift_n
+* map
+* pluck
+
+Supported libraries ([comparison](docs/FUNCTORS.md)):
+
+* [dry-monads](https://github.com/dry-rb/dry-monads)
+* [kleisli](https://github.com/txus/kleisli)
+
+dry-monads
+
+works with ruby >= 2.1
+
+kleisli works from this fork:
+
+```ruby
+
+gem 'kleisli', git: 'git@github.com:lazebny/kleisli.git', branch: 'ramda-ruby'
+
+```
+
+Differences:
+
+* https://github.com/txus/kleisli/pull/28
+* https://github.com/txus/kleisli/pull/29
+
+
 Usage
 -------------
 
@@ -112,6 +151,30 @@ Transducers:
 
 ```
 
+With algebraic structures:
+
+```ruby
+
+  # ap
+  R.ap(R.ap(Maybe.of(R.add), Maybe.of(3)), Maybe.of(5)) # Some(8)
+
+  # chain
+  R.chain(->(x) { Maybe.of(R.add(5, x)) }, Maybe.of(3)) # Some(8)
+
+  # map
+  R.map(R.add(3), Maybe.of(5)) # Some(8)
+
+  # lift
+  add_m = R.lift(R.add)
+  add_m.call(Maybe.of(3), Maybe.of(5)) # Some(8)
+
+  # lift_n
+  add_m = R.lift_n(3, -> (a, b, c) { a + b + c })
+  add_m.call(Maybe.of(3), Maybe.of(5), Maybe.of(10)) # Some(18)
+
+```
+
+
 Change exceptions handler:
 
 ```ruby
@@ -141,7 +204,7 @@ Enable debug mode:
 
   # Example:
 
-  Ramda.filter(Ramda.curry(->(n) { n.even? }), [1, 2, 3, 4])
+  Ramda.filter(Ramda.curry(:even?.to_proc, [1, 2, 3, 4])
 
   # -> curry(#<Proc:0x...@/srv/app/spec/ramda/list_spec.rb:130 (lambda)>) # #<Proc:0x... (lambda)>
   # -> curry(1) # false
@@ -152,6 +215,10 @@ Enable debug mode:
 
 ```
 
+Resources
+-------------------
+* [Cleaner Ruby validations using the Either monad and Kleisli gem](https://blog.abevoelker.com/you-got-haskell-in-my-ruby-cleaner-ruby-validations-using-either-monad-kleisli-gem/)
+
 
 Benchmarks
 -------------

data/ROADMAP.md

@@ -3,15 +3,6 @@ Release 0.13.0
 
 Release 0.14.0
 ---------------
-* adjust
-* drop_repeats
-* drop_repeats_with
-* intersperse
-* mean
-* median
-* to_string
-* uncurry_n
-* where_eq
 
 Releaes 0.15.0
 ---------------

data/docs/FUNCTIONS.md

@@ -5,6 +5,7 @@
 * (pending) math_mod
 * (pending) pipe_p
 * (pending) to_pairs_in
+* (pending) uncurry_n
 * (pending) values_in
 
 Function
@@ -49,6 +50,7 @@ Function
 List
 ------------
 
+* [adjust](http://ramdajs.com/docs/#adjust)
 * [all](http://ramdajs.com/docs/#all)
 * [any](http://ramdajs.com/docs/#any)
 * [aperture](http://ramdajs.com/docs/#aperture)
@@ -57,6 +59,8 @@ List
 * [concat](http://ramdajs.com/docs/#concat)
 * [contains](http://ramdajs.com/docs/#contains)
 * [drop](http://ramdajs.com/docs/#drop)
+* [drop_repeats](http://ramdajs.com/docs/#dropRepeats)
+* [drop_repeats_with](http://ramdajs.com/docs/#dropRepeatsWith)
 * [drop_while](http://ramdajs.com/docs/#dropWhile)
 * [filter](http://ramdajs.com/docs/#filter) - transducer
 * [find](http://ramdajs.com/docs/#find)
@@ -72,6 +76,7 @@ List
 * [init](http://ramdajs.com/docs/#init)
 * [insert](http://ramdajs.com/docs/#insert)
 * [insert_all](http://ramdajs.com/docs/#insertAll)
+* [intersperse](http://ramdajs.com/docs/#intersperse)
 * [into](http://ramdajs.com/docs/#into)
 * [join](http://ramdajs.com/docs/#join)
 * [last](http://ramdajs.com/docs/#last)
@@ -134,6 +139,8 @@ Math
 * [dec](http://ramdajs.com/docs/#dec)
 * [divide](http://ramdajs.com/docs/#divide)
 * [inc](http://ramdajs.com/docs/#inc)
+* [mean](http://ramdajs.com/docs/#mean)
+* [median](http://ramdajs.com/docs/#median)
 * [modulo](http://ramdajs.com/docs/#modulo)
 * [multiply](http://ramdajs.com/docs/#multiply)
 * [negate](http://ramdajs.com/docs/#negate)
@@ -176,6 +183,7 @@ Object
 * [values](http://ramdajs.com/docs/#values)
 * [view](http://ramdajs.com/docs/#view)
 * [where](http://ramdajs.com/docs/#where)
+* [where_eq](http://ramdajs.com/docs/#whereEq)
 
 
 Relation
@@ -209,6 +217,7 @@ String
 * [split](http://ramdajs.com/docs/#split)
 * [test](http://ramdajs.com/docs/#test)
 * [to_lower](http://ramdajs.com/docs/#toLower)
+* [to_string](http://ramdajs.com/docs/#toString)
 * [to_upper](http://ramdajs.com/docs/#toUpper)
 * [trim](http://ramdajs.com/docs/#trim)
 

data/docs/FUNCTORS.md

@@ -0,0 +1,39 @@
+From [fantasy-land](https://github.com/fantasyland/fantasy-land)
+
+[Functor](https://github.com/fantasyland/fantasy-land#functor)
+---------------
+map :: Functor f => f a ~> (a -> b) -> f b
+
+[Apply](https://github.com/fantasyland/fantasy-land#apply)
+---------------
+ap :: Apply f => f a ~> f (a -> b) -> f b
+
+[Applicative](https://github.com/fantasyland/fantasy-land#applicative)
+---------------
+of :: Applicative f => a -> f a
+
+```javascript
+
+  Array.of = x => [x]
+  Either.of = x => Right(x)
+  Function.of = x => _ => x
+  Maybe.of = x => Just(x)
+  Task.of = x => new Task((_, res) => res(x))
+
+```
+
+[Chain](https://github.com/fantasyland/fantasy-land#Chain)
+---------------
+chain :: Chain m => m a ~> (a -> m b) -> m b
+
+
+Comparison
+---------------
+
+|Language   |Library         |Functor |Apply |Applicative |Chain |
+|-----------|----------------|--------|------|------------|------|
+|Haskel     |out of box      |<$>|fmap|<*>   |pure        |>>=   |
+|JavaScript |ramda-fantasy   |map     |ap    |of          |chain |
+|Ruby       |dry-monads      |fmap    |      |pure        |bind  |
+|Ruby       |kleisli         |fmap    |*     |            |>     |
+|Ruby       |ramda-ruby      |map     |ap    |            |chain |

data/lib/ramda/function.rb

@@ -1,3 +1,4 @@
+require_relative 'internal/class_which_respond_to'
 require_relative 'internal/curried_method'
 require_relative 'internal/dispatchable'
 require_relative 'internal/function_with_arity'
@@ -8,6 +9,7 @@ module Ramda
   module Function
     extend ::Ramda::Internal::CurriedMethod
     extend ::Ramda::Internal::Dispatchable
+    extend ::Ramda::Internal::ClassWhichRespondTo
 
     # Returns a function that always returns the given value. Note that
     # for non-primitives the value returned is a reference to the original
@@ -28,8 +30,19 @@ module Ramda
     # [a -> b] -> [a] -> [b]
     # Apply f => f (a -> b) -> f a -> f b
     #
-    curried(:ap, &dispatchable(:ap, ::Array) do |apply_f, apply_x|
-      apply_f.flat_map { |fn| apply_x.map(&fn) }
+    class_with_ap = class_which_responds_to(:ap)
+    class_with_m = class_which_responds_to(:*)
+    curried(:ap, &dispatchable(:ap, [::Array, class_with_ap, class_with_m]) do |apply_f, apply_x|
+      case apply_f
+      when ::Array
+        apply_f.flat_map { |fn| apply_x.map(&fn) }
+
+      when class_with_ap
+        apply_f.ap(apply_x)
+
+      when class_with_m
+        apply_f * apply_x
+      end
     end)
 
     # Applies function fn to the argument list args. This is useful
@@ -242,7 +255,13 @@ module Ramda
     # Number -> (*... -> *) -> ([*]... -> [*])
     #
     curried_method(:lift_n) do |arity, fn, a, *xs|
-      ([a] + xs).reduce([::Ramda.curry_n(arity, fn)], &::Ramda.ap)
+      # Applicative
+      if a.respond_to?(:ap)
+        xs.reduce(a.map(::Ramda.curry_n(arity, fn)), &::Ramda.ap)
+      # Array
+      else
+        ([a] + xs).reduce([::Ramda.curry_n(arity, fn)], &::Ramda.ap)
+      end
     end
 
     # Creates a new function that, when invoked, caches the result of calling

data/lib/ramda/internal/class_which_respond_to.rb

@@ -0,0 +1,17 @@
+module Ramda
+  module Internal
+    # Defines a class which responds to method and can be used in case construction
+    # for equality check.
+    module ClassWhichRespondTo
+      def class_which_responds_to(*method_names)
+        Class.new do
+          @method_names = method_names
+
+          def self.===(other)
+            @method_names.find(&other.method(:respond_to?))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramda/internal/dispatchable.rb

@@ -3,7 +3,6 @@ module Ramda
     # Dispatchable
     # rubocop:disable Performance/CaseWhenSplat
     # rubocop:disable Metrics/MethodLength
-    # rubocop:disable Style/GuardClause
     module Dispatchable
       #   Returns a function that dispatches with different strategies based on the
       #   object in list position (last argument). If it is an array, executes [fn].
@@ -19,6 +18,7 @@ module Ramda
       #   - @param {Function} fn default ramda implementation
       #   - @return {Function} A function that dispatches on object in list position
       #
+      # Works with fn(arity>1)
       def dispatchable(method_names, described_types, xf = nil, &fn)
         method_names = Array(method_names)
 
@@ -36,11 +36,39 @@ module Ramda
             if method_name
               xs.public_send(method_name, *args)
             else
-              raise ArgumentError, "Unexpected type #{xs.class} in method: #{method_name}"
+              dispatchable_error(xs, method_name)
             end
           end
         end
       end
+
+      # Works with fn(arity=1)
+      def dispatchable1(method_names, described_types, xf = nil, &fn)
+        method_names = Array(method_names)
+
+        FunctionWithArity.call(fn.arity) do |xs|
+          case xs
+          when *described_types # default behaviour
+            yield(xs)
+
+          when Proc # transducer behaviour
+            xf.call(xs)
+
+          else # method dispatch behaviour
+            method_name = method_names.find { |name| xs.respond_to?(name) }
+
+            if method_name
+              xs.public_send(method_name)
+            else
+              dispatchable_error(xs, method_name)
+            end
+          end
+        end
+      end
+
+      def dispatchable_error(xs, method_name)
+        raise ArgumentError, "Unexpected type #{xs.class} in method: #{method_name}"
+      end
     end
   end
 end

data/lib/ramda/internal/functors.rb

@@ -1,5 +1,5 @@
 module Ramda
-  module Internals
+  module Internal
     module Functors
       # `const` is a functor that effectively ignores the function given to `map`.
       class Const
@@ -39,6 +39,77 @@ module Ramda
           @value = value
         end
       end
+
+      # The `Maybe` type represents the possibility of some value or nothing.
+      class Maybe
+        def self.of(x)
+          Some.new(x)
+        end
+
+        # Some value
+        class Some
+          attr_reader :value
+
+          def initialize(value)
+            @value = value
+          end
+
+          def ==(other)
+            instance_of?(other.class) && value == other.value
+          end
+
+          def ap(m)
+            m.map(@value)
+          end
+
+          def chain(f)
+            f.call(@value)
+          end
+
+          def map(f)
+            Maybe.of(f.call(@value))
+          end
+
+          def none?
+            false
+          end
+
+          def some?
+            true
+          end
+        end
+
+        # None value
+        class None
+          attr_reader :value
+
+          def initialize(*); end
+
+          def ==(other)
+            instance_of?(other.class)
+          end
+
+          def ap(_m)
+            self
+          end
+
+          def chain(_f)
+            self
+          end
+
+          def map(_f)
+            self
+          end
+
+          def none?
+            true
+          end
+
+          def some?
+            false
+          end
+        end
+      end
     end
   end
 end