ramda-ruby 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f28ea9a5acc282047805422a96e187bd6b97791
-  data.tar.gz: fde8d4617b4d1d43ba9ac481505a046abbe5c6b0
+  metadata.gz: a69b5e8207b7a9b33c6dbfc65e0ab0139b33efd9
+  data.tar.gz: 4712559e1863c803718872c0356909dfdd0ae669
 SHA512:
-  metadata.gz: 61fb7fd43a5912c651d4f26441c2267530cf55f1b6473b91693fc8f7ba99eafc01cb739006d6d89c59cc1278e02d1464e5b95603e4c99c9e26af4bd1975af834
-  data.tar.gz: 208dbb9efa07a6c5b6a00609c410fb81ad98245a5b7b1158b09579cb6531e13acb6d5e30752227153fc28ff4ecf53410b052446cf330367a2ec63a5126d0e5ad
+  metadata.gz: 698f61ac9c9590beca80454f7f0175295385d6f872e0d93fce994fe98e897e148acfadf7ba4ea904320d8ed927a6456f3148fbc59a717c5bab270c5fc541792c
+  data.tar.gz: 4f0d9c29a977253b65694e58632afb798777dd5585cb8511ed99032823babba9d666786fbb03285ede462c7844f2b1739e6c3da04bebf16aacbd2f71dbdbf133

data/CHANGELOG.md

@@ -1,6 +1,20 @@
 Not Released
 ---------------
 
+Release 0.16.0
+---------------
+
+* [compose_k](http://ramdajs.com/docs/#composeK)
+* [drop_last](http://ramdajs.com/docs/#dropLast)
+* [drop_last_while](http://ramdajs.com/docs/#dropLastWhile)
+* [pipe_k](http://ramdajs.com/docs/#pipeK)
+* [prop_is](http://ramdajs.com/docs/#propIs)
+* [prop_satisfies](http://ramdajs.com/docs/#propSatisfies)
+* [split_every](http://ramdajs.com/docs/#splitEvery)
+* [take_last](http://ramdajs.com/docs/#takeLast)
+* [take_last_while](http://ramdajs.com/docs/#takeLastWhile)
+* [uniq_by](http://ramdajs.com/docs/#uniqBy)
+
 Release 0.15.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-187-green.svg)](docs/FUNCTIONS.md)
+[![Functions](https://img.shields.io/badge/Functions-197-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)

data/ROADMAP.md

@@ -1,19 +1,3 @@
-Release 0.16.0
----------------
-* compose_k
-* drop_last
-* drop_last_while
-* pipe_k
-* prop_is
-* prop_satisfies
-* split_every
-* take_last
-* take_last_while
-* uniq_by
-
-Release 0.17.0
----------------
-
 Release 0.18.0
 ---------------
 * eq_by
@@ -72,3 +56,8 @@ Release 0.24.0
 * merge_deep_with_key
 * o
 * starts_with
+
+Release 0.25.0
+---------------
+* apply_to
+* memoize(deprecate)

data/docs/FUNCTIONS.md

@@ -23,6 +23,7 @@ Function
 * [call](http://ramdajs.com/docs/#call)
 * [comparator](http://ramdajs.com/docs/#comparator)
 * [compose](http://ramdajs.com/docs/#compose)
+* [compose_k](http://ramdajs.com/docs/#composeK)
 * [construct](http://ramdajs.com/docs/#construct)
 * [construct_n](http://ramdajs.com/docs/#constructN)
 * [converge](http://ramdajs.com/docs/#converge)
@@ -43,6 +44,7 @@ Function
 * [partial](http://ramdajs.com/docs/#partial)
 * [partial_right](http://ramdajs.com/docs/#partialRight)
 * [pipe](http://ramdajs.com/docs/#pipe)
+* [pipe_k](http://ramdajs.com/docs/#pipeK)
 * [tap](http://ramdajs.com/docs/#tap)
 * [unapply](http://ramdajs.com/docs/#unapply)
 * [unary](http://ramdajs.com/docs/#unary)
@@ -60,6 +62,8 @@ List
 * [concat](http://ramdajs.com/docs/#concat)
 * [contains](http://ramdajs.com/docs/#contains)
 * [drop](http://ramdajs.com/docs/#drop)
+* [drop_last](http://ramdajs.com/docs/#dropLast)
+* [drop_last_while](http://ramdajs.com/docs/#dropLastWhile)
 * [drop_repeats](http://ramdajs.com/docs/#dropRepeats)
 * [drop_repeats_with](http://ramdajs.com/docs/#dropRepeatsWith)
 * [drop_while](http://ramdajs.com/docs/#dropWhile)
@@ -103,13 +107,17 @@ List
 * [slice](http://ramdajs.com/docs/#slice)
 * [sort](http://ramdajs.com/docs/#sort)
 * [sort_by](http://ramdajs.com/docs/#sortBy)
+* [split_every](http://ramdajs.com/docs/#splitEvery)
 * [tail](http://ramdajs.com/docs/#tail)
 * [take](http://ramdajs.com/docs/#take)- transducer
+* [take_last](http://ramdajs.com/docs/#takeLast)
+* [take_last_while](http://ramdajs.com/docs/#takeLastWhile)
 * [take_while](http://ramdajs.com/docs/#takeWhile)
 * [times](http://ramdajs.com/docs/#times)
 * [transduce](http://ramdajs.com/docs/#transduce)
 * [unfold](http://ramdajs.com/docs/#unfold)
 * [uniq](http://ramdajs.com/docs/#uniq)
+* [uniq_by](http://ramdajs.com/docs/#uniqBy)
 * [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)
@@ -133,6 +141,7 @@ Logic
 * [is_empty](http://ramdajs.com/docs/#isEmpty)
 * [not](http://ramdajs.com/docs/#not)
 * [or](http://ramdajs.com/docs/#or)
+* [prop_satisfies](http://ramdajs.com/docs/#propSatisfies)
 
 Math
 ------------
@@ -229,4 +238,5 @@ Type
 
 * [is](http://ramdajs.com/docs/#is)
 * [is_nil](http://ramdajs.com/docs/#isNil)
+* [prop_is](http://ramdajs.com/docs/#propIs)
 * [type](http://ramdajs.com/docs/#type)

data/docs/FUNCTORS.md

@@ -30,10 +30,11 @@ 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 |
+|Language   |Library         |Functor |Apply |Applicative |Chain    |
+|-----------|----------------|--------|------|------------|---------|
+|Haskel     |                |<$>|fmap|<*>   |pure        |>>=      |
+|JavaScript |ramda-fantasy   |map     |ap    |of          |chain    |
+|Ruby       |                |map     |      |            |flat_map |
+|Ruby       |dry-monads      |fmap    |      |pure        |bind     |
+|Ruby       |kleisli         |fmap    |*     |            |>        |
+|Ruby       |ramda-ruby      |map     |ap    |            |chain    |

data/lib/ramda/function.rb

@@ -124,6 +124,15 @@ module Ramda
       ::Ramda.pipe(*fns.reverse)
     end
 
+    # Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (a -> m z)
+    # Returns the right-to-left Kleisli composition of the provided functions,
+    # each of which must return a value of a type supported by chain.
+
+    # R.compose_k(h, g, f) is equivalent to R.compose(R.chain(h), R.chain(g), f).
+    curried_method(:compose_k) do |*fns|
+      ::Ramda.compose(*(fns[0..-2].map(&::Ramda.chain) + fns[-1, 1]))
+    end
+
     # Wraps a constructor function inside a curried function that can be called
     # with the same arguments and returns the same type.
     #
@@ -379,6 +388,17 @@ module Ramda
       ->(*args) { fns[1..-1].reduce(fns[0].call(*args)) { |memo, fn| fn.call(memo) } }
     end
 
+    # Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (a -> m z)
+    #
+    # Returns the left-to-right Kleisli composition of the provided functions,
+    # each of which must return a value of a type supported by chain.
+    #
+    # R.pipeK(f, g, h) is equivalent to R.pipe(f, R.chain(g), R.chain(h)).
+    #
+    curried(:pipe_k) do |*fns|
+      ::Ramda.pipe(*(fns[0, 1] + fns[1..-1].map(&::Ramda.chain)))
+    end
+
     # Runs the given function with the supplied object, then returns the object.
     #
     # (a -> *) -> a -> a

data/lib/ramda/internal/curried_method.rb

@@ -1,5 +1,6 @@
 require_relative 'function_with_arity'
 
+# rubocop:disable Performance/RedundantBlockCall
 module Ramda
   module Internal
     # Curried Method
@@ -17,7 +18,7 @@ module Ramda
             if args.index(Ramda.__)
               replace_placeholder(args, &block).curry
             else
-              result = args.empty? ? block : yield(*args)
+              result = args.empty? ? block : block.call(*args)
               debug_log(name, args, result) if ::Ramda::DEBUG_MODE
               result
             end
@@ -28,11 +29,11 @@ module Ramda
       end
       # rubocop:enable Metrics/MethodLength
 
-      def replace_placeholder(basic_args)
+      def replace_placeholder(basic_args, &block)
         Ramda::Internal::FunctionWithArity.call(basic_args.count(Ramda.__)) do |*new_args|
           cloned_args = basic_args.dup
           new_args.each { |arg| cloned_args[cloned_args.index(Ramda.__)] = arg }
-          result = yield(*cloned_args)
+          result = block.call(*cloned_args)
           debug_log(name, cloned_args, result) if ::Ramda::DEBUG_MODE
           result
         end

data/lib/ramda/internal/functors.rb

@@ -42,6 +42,10 @@ module Ramda
 
       # The `Maybe` type represents the possibility of some value or nothing.
       class Maybe
+        def self.new(x)
+          x.nil? ? None.new : Some.new(x)
+        end
+
         def self.of(x)
           Some.new(x)
         end
@@ -83,7 +87,13 @@ module Ramda
         class None
           attr_reader :value
 
-          def initialize(*); end
+          class << self
+            alias orig_new new
+
+            def new
+              @instance ||= orig_new
+            end
+          end
 
           def ==(other)
             instance_of?(other.class)

data/lib/ramda/list.rb

@@ -115,6 +115,37 @@ module Ramda
       xs[num..-1] || xs.class.new
     end)
 
+    # Number -> [a] -> [a]
+    # Number -> String -> String
+    #
+    # Returns a list containing all but the last n elements of the given list.
+    #
+    curried(:drop_last) do |x, xs|
+      xs[0...-x]
+    end
+
+    # (a -> Boolean) -> [a] -> [a]
+    # (a -> Boolean) -> String -> String
+    #
+    # Returns a new list excluding all the tailing elements of a given list
+    # which satisfy the supplied predicate function.
+    # It passes each value from the right to the supplied predicate function,
+    # skipping elements until the predicate function returns a falsy value.
+    # The predicate function is applied to one argument: (value).
+    #
+    curried(:drop_last_while) do |fn, xs|
+      lxs =
+        case xs
+        when ::String
+          xs.chars.to_a
+        else
+          xs
+        end
+
+      index = lxs.reverse.index { |x| !fn.call(x) } || 0
+      xs[0...-index]
+    end
+
     # Returns a new list without any consecutively repeating elements.
     # R.equals is used to determine equality.
     #
@@ -615,6 +646,28 @@ module Ramda
       xs.sort(&comparator)
     end
 
+    # Number -> [a] -> [[a]]
+    # Number -> String -> [String]
+    #
+    # Splits a collection into slices of the specified length.
+    #
+    curried(:split_every) do |num, xs|
+      case xs
+      when ::Array
+        xs
+          .each_slice(num)
+          .to_a
+      when ::String
+        xs
+          .chars
+          .each_slice(num)
+          .to_a
+          .map(&:join)
+      else
+        type_error(xs, :split_every)
+      end
+    end
+
     # Returns all but the first element of the given list or string
     # (or object with a tail method).
     #
@@ -637,6 +690,35 @@ module Ramda
                xs[0, num]
              end)
 
+    # Number -> [a] -> [a]
+    # Number -> String -> String
+    #
+    # Returns a new list containing the last n elements of the given list.
+    # If n > list.length, returns a list of list.length elements.
+    #
+    curried(:take_last) do |n, xs|
+      xs[-(n > xs.size ? xs.size : n)..-1]
+    end
+
+    # Number -> [a] -> [a]
+    # Number -> String -> String
+    #
+    # Returns a new list containing the last n elements of the given list.
+    # If n > list.length, returns a list of list.length elements.
+    #
+    curried(:take_last_while) do |f, xs|
+      lxs =
+        case xs
+        when ::String
+          xs.chars.to_a
+        else
+          xs
+        end
+
+      index = lxs.reverse.index { |x| !f.call(x) } || lxs.size
+      xs[-index..-1]
+    end
+
     # Returns a new list containing the first n elements of a given list,
     # passing each value to the supplied predicate function, and terminating
     # when the predicate function returns false. Excludes the element that
@@ -713,6 +795,17 @@ module Ramda
     #
     curried_method(:uniq, &:uniq)
 
+    # (a → b) → [a] → [a]
+    #
+    # Returns a new list containing only one copy of each element in the original list,
+    # based upon the value returned by applying the supplied function to each list element.
+    # Prefers the first item if the supplied function produces the same value on two items.
+    # R.equals is used for comparison.
+    #
+    curried(:uniq_by) do |f, xs|
+      xs.uniq(&f)
+    end
+
     # 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.

data/lib/ramda/logic.rb

@@ -157,5 +157,14 @@ module Ramda
     curried_method(:or) do |a, b|
       a || b
     end
+
+    # (a -> Boolean) -> String -> {String: a} -> Boolean
+    #
+    # Returns true if the specified object property satisfies the given predicate;
+    # false otherwise. You can test multiple properties with R.where.
+    #
+    curried(:prop_satisfies) do |fn, key, obj|
+      fn.call(obj[key])
+    end
   end
 end

data/lib/ramda/type.rb

@@ -20,6 +20,15 @@ module Ramda
     #
     curried_method(:is_nil, &:nil?)
 
+    # Type -> String -> Object -> Boolean
+    #
+    # Returns true if the specified object property is of the given type;
+    # false otherwise.
+    #
+    curried(:prop_is) do |type, key, obj|
+      obj[key].is_a?(type)
+    end
+
     # Gives a class of the (native) type of a value.
     #
     # (* -> {*}) -> String

data/lib/ramda/version.rb

@@ -1,3 +1,3 @@
 module Ramda
-  VERSION = '0.15.0'.freeze
+  VERSION = '0.16.0'.freeze
 end

data/spec/ramda/function_spec.rb

@@ -223,6 +223,23 @@ describe Ramda::Function do
     end
   end
 
+  context '#compose_k' do
+    it 'from docs' do
+      #  get :: String -> Object -> Maybe *
+      get = R.curry(->(prop_name, obj) { Maybe.new(obj[prop_name]) })
+
+      # get_status_code :: Maybe String -> Maybe String
+      get_status_code = R.compose_k(
+        R.compose(Maybe.method(:new), R.to_upper),
+        get[:state],
+        get[:address],
+        get[:user]
+      )
+      expect(get_status_code.call(user: { address: { state: 'ny' } })).to eq(Maybe::Some.new('NY'))
+      expect(get_status_code.call({})).to eql(Maybe::None.new)
+    end
+  end
+
   context '#construct' do
     it 'from docs' do
       array_builder = r.construct(Array)
@@ -540,6 +557,37 @@ describe Ramda::Function do
     end
   end
 
+  context '#pipe_k' do
+    it 'from docs' do
+      # parse_json :: String -> Maybe *
+      parse_json = lambda do |json|
+        Maybe.new(
+          begin
+            JSON.parse(json)
+          rescue
+            nil
+          end
+        )
+      end
+
+      # get :: String -> Object -> Maybe *
+      get = R.curry(->(prop_name, obj) { Maybe.new(obj[prop_name]) })
+
+      # get_status_code :: Maybe String -> Maybe String
+      get_status_code = R.pipe_k(
+        parse_json,
+        get['user'],
+        get['address'],
+        get['state'],
+        R.compose(Maybe.method(:of), R.to_upper)
+      )
+
+      actual = get_status_code.call('{"user":{"address":{"state":"ny"}}}')
+      expect(actual).to eq(Maybe::Some.new('NY'))
+      expect(get_status_code.call('[Invalid JSON]')).to eq(Maybe::None.new)
+    end
+  end
+
   context '#tap' do
     it 'from docs' do
       say_x = instance_double(Proc)

data/spec/ramda/list_spec.rb

@@ -140,6 +140,32 @@ describe Ramda::List do
     end
   end
 
+  context '#drop_last' do
+    it 'from docs' do
+      expect(R.drop_last(1, ['foo', 'bar', 'baz'])).to eq(['foo', 'bar'])
+      expect(R.drop_last(2, ['foo', 'bar', 'baz'])).to eq(['foo'])
+      expect(R.drop_last(3, ['foo', 'bar', 'baz'])).to eq([])
+      expect(R.drop_last(4, ['foo', 'bar', 'baz'])).to eq([])
+      expect(R.drop_last(3, 'ramda')).to eq('ra')
+    end
+  end
+
+  context '#drop_last_while' do
+    it 'from docs' do
+      lte_three = ->(x) { x <= 3 }
+
+      expect(R.drop_last_while(lte_three, [1, 2, 3, 4, 3, 2, 1])).to eq([1, 2, 3, 4])
+
+      not_d = ->(x) { x != 'd' }
+      expect(R.drop_last_while(not_d, 'Ramda')).to eq('Ramd')
+    end
+
+    it 'returns empty list' do
+      always_fn = ->(*) { true }
+      expect(R.drop_last_while(always_fn, [1, 2, 3])).to eq([])
+    end
+  end
+
   context '#drop_repeats' do
     let(:x1s) { [1, 2, 3, 4, 5, 3, 2] }
     let(:x2s) { [1, 2, 2, 2, 3, 4, 4, 5, 5, 3, 2, 2] }
@@ -666,6 +692,13 @@ describe Ramda::List do
     end
   end
 
+  context '#split_every' do
+    it 'from docs' do
+      expect(R.split_every(3, [1, 2, 3, 4, 5, 6, 7])).to eq([[1, 2, 3], [4, 5, 6], [7]])
+      expect(R.split_every(3, 'foobarbaz')).to eq(['foo', 'bar', 'baz'])
+    end
+  end
+
   context '#tail' do
     it 'from docs' do
       expect(r.tail([1, 2, 3])).to eq([2, 3])
@@ -717,6 +750,27 @@ describe Ramda::List do
     end
   end
 
+  context '#take_last' do
+    it 'from docs' do
+      expect(R.take_last(1, ['foo', 'bar', 'baz'])).to eq(['baz'])
+      expect(R.take_last(2, ['foo', 'bar', 'baz'])).to eq(['bar', 'baz'])
+      expect(R.take_last(3, ['foo', 'bar', 'baz'])).to eq(['foo', 'bar', 'baz'])
+      expect(R.take_last(4, ['foo', 'bar', 'baz'])).to eq(['foo', 'bar', 'baz'])
+      expect(R.take_last(3, 'ramda')).to eq('mda')
+    end
+  end
+
+  context '#take_last_while' do
+    it 'from docs' do
+      is_not_one = ->(x) { x != 1 }
+
+      expect(R.take_last_while(is_not_one, [1, 2, 3, 4])).to eq([2, 3, 4])
+
+      is_not_r = ->(x) { x != 'R' }
+      expect(R.take_last_while(is_not_r, 'Ramda')).to eq('amda')
+    end
+  end
+
   context '#take_while' do
     it 'from docs' do
       is_not_four = ->(x) { x != 4 }
@@ -799,6 +853,12 @@ describe Ramda::List do
     end
   end
 
+  context '#uniq_by' do
+    it 'from docs' do
+      expect(R.uniq_by(:abs.to_proc, [-1, -5, 2, 10, 1, 2])).to eq([-1, -5, 2, 10])
+    end
+  end
+
   context '#uniq_with' do
     it 'from docs' do
       str_eq = R.invoker(0, 'to_s')

data/spec/ramda/logic_spec.rb

@@ -159,4 +159,11 @@ describe Ramda::Logic do
       expect(r.or(false, false)).to be_falsey
     end
   end
+
+  context '#prop_satisfies' do
+    it 'from docs' do
+      expect(R.prop_satisfies(0.method(:<), :x, x: 1, y: 2)).to be_truthy
+      expect(R.prop_satisfies(0.method(:<), :x, x: -1, y: 2)).to be_falsey
+    end
+  end
 end

data/spec/ramda/type_spec.rb

@@ -24,6 +24,14 @@ describe Ramda::Type do
     end
   end
 
+  context '#prop_is' do
+    it 'from docs' do
+      expect(R.prop_is(Integer, :x, x: 1, y: 2)).to be_truthy
+      expect(R.prop_is(Integer, :x, x: 'foo')).to be_falsey
+      expect(R.prop_is(Integer, :x, {})).to be_falsey
+    end
+  end
+
   context '#type' do
     it 'from docs' do
       expect(r.type({})).to be(Hash)

data/spec/ramda_spec.rb

@@ -40,6 +40,7 @@ describe Ramda do
   r(:comparator)
   r(:complement)
   r(:compose)
+  r(:compose_k)
   r(:concat)
   r(:cond)
   r(:construct)
@@ -57,6 +58,8 @@ describe Ramda do
   r(:dissoc_path)
   r(:divide)
   r(:drop)
+  r(:drop_last)
+  r(:drop_last_while)
   r(:drop_repeats)
   r(:drop_repeats_with)
   r(:drop_while)
@@ -146,12 +149,14 @@ describe Ramda do
   r(:pick_all)
   r(:pick_by)
   r(:pipe)
+  r(:pipe_k)
   r(:pluck)
   r(:prepend)
   r(:product)
   r(:project)
   r(:prop)
   r(:prop_eq)
+  r(:prop_is)
   r(:prop_or)
   r(:props)
   r(:range)
@@ -169,10 +174,13 @@ describe Ramda do
   r(:sort)
   r(:sort_by)
   r(:split)
+  r(:split_every)
   r(:subtract)
   r(:sum)
   r(:tail)
   r(:take)
+  r(:take_last)
+  r(:take_last_while)
   r(:take_while)
   r(:tap)
   r(:test)
@@ -190,6 +198,7 @@ describe Ramda do
   r(:union)
   r(:union_with)
   r(:uniq)
+  r(:uniq_by)
   r(:uniq_with)
   r(:unnest)
   r(:update)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ramda-ruby
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.16.0
 platform: ruby
 authors:
 - Vadim Lazebny
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-13 00:00:00.000000000 Z
+date: 2017-12-17 00:00:00.000000000 Z
 dependencies: []
 description: Ruby version of Ramda Js library.
 email: