ramda-ruby 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87c6a7c3172da72254170f7d90c79f3837e8a74e
-  data.tar.gz: 0f57eed0c3497ed9da5725a72f7efa279e475473
+  metadata.gz: 65ad97e5bb00333847f6a7705f72b84ae81f7549
+  data.tar.gz: 2aab392d448af389c478cf44c1a3f5639d8948b0
 SHA512:
-  metadata.gz: a89e53d9df3f0f65620cc5be1b85addb80b7940d2fa56b7866c5b9a3fb31125e8f928da57ea3f0a12bc46b8be55bd8fa47b5c5ec2a2030feeac904a3ed4ec1c7
-  data.tar.gz: 7645cde2e138e671dff744fda5c108284e7d4def28de3399770faf03d1cfc3e29cd023143d5cdef1e8b52f5268c27a6d85bbb5bd6f475e8e2ca84eac2d4a44b7
+  metadata.gz: 5ba02e63aeb102d71134428662f1eb7574bee6f6bb57e8befa70616272fc05d7e635b4023ceae1811232069abe9b2a83e4f1afc424e8cd7c4ee277a8954651a0
+  data.tar.gz: e9e6e79f2b65392162157d504813a20caa3116b9096f1e2c369d709b3c4c650b9039604f5840a02c6a33edcb18ba903305b27d1d05340c3c8549093c0237c2a6

data/CHANGELOG.md

@@ -1,6 +1,23 @@
 Not Released
 ---------------
 
+Release 0.10.0
+---------------
+
+Added:
+
+* (pending) compose_p
+* (pending) pipe_p
+* (pending) map_accum
+* (pending) map_accum_right
+* default_to
+* merge_all
+* partial
+* partial_right
+* scan
+* unfold
+
+
 Release 0.9.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-164-green.svg)](docs/FUNCTIONS.md)
+[![Functions](https://img.shields.io/badge/Functions-170-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)
@@ -168,15 +168,40 @@ bundle exec rake ramda:run_benchmark_to_file[bench/list/*]
 Development
 --------------
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+You can use either regular approach with installing gems on local machine
+or with docker-compose which is handy when you are playing with ruby versions.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+With docker-compose:
+
+1. Install [Docker](https://docs.docker.com/engine/installation/)
+2. Install [Docker Compose](https://docs.docker.com/compose/install/)
+3. Run tests
+
+```sh
+
+touch .bashrc.docker .pry_history.docker
+docker-compose run --rm app bash
+bundle
+rspec
+
+```
+
+To release a new version, update the version number in `version.rb`,
+and then run `bundle exec rake release`, which will create a git tag
+for the version, push git commits and tags, and push the `.gem` file
+to [rubygems.org](https://rubygems.org).
 
 
 Contributing
 --------------
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/lazebny/ramda-ruby.
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Make changes
+4. Check with Rubocop and resolve all issues(`rubocop -aD`)
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create new Pull Request
 
 
 License

data/ROADMAP.md

@@ -1,16 +1,3 @@
-Release 0.10.0
----------------
-* compose_p
-* default_to
-* map_accum
-* map_accum_right
-* merge_all
-* partial
-* partial_right
-* pipe_p
-* scan
-* unfold
-
 Release 0.11.0
 ---------------
 * dissoc_path

data/docs/FUNCTIONS.md

@@ -1,168 +1,212 @@
+* (pending) compose_p
 * (pending) keys_in
+* (pending) map_accum
+* (pending) map_accum_right
 * (pending) math_mod
+* (pending) pipe_p
 * (pending) to_pairs_in
 * (pending) values_in
-* F
-* T
-* `__` - first function call should have all arguments `g(__2, __)(1, 3)`, this means that it doesn't support `g(__, 2)(1)(3)`, `g(__, 2)(1, 3)` and `g(__, 2)(__, 3)(1)`
-* add
-* all
-* all_pass
-* always
-* and
-* any
-* any_pass
-* ap
-* append
-* apply
-* assoc
-* assoc_path
-* binary
-* bind
-* call
-* chain
-* clone
-* comparator
-* complement
-* compose
-* concat
-* cond
-* construct
-* construct_n
-* contains
-* converge
-* count_by
-* curry
-* curry_n
-* dec
-* difference
-* difference_with
-* dissoc
-* divide
-* drop
-* drop_while
-* empty - uses x.class.new for defining new empty object if empty method does not exist
-* eq_by
-* eq_props
-* equals
-* evolve
-* filter
-* find
-* find_index - returns nil if index doesn't exist
-* find_last
-* find_last_index - returns nil if index doesn't exist
-* flatten
-* flip
-* for_each
-* from_pairs
-* group_by
-* gt
-* gte
-* has
-* has_in
-* head
-* identity
-* if_else
-* inc
-* index_of - returns nil if index doesn't exist
-* init
-* insert
-* insert_all
-* intersection
-* invert
-* invert_obj
-* invoker
-* is
-* is_empty
-* is_nil
-* join
-* juxt
-* keys
-* last
-* last_index_of - returns nil if index doesn't exist
-* length
-* lens - composition does not work compose(lens1, lensb)
-* lens_index
-* lens_path
-* lens_prop
-* lift
-* lift_n
-* lt
-* lte
-* map
-* map_obj_indexed
-* match
-* max
-* max_by
-* memoize
-* merge
-* min
-* min_by
-* modulo
-* multiply
-* n_ary
-* negate
-* not
-* nth
-* nth_arg
-* of
-* omit
-* once
-* or
-* over
-* partition
-* path
-* path_eq
-* pick
-* pick_all
-* pick_by
-* pipe
-* pluck
-* prepend
-* product
-* project
-* prop
-* prop_eq
-* prop_or
-* props
-* range
-* reduce
-* reduce_right
-* reject
-* remove
-* repeat
-* replace - it uses a gsub method and global replacement
-* reverse
-* set
-* slice
-* sort
-* sort_by
-* split
-* subtract
-* sum
-* tail
-* take
-* take_while
-* tap
-* times
-* to_lower
-* to_pairs
-* to_upper
-* trim
-* type
-* unapply
-* unary
-* union
-* union_with
-* uniq
-* uniq_with - first argument is a function with 1 arity which transforms each list element and applies uniq function to results
-* unnest
-* update
-* use_with
-* values
-* view
-* where
-* xprod
-* zip
-* zip_obj
-* zip_with
+
+Function
+------------
+
+* [F](http://ramdajs.com/docs/#F)
+* [T](http://ramdajs.com/docs/#T)
+* [`__`](http://ramdajs.com/docs/) - first function call should have all arguments `g(__2, __)(1, 3)`, this means that it doesn't support `g(__, 2)(1)(3)`, `g(__, 2)(1, 3)` and `g(__, 2)(__, 3)(1)`
+* [always](http://ramdajs.com/docs/#always)
+* [ap](http://ramdajs.com/docs/#ap)
+* [apply](http://ramdajs.com/docs/#apply)
+* [binary](http://ramdajs.com/docs/#binary)
+* [bind](http://ramdajs.com/docs/#bind)
+* [call](http://ramdajs.com/docs/#call)
+* [comparator](http://ramdajs.com/docs/#comparator)
+* [compose](http://ramdajs.com/docs/#compose)
+* [construct](http://ramdajs.com/docs/#construct)
+* [construct_n](http://ramdajs.com/docs/#constructN)
+* [converge](http://ramdajs.com/docs/#converge)
+* [curry](http://ramdajs.com/docs/#curry)
+* [curry_n](http://ramdajs.com/docs/#curryN)
+* [empty](http://ramdajs.com/docs/#empty) - uses x.class.new for defining new empty object if empty method does not exist
+* [flip](http://ramdajs.com/docs/#flip)
+* [identity](http://ramdajs.com/docs/#identity)
+* [invoker](http://ramdajs.com/docs/#invoker)
+* [juxt](http://ramdajs.com/docs/#juxt)
+* [lift](http://ramdajs.com/docs/#lift)
+* [lift_n](http://ramdajs.com/docs/#liftN)
+* [memoize](http://ramdajs.com/docs/#memoize)
+* [n_ary](http://ramdajs.com/docs/#nAry)
+* [nth_arg](http://ramdajs.com/docs/#nthArg)
+* [of](http://ramdajs.com/docs/#cond)
+* [once](http://ramdajs.com/docs/#once)
+* [partial](http://ramdajs.com/docs/#partial)
+* [partial_right](http://ramdajs.com/docs/#partialRight)
+* [pipe](http://ramdajs.com/docs/#pipe)
+* [tap](http://ramdajs.com/docs/#tap)
+* [unapply](http://ramdajs.com/docs/#unapply)
+* [unary](http://ramdajs.com/docs/#unary)
+* [use_with](http://ramdajs.com/docs/#useWith)
+
+List
+------------
+
+* [all](http://ramdajs.com/docs/#all)
+* [any](http://ramdajs.com/docs/#any)
+* [append](http://ramdajs.com/docs/#append)
+* [chain](http://ramdajs.com/docs/#chain)
+* [concat](http://ramdajs.com/docs/#concat)
+* [contains](http://ramdajs.com/docs/#contains)
+* [drop](http://ramdajs.com/docs/#drop)
+* [drop_while](http://ramdajs.com/docs/#dropWhile)
+* [filter](http://ramdajs.com/docs/#filter)
+* [find](http://ramdajs.com/docs/#find)
+* [find_index](http://ramdajs.com/docs/#findIndex) - returns nil if index doesn't exist
+* [find_last](http://ramdajs.com/docs/#findLast)
+* [find_last_index](http://ramdajs.com/docs/#findLastIndex) - returns nil if index doesn't exist
+* [flatten](http://ramdajs.com/docs/#flatten)
+* [for_each](http://ramdajs.com/docs/#forEach)
+* [from_pairs](http://ramdajs.com/docs/#fromPairs)
+* [group_by](http://ramdajs.com/docs/#groupBy)
+* [head](http://ramdajs.com/docs/#head)
+* [index_of](http://ramdajs.com/docs/#indexOf) - returns nil if index doesn't exist
+* [init](http://ramdajs.com/docs/#init)
+* [insert](http://ramdajs.com/docs/#insert)
+* [insert_all](http://ramdajs.com/docs/#insertAll)
+* [join](http://ramdajs.com/docs/#join)
+* [last](http://ramdajs.com/docs/#last)
+* [last_index_of](http://ramdajs.com/docs/#lastIndexOf) - returns nil if index doesn't exist
+* [length](http://ramdajs.com/docs/#length)
+* [map](http://ramdajs.com/docs/#map)
+* [map_obj_indexed](http://ramdajs.com/docs/#mapObjIndexed)
+* [merge_all](http://ramdajs.com/docs/#mergeAll)
+* [nth](http://ramdajs.com/docs/#nth)
+* [partition](http://ramdajs.com/docs/#partition)
+* [pluck](http://ramdajs.com/docs/#pluck)
+* [prepend](http://ramdajs.com/docs/#prepend)
+* [range](http://ramdajs.com/docs/#range)
+* [reduce](http://ramdajs.com/docs/#reduce)
+* [reduce_right](http://ramdajs.com/docs/#reduceRight)
+* [reject](http://ramdajs.com/docs/#reject)
+* [remove](http://ramdajs.com/docs/#remove)
+* [repeat](http://ramdajs.com/docs/#repeat)
+* [reverse](http://ramdajs.com/docs/#reverse)
+* [scan](http://ramdajs.com/docs/#scan)
+* [slice](http://ramdajs.com/docs/#slice)
+* [sort](http://ramdajs.com/docs/#sort)
+* [sort_by](http://ramdajs.com/docs/#sortBy)
+* [tail](http://ramdajs.com/docs/#tail)
+* [take](http://ramdajs.com/docs/#take)
+* [take_while](http://ramdajs.com/docs/#takeWhile)
+* [times](http://ramdajs.com/docs/#times)
+* [unfold](http://ramdajs.com/docs/#unfold)
+* [uniq](http://ramdajs.com/docs/#uniq)
+* [uniq_with](http://ramdajs.com/docs/#uniqWith) - first argument is a function with 1 arity which transforms each list element and applies uniq function to results
+* [unnest](http://ramdajs.com/docs/#unnest)
+* [update](http://ramdajs.com/docs/#update)
+* [xprod](http://ramdajs.com/docs/#xprod)
+* [zip](http://ramdajs.com/docs/#zip)
+* [zip_obj](http://ramdajs.com/docs/#zipObj)
+* [zip_with](http://ramdajs.com/docs/#zipWith)
+
+Logic
+------------
+
+* [all_pass](http://ramdajs.com/docs/#allPass)
+* [and](http://ramdajs.com/docs/#and)
+* [any_pass](http://ramdajs.com/docs/#anyPass)
+* [complement](http://ramdajs.com/docs/#complement)
+* [cond](http://ramdajs.com/docs/#cond)
+* [default_to](http://ramdajs.com/docs/#defaultTo)
+* [if_else](http://ramdajs.com/docs/#ifElse)
+* [is_empty](http://ramdajs.com/docs/#isEmpty)
+* [not](http://ramdajs.com/docs/#not)
+* [or](http://ramdajs.com/docs/#or)
+
+Math
+------------
+
+* [add](http://ramdajs.com/docs/#add)
+* [dec](http://ramdajs.com/docs/#dec)
+* [divide](http://ramdajs.com/docs/#divide)
+* [inc](http://ramdajs.com/docs/#inc)
+* [modulo](http://ramdajs.com/docs/#modulo)
+* [multiply](http://ramdajs.com/docs/#multiply)
+* [negate](http://ramdajs.com/docs/#negate)
+* [product](http://ramdajs.com/docs/#product)
+* [subtract](http://ramdajs.com/docs/#substract)
+* [sum](http://ramdajs.com/docs/#sum)
+
+Object
+------------
+
+* [assoc](http://ramdajs.com/docs/#assoc)
+* [assoc_path](http://ramdajs.com/docs/#assocPath)
+* [clone](http://ramdajs.com/docs/#clone)
+* [dissoc](http://ramdajs.com/docs/#dissoc)
+* [eq_props](http://ramdajs.com/docs/#eqProps)
+* [evolve](http://ramdajs.com/docs/#evolve)
+* [has](http://ramdajs.com/docs/#has)
+* [has_in](http://ramdajs.com/docs/#hasIn)
+* [invert](http://ramdajs.com/docs/#invert)
+* [invert_obj](http://ramdajs.com/docs/#invertObj)
+* [keys](http://ramdajs.com/docs/#keys)
+* [lens](http://ramdajs.com/docs/#lens) - composition does not work compose(lens1, lensb)
+* [lens_index](http://ramdajs.com/docs/#lensIndex)
+* [lens_path](http://ramdajs.com/docs/#lensPath)
+* [lens_prop](http://ramdajs.com/docs/#lensProp)
+* [merge](http://ramdajs.com/docs/#merge)
+* [omit](http://ramdajs.com/docs/#omit)
+* [over](http://ramdajs.com/docs/#over)
+* [path](http://ramdajs.com/docs/#path)
+* [pick](http://ramdajs.com/docs/#pick)
+* [pick_all](http://ramdajs.com/docs/#pickAll)
+* [pick_by](http://ramdajs.com/docs/#pickBy)
+* [project](http://ramdajs.com/docs/#project)
+* [prop](http://ramdajs.com/docs/#prop)
+* [prop_or](http://ramdajs.com/docs/#propOr)
+* [props](http://ramdajs.com/docs/#props)
+* [set](http://ramdajs.com/docs/#set)
+* [to_pairs](http://ramdajs.com/docs/#toPairs)
+* [values](http://ramdajs.com/docs/#values)
+* [view](http://ramdajs.com/docs/#view)
+* [where](http://ramdajs.com/docs/#where)
+
+
+Relation
+------------
+
+* [count_by](http://ramdajs.com/docs/#countBy)
+* [difference](http://ramdajs.com/docs/#difference)
+* [difference_with](http://ramdajs.com/docs/#differenceWith)
+* [eq_by](http://ramdajs.com/docs/#eqBy)
+* [equals](http://ramdajs.com/docs/#equals)
+* [gt](http://ramdajs.com/docs/#gt)
+* [gte](http://ramdajs.com/docs/#gte)
+* [intersection](http://ramdajs.com/docs/#intersection)
+* [lt](http://ramdajs.com/docs/#lt)
+* [lte](http://ramdajs.com/docs/#lte)
+* [max](http://ramdajs.com/docs/#max)
+* [max_by](http://ramdajs.com/docs/#maxBy)
+* [min](http://ramdajs.com/docs/#min)
+* [min_by](http://ramdajs.com/docs/#minBy)
+* [path_eq](http://ramdajs.com/docs/#pathEq)
+* [prop_eq](http://ramdajs.com/docs/#propEq)
+* [sort_by](http://ramdajs.com/docs/#sortBy)
+* [union](http://ramdajs.com/docs/#union)
+* [union_with](http://ramdajs.com/docs/#unionWith)
+
+String
+------------
+
+* [match](http://ramdajs.com/docs/#math)
+* [replace](http://ramdajs.com/docs/#replace) - it uses a gsub method and global replacement
+* [split](http://ramdajs.com/docs/#split)
+* [to_lower](http://ramdajs.com/docs/#toLower)
+* [to_upper](http://ramdajs.com/docs/#toUpper)
+* [trim](http://ramdajs.com/docs/#trim)
+
+Type
+------------
+
+* [is](http://ramdajs.com/docs/#is)
+* [is_nil](http://ramdajs.com/docs/#isNil)
+* [type](http://ramdajs.com/docs/#type)

data/lib/ramda/function.rb

@@ -27,10 +27,10 @@ module Ramda
     # Apply f => f (a -> b) -> f a -> f b
     #
     curried_method(:ap) do |apply_f, apply_x|
-      if apply_x.respond_to?(:ap)
-        apply_x.ap(apply_f)
-      else
+      if apply_x.is_a?(Array)
         apply_f.flat_map { |fn| apply_x.map(&fn) }
+      else
+        Internal::Dispatchable.call([:ap], nil, apply_f, apply_x)
       end
     end
 
@@ -308,6 +308,26 @@ module Ramda
       end.curry
     end
 
+    # Takes a function f and a list of arguments, and returns a function g.
+    # When applied, g returns the result of applying f to the arguments
+    # provided initially followed by the arguments provided to g.
+    #
+    # ((a, b, c, ..., n) -> x) -> [a, b, c, ...] -> ((d, e, f, ..., n) -> x)
+    #
+    curried_method(:partial) do |fn, args|
+      Ramda.curry(fn).call(*args)
+    end
+
+    # Takes a function f and a list of arguments, and returns a function g.
+    # When applied, g returns the result of applying f to the arguments
+    # provided to g followed by the arguments provided initially.
+    #
+    # ((a, b, c, ..., n) -> x) -> [d, e, f, ..., n] -> ((a, b, c, ...) -> x)
+    #
+    curried_method(:partial_right) do |fn, args|
+      Ramda.curry(fn).call(*Array.new(fn.arity - args.size, Ramda.__) + args)
+    end
+
     # Performs left-to-right function composition. The leftmost function may
     # have any arity; the remaining functions must be unary.
     # In some libraries this function is named sequence.

data/lib/ramda/internal/dispatchable.rb

@@ -0,0 +1,28 @@
+module Ramda
+  module Internal
+    # Dispatchable
+    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].
+      #   Otherwise, if it has a  function with [methodname], it will execute that
+      #   function (functor case). Otherwise, if it is a transformer, uses transducer
+      #   [xf] to return a new transformer (transducer case). Otherwise, it will
+      #   default to executing [fn].
+      #
+      #   @private
+      #   - @param {String} methodname property to check for a custom implementation
+      #   - @param {Function} xf transducer to initialize if object is transformer
+      #   - @param {Function} fn default ramda implementation
+      #   - @return {Function} A function that dispatches on object in list position
+      #
+      def self.call(method_names, _xf, *args, xs)
+        method_name = method_names.find { |name| xs.respond_to?(name) }
+
+        return xs.public_send(method_name, *args) if method_name
+
+        raise ArgumentError, "Unexpected type #{xs.class} in method: #{method_name}"
+      end
+    end
+  end
+end

data/lib/ramda/list.rb

@@ -1,4 +1,5 @@
 require_relative 'internal/curried_method'
+require_relative 'internal/dispatchable'
 
 module Ramda
   # List functions
@@ -8,24 +9,36 @@ module Ramda
 
     # Returns true if all elements of the list match the predicate,
     # false if there are any that don't.
+    #
     # Dispatches to the all method of the second argument, if present.
+    #
     # Acts as a transducer if a transformer is given in list position.
     #
     # (a -> Boolean) -> [a] -> Boolean
     #
     curried_method(:all) do |f, xs|
-      xs.all?(&f)
+      if xs.is_a?(::Array)
+        xs.all?(&f)
+      else
+        Internal::Dispatchable.call([:any], nil, f, xs)
+      end
     end
 
     # Returns true if at least one of elements of the list match the predicate,
     # false otherwise.
+    #
     # Dispatches to the any method of the second argument, if present.
+    #
     # Acts as a transducer if a transformer is given in list position.
     #
     # (a -> Boolean) -> [a] -> Boolean
     #
     curried_method(:any) do |f, xs|
-      xs.any?(&f)
+      if xs.is_a?(::Array)
+        xs.any?(&f)
+      else
+        Internal::Dispatchable.call([:any], nil, f, xs)
+      end
     end
 
     # Returns a new list containing the contents of the given list,
@@ -45,13 +58,11 @@ module Ramda
     #
     # Chain m => (a -> m b) -> m a -> m b
     #
-    curried_method(:chain) do |fn, xs|
-      if xs.respond_to?(:chain)
-        xs.chain(fn)
-      elsif xs.respond_to?(:bind)
-        xs.bind(fn)
+    curried_method(:chain) do |f, xs|
+      if xs.is_a?(::Array)
+        xs.flat_map(&f)
       else
-        xs.flat_map(&fn)
+        Internal::Dispatchable.call([:chain, :bind], nil, f, xs)
       end
     end
 
@@ -61,19 +72,21 @@ module Ramda
     # List -> List -> List
     #
     curried_method(:concat) do |list_a, list_b|
-      case list_a
+      case list_b
       when ::String, ::Symbol
         [list_a, list_b].join('')
       when ::Array
         list_a.dup + list_b
       else
-        type_error(list_a, :concat)
+        Internal::Dispatchable.call([:concat], nil, list_a, list_b)
       end
     end
 
     # Returns true if the specified value is equal, in R.equals terms,
     # to at least one element of the given list; false otherwise.
     #
+    # Dispatches to the concat method of the first argument, if present.
+    #
     # a -> [a] -> Boolean
     #
     curried_method(:contains) do |x, xs|
@@ -83,6 +96,8 @@ module Ramda
     # Returns all but the first n elements of the given list, string,
     # or transducer/transformer (or object with a drop method).
     #
+    # Dispatches to the drop method of the second argument, if present.
+    #
     # Number -> [a] -> [a]
     # Number -> String -> String
     #
@@ -93,7 +108,7 @@ module Ramda
       when ::Array
         xs[num..-1] || []
       else
-        type_error(xs, :drop)
+        Internal::Dispatchable.call([:drop], nil, num, xs)
       end
     end
 
@@ -109,14 +124,19 @@ module Ramda
     #
     # (a -> Boolean) -> [a] -> [a]
     #
-    curried_method(:drop_while) do |fn, xs|
-      xs.drop_while(&fn)
+    curried_method(:drop_while) do |f, xs|
+      if xs.is_a?(::Array)
+        xs.drop_while(&f)
+      else
+        Internal::Dispatchable.call([:drop_while], nil, f, xs)
+      end
     end
 
     # Takes a predicate and a Filterable, and returns a new filterable of the same
     # type containing the members of the given filterable which satisfy the given
     # predicate. Filterable objects include plain objects or any object that
     # has a filter method such as Array.
+    #
     # Dispatches to the filter method of the second argument, if present.
     #
     # Filterable f => (a -> Boolean) -> f a -> f a
@@ -125,8 +145,10 @@ module Ramda
       case xs
       when ::Hash
         xs.select { |_, value| f.call(value) }
-      else
+      when ::Array
         xs.select(&f)
+      else
+        Internal::Dispatchable.call([:filter], nil, f, xs)
       end
     end
 
@@ -142,10 +164,16 @@ module Ramda
     # Returns the first element of the list which matches the predicate,
     # or undefined if no element matches.
     #
+    # Dispatches to the find method of the second argument, if present.
+    #
     # (a -> Boolean) -> [a] -> a | NilClass
     #
     curried_method(:find) do |f, xs|
-      xs.find(&f)
+      if xs.is_a?(::Array)
+        xs.find(&f)
+      else
+        Internal::Dispatchable.call([:find], nil, f, xs)
+      end
     end
 
     # Returns the index of the first element of the list which matches the predicate,
@@ -153,8 +181,8 @@ module Ramda
     #
     # (a -> Boolean) -> [a] -> Number | NilClass
     #
-    curried_method(:find_index) do |fn, xs|
-      xs.index(&fn)
+    curried_method(:find_index) do |f, xs|
+      xs.index(&f)
     end
 
     # Returns the last element of the list which matches the predicate,
@@ -162,8 +190,8 @@ module Ramda
     #
     # (a -> Boolean) -> [a] -> a | NilClass
     #
-    curried_method(:find_last) do |fn, xs|
-      index = xs.rindex(&fn)
+    curried_method(:find_last) do |f, xs|
+      index = xs.rindex(&f)
       xs[index] unless index.nil?
     end
 
@@ -172,8 +200,8 @@ module Ramda
     #
     # (a -> Boolean) -> [a] -> Number | NilClass
     #
-    curried_method(:find_last_index) do |fn, xs|
-      xs.rindex(&fn)
+    curried_method(:find_last_index) do |f, xs|
+      xs.rindex(&f)
     end
 
     # Returns a new list by pulling every item out of it (and all its sub-arrays)
@@ -186,20 +214,33 @@ module Ramda
     # Iterate over an input list, calling a provided function fn for each element
     # in the list.
     #
+    # Dispatches to the forEach method of the second argument, if present.
+    #
     # (a -> *) -> [a] -> [a]
     #
-    curried_method(:for_each) do |fn, xs|
-      xs.each(&fn)
+    curried_method(:for_each) do |f, xs|
+      if xs.is_a?(::Array)
+        xs.each(&f)
+      else
+        Internal::Dispatchable.call([:for_each], nil, f, xs)
+      end
     end
 
     # Splits a list into sub-lists stored in an object, based on the result of
     # calling a String-returning function on each element, and grouping the
     # results according to values returned.
     #
+    # Dispatches to the groupBy method of the second argument, if present.
+    #
+    #
     # (a -> String) -> [a] -> {String: [a]}
     #
     curried_method(:group_by) do |f, xs|
-      xs.group_by(&f)
+      if xs.is_a?(::Array)
+        xs.group_by(&f)
+      else
+        Internal::Dispatchable.call([:group_by], nil, f, xs)
+      end
     end
 
     # Returns the first element of the given list or string. In some libraries
@@ -297,21 +338,39 @@ module Ramda
     #
     # Functor f => (a -> b) -> f a -> f b
     #
-    curried_method(:map) do |f, functor|
-      case functor
+    curried_method(:map) do |f, xs|
+      case xs
       when ::Hash
-        Hash[functor.map { |k, v| [k, f.call(v)] }]
+        Hash[xs.map { |k, v| [k, f.call(v)] }]
       when ::Array
-        functor.map(&f)
+        xs.map(&f)
       else
-        if functor.respond_to?(:map)
-          functor.map(f)
-        else
-          type_error(functor, :map)
-        end
+        Internal::Dispatchable.call([:map], nil, f, xs)
       end
     end
 
+    # The mapAccum function behaves like a combination of map and reduce;
+    # it applies a function to each element of a list, passing
+    # an accumulating parameter from left to right, and returning
+    # a final value of this accumulator together with the new list.
+    #
+    # The iterator function receives two arguments, acc and value,
+    # and should return a tuple [acc, value].
+    #
+    # (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
+    #
+    # curried_method(:map_accum) do |fn, acc, xs|
+    #
+    # end
+
+    # Merges a list of objects together into one object.
+    #
+    # [{k: v}] -> {k: v}
+    #
+    curried_method(:merge_all) do |xs|
+      xs.reduce(&:merge)
+    end
+
     # Returns the nth element of the given list or string. If n is negative
     # the element at index length + n is returned.
     #
@@ -335,8 +394,8 @@ module Ramda
     #
     # Filterable f => (a -> Boolean) -> f a -> [f a, f a]
     #
-    curried_method(:partition) do |fn, xs|
-      ::Ramda.juxt([::Ramda.filter, ::Ramda.reject]).call(fn, xs)
+    curried_method(:partition) do |f, xs|
+      ::Ramda.juxt([::Ramda.filter, ::Ramda.reject]).call(f, xs)
     end
 
     # Returns a new list by plucking the same named property off all objects
@@ -378,8 +437,8 @@ module Ramda
     #
     # ((a, b) -> a) -> a -> [b] -> a
     #
-    curried_method(:reduce) do |fn, acc, xs|
-      xs.reduce(acc, &fn)
+    curried_method(:reduce) do |f, acc, xs|
+      xs.reduce(acc, &f)
     end
 
     # Returns a single item by iterating through the list, successively
@@ -394,8 +453,8 @@ module Ramda
     #
     # ((a, b) -> a) -> a -> [b] -> a
     #
-    curried_method(:reduce_right) do |fn, acc_arg, xs|
-      xs.reverse.reduce(acc_arg) { |acc, x| fn.call(x, acc) }
+    curried_method(:reduce_right) do |f, acc_arg, xs|
+      xs.reverse.reduce(acc_arg) { |acc, x| f.call(x, acc) }
     end
 
     # Returns a new list or string with the elements or characters in reverse order.
@@ -430,7 +489,16 @@ module Ramda
     # a -> n -> [a]
     #
     curried_method(:repeat) do |a, n|
-      Array.new(n, a)
+      ::Array.new(n, a)
+    end
+
+    # Scan is similar to reduce, but returns a list of successively
+    # reduced values from the left
+    #
+    # (a,b -> a) -> a -> [b] -> [a]
+    #
+    curried_method(:scan) do |f, acc0, xs|
+      xs.reduce([acc0]) { |acc, x| acc << f.call(acc[-1], x) }
     end
 
     # Returns the elements of the given list or string
@@ -440,7 +508,12 @@ module Ramda
     # Number -> Number -> String -> String
     #
     curried_method(:slice) do |from, to, xs|
-      xs[from...to]
+      case xs
+      when ::Array, ::String
+        xs[from...to]
+      else
+        Internal::Dispatchable.call([:slice], nil, from, to, xs)
+      end
     end
 
     # Returns a copy of the list, sorted according to the comparator function,
@@ -465,11 +538,18 @@ module Ramda
 
     # Returns the first n elements of the given list, string.
     #
+    # Dispatches to the take method of the second argument, if present.
+    #
     # Number -> [a] -> [a]
     # Number -> String -> String
     #
     curried_method(:take) do |num, xs|
-      xs[0, num]
+      case xs
+      when ::Array, ::String
+        xs[0, num]
+      else
+        Internal::Dispatchable.call([:take], nil, num, xs)
+      end
     end
 
     # Returns a new list containing the first n elements of a given list,
@@ -480,8 +560,12 @@ module Ramda
     #
     # (a -> Boolean) -> [a] -> [a]
     #
-    curried_method(:take_while) do |fn, xs|
-      xs[0, xs.index { |x| !fn.call(x) } || xs.size]
+    curried_method(:take_while) do |f, xs|
+      if xs.is_a?(::Array)
+        xs[0, xs.index { |x| !f.call(x) } || xs.size]
+      else
+        Internal::Dispatchable.call([:take_while], nil, f, xs)
+      end
     end
 
     # Calls an input function n times, returning an array containing the results
@@ -491,8 +575,30 @@ module Ramda
     #
     # (Number -> a) -> Number -> [a]
     #
-    curried_method(:times) do |fn, n|
-      n.times.to_a.map(&fn)
+    curried_method(:times) do |f, n|
+      n.times.to_a.map(&f)
+    end
+
+    # Builds a list from a seed value. Accepts an iterator function, which
+    # returns either false to stop iteration or an array of length 2
+    # containing the value to add to the resulting list and the seed
+    # to be used in the next call to the iterator function.
+    #
+    # The iterator function receives one argument: (seed).
+    #
+    # (a -> [b]) -> * -> [b]
+    #
+    curried_method(:unfold) do |f, n|
+      xs = []
+      loop do
+        res = f.call(n)
+
+        break if res.is_a?(FalseClass)
+
+        xs << res[0]
+        n = res[1]
+      end
+      xs
     end
 
     # Returns a new list containing only one copy of each element in the original list.
@@ -504,8 +610,8 @@ module Ramda
     # Returns a new list containing only one copy of each element in the original list,
     # based upon the value returned by applying the supplied predicate to each list
     # element.
-    curried_method(:uniq_with) do |fn, xs|
-      xs.uniq(&fn)
+    curried_method(:uniq_with) do |f, xs|
+      xs.uniq(&f)
     end
 
     # Shorthand for R.chain(R.identity), which removes one level of nesting from any Chain.
@@ -561,8 +667,8 @@ module Ramda
     #
     # (a,b -> c) -> [a] -> [b] -> [c]
     #
-    curried_method(:zip_with) do |fn, xs1, xs2|
-      xs1.zip(xs2).map { |(a, b)| fn.call(a, b) }
+    curried_method(:zip_with) do |f, xs1, xs2|
+      xs1.zip(xs2).map { |(a, b)| f.call(a, b) }
     end
 
     # TODO: Extract from this module

data/lib/ramda/logic.rb

@@ -47,6 +47,15 @@ module Ramda
       then_fn.call(x, *other_x) unless then_fn.nil?
     end
 
+    # Returns the second argument if it is not null, undefined or NaN;
+    # otherwise the first argument is returned.
+    #
+    # a -> b -> a | b
+    #
+    curried_method(:default_to) do |a, b|
+      b || a
+    end
+
     # Creates a function that will process either the onTrue or the onFalse
     # function depending upon the result of the condition predicate.
     #

data/lib/ramda/version.rb

@@ -1,3 +1,3 @@
 module Ramda
-  VERSION = '0.9.0'.freeze
+  VERSION = '0.10.0'.freeze
 end

data/spec/ramda/function_spec.rb

@@ -407,6 +407,34 @@ describe Ramda::Function do
     end
   end
 
+  context '#partial' do
+    it 'from docs' do
+      multiply2 = ->(a, b) { a * b }
+      double_fn = R.partial(multiply2, [2])
+      expect(double_fn.call(2)).to eq(4)
+
+      greet = lambda { |salutation, title, first_name, last_name|
+        salutation + ', ' + title + ' ' + first_name + ' ' + last_name + '!'
+      }
+
+      say_hello = R.partial(greet, ['Hello'])
+      say_hello_to_ms = R.partial(say_hello, ['Ms.'])
+      expect(say_hello_to_ms.call('Jane', 'Jones')).to eq('Hello, Ms. Jane Jones!')
+    end
+  end
+
+  context '#partial_right' do
+    it 'from docs' do
+      greet = lambda { |salutation, title, first_name, last_name|
+        salutation + ', ' + title + ' ' + first_name + ' ' + last_name + '!'
+      }
+
+      gree_ms_jane_jones = R.partial_right(greet, ['Ms.', 'Jane', 'Jones'])
+
+      expect(gree_ms_jane_jones.call('Hello')).to eq('Hello, Ms. Jane Jones!')
+    end
+  end
+
   context '#pipe' do
     it 'from docs' do
       classy_greeting = lambda do |first_name, last_name|

data/spec/ramda/list_spec.rb

@@ -350,6 +350,26 @@ describe Ramda::List do
     end
   end
 
+  # context '#map_accum' do
+  #   it 'from docs' do
+  #     digits = ['1', '2', '3', '4'];
+  #     appender = -> (a, b) { [a + b, a + b] }
+  #
+  #     expect(R.map_accum(appender, 0, digits)).to eq(['01234', ['01', '012', '0123', '01234']])
+  #   end
+  # end
+
+  context '#merge_all' do
+    it 'from docs' do
+      expect(R.merge_all([{ foo: 1 }, { bar: 2 }, { baz: 3 }])).to eq(foo: 1, bar: 2, baz: 3)
+      expect(R.merge_all([{ foo: 1 }, { foo: 2 }, { bar: 2 }])).to eq(foo: 2, bar: 2)
+    end
+
+    it 'curried' do
+      expect(R.merge_all.call([{ foo: 1 }, { bar: 2 }])).to eq(foo: 1, bar: 2)
+    end
+  end
+
   context '#nth' do
     it 'with array' do
       list = ['foo', 'bar', 'baz', 'quux']
@@ -469,6 +489,29 @@ describe Ramda::List do
     end
   end
 
+  context '#scan' do
+    let(:add) { ->(a, b) { a + b } }
+    let(:mult) { ->(a, b) { a * b;  }; }
+
+    it 'scans simple functions over arrays with the supplied accumulator' do
+      expect(R.scan(add, 0, [1, 2, 3, 4])).to eq([0, 1, 3, 6, 10])
+      expect(R.scan(mult, 1, [1, 2, 3, 4])).to eq([1, 1, 2, 6, 24])
+    end
+
+    it 'returns the accumulator for an empty array' do
+      expect(R.scan(add, 0, [])).to eq([0])
+      expect(R.scan(mult, 1, [])).to eq([1])
+    end
+
+    it 'is curried' do
+      add_or_concat = R.scan(add)
+      sum = add_or_concat.call(0)
+      cat = add_or_concat.call('')
+      expect(sum.call([1, 2, 3, 4])).to eq([0, 1, 3, 6, 10])
+      expect(cat.call(['1', '2', '3', '4'])).to eq(['', '1', '12', '123', '1234'])
+    end
+  end
+
   context '#slice' do
     it 'from docs' do
       expect(r.slice(1, 3, ['a', 'b', 'c', 'd'])).to eq(['b', 'c'])
@@ -551,6 +594,13 @@ describe Ramda::List do
     end
   end
 
+  context '#unfold' do
+    it 'from docs' do
+      f = ->(n) { n > 50 ? false : [-n, n + 10] }
+      expect(R.unfold(f, 10)).to eq([-10, -20, -30, -40, -50])
+    end
+  end
+
   context '#uniq' do
     it 'from docs' do
       expect(r.uniq([1, 1, 2, 1])).to eq([1, 2])

data/spec/ramda/logic_spec.rb

@@ -53,6 +53,15 @@ describe Ramda::Logic do
     end
   end
 
+  context '#default_to' do
+    it 'from docs' do
+      default_to42 = R.default_to(42)
+
+      expect(default_to42.call(nil)).to eq(42)
+      expect(default_to42.call('Ramda')).to eq('Ramda')
+    end
+  end
+
   context '#if_else' do
     it 'from docs' do
       inc_count = R.if_else(

data/spec/ramda_spec.rb

@@ -8,6 +8,8 @@ describe Ramda do
   end
 
   # r(:keys_in)
+  # r(:map_accum)
+  # r(:map_accum_right)
   # r(:math_mod)
   # r(:to_pairs_in)
   # r(:values_in)
@@ -44,6 +46,7 @@ describe Ramda do
   r(:curry)
   r(:curry_n)
   r(:dec)
+  r(:default_to)
   r(:difference)
   r(:difference_with)
   r(:dissoc)
@@ -105,6 +108,7 @@ describe Ramda do
   r(:max_by)
   r(:memoize)
   r(:merge)
+  r(:merge_all)
   r(:min)
   r(:min_by)
   r(:modulo)
@@ -119,6 +123,8 @@ describe Ramda do
   r(:once)
   r(:or)
   r(:over)
+  r(:partial)
+  r(:partial_right)
   r(:partition)
   r(:path)
   r(:path_eq)
@@ -142,6 +148,7 @@ describe Ramda do
   r(:repeat)
   r(:replace)
   r(:reverse)
+  r(:scan)
   r(:set)
   r(:slice)
   r(:sort)
@@ -161,6 +168,7 @@ describe Ramda do
   r(:type)
   r(:unapply)
   r(:unary)
+  r(:unfold)
   r(:union)
   r(:union_with)
   r(:uniq)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ramda-ruby
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Vadim Lazebny
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-02 00:00:00.000000000 Z
+date: 2017-07-03 00:00:00.000000000 Z
 dependencies: []
 description: Ruby version of Ramda Js library.
 email:
@@ -33,6 +33,7 @@ files:
 - lib/ramda/exception_handler.rb
 - lib/ramda/function.rb
 - lib/ramda/internal/curried_method.rb
+- lib/ramda/internal/dispatchable.rb
 - lib/ramda/internal/function_with_arity.rb
 - lib/ramda/internal/functors.rb
 - lib/ramda/internal/java/__make_curry_proc__.rb