ramda-ruby 0.1.0.alpha → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 00738383c28ec2a3917c0154c2cd68f8243435b9
-  data.tar.gz: b10e359516a0af531fd0f8d0ed96a928bcb4cbef
+  metadata.gz: 92c254b35426d8cb7d3e26e8a20a65dd0194a795
+  data.tar.gz: 49381b27473b09231633674595c3893ef9105600
 SHA512:
-  metadata.gz: 7b7018823bd8db0091106355b1d50262a1ce1deb6fc78ce0c5dbd6e4e2714c526a8991bf39547dde74f64d3ac6ae995c4b152ea541ffecc8f94d05a78d0508db
-  data.tar.gz: 26cd80e631e8cbf847672612a2340a34447746548a3b6d20bb1b940f34efdd5c24a9759b24ab80691cf4df01f6549572b532e169529675e64377659db60eeba5
+  metadata.gz: b3bb80690881e350816705eb9d91b91d507d633ae395ee904f37acbf8e90cbf2c2d8a2575a7805fb0be8009c7fab069e05eb2aa373883a9d6d350c2a6ef3d7b3
+  data.tar.gz: b6c9c51bd4a2ff317673d28ce65f0e1f5e1e3f06d62362a48ae04d429819012a6747ca12f5b2477678b1f7e6ae0d1f5e49e1333a8069ff8373081bd418207091

data/README.md

@@ -1,8 +1,7 @@
 Ramda Ruby
 =============
 
-This is ruby version of of Ramda library from (http://ramdajs.com)
-
+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)
 [![Travis badge](https://travis-ci.org/lazebny/ramda-ruby.svg?branch=master)](https://travis-ci.org/lazebny/ramda-ruby)
@@ -34,18 +33,34 @@ Or install it yourself as:
 And then require:
 
 ```ruby
-reuire 'ramda'
+require 'ramda'
 ```
 
+## Philosophy of [Ramda](http://ramdajs.com)
+
+* Ramda emphasizes a purer functional style.
+  Immutability and side-effect free functions are at the heart of its design philosophy.
+  This can help you get the job done with simple, elegant code.
+
+* Ramda functions are automatically curried.
+  This allows you to easily build up new functions from old ones simply by not supplying the final parameters.
+
+* The parameters to Ramda functions are arranged to make it convenient for currying.
+  The data to be operated on is generally supplied last.
+
+
 ## Documentation
 
-This gem tries to follow the same versions as ramdajs has.
+This gem tries to follow the same versions as Ramda Js.
+
+Currently the gem doesn't have own documentation but it tries to follow specification from [Ramda Js](http://ramdajs.com/docs/):
+
+* each release contains [functions](docs/FUNCTIONS.md) from the relevant Ramda Js release
+* each release includes more functions which i found pretty useful
 
-[Implemeted Functions](docs/FUNCTIONS.md)
+You could use [Ramda Js](http://ramdajs.com/docs/) as a source of documentation.
 
-Currently this project doesn't have own documentation but it tries to follow
-specification from http://ramdajs.com/docs/. You could use this resource as a
-source of documentation. Examples exist in spec directory.
+Ruby scpecific examples can be found in [tests](spec/ramda).
 
 ## Usage
 

data/docs/FUNCTIONS.md

@@ -6,6 +6,7 @@
 * any
 * any_pass
 * append
+* assoc
 * clone
 * comparator
 * compose
@@ -18,6 +19,7 @@
 * dec
 * difference
 * difference_with
+* dissoc
 * divide
 * drop
 * eq_by

data/lib/ramda.rb

@@ -85,7 +85,9 @@ module Ramda
                  :sum
 
   def_delegators Ramda::Object,
+                 :assoc,
                  :clone,
+                 :dissoc,
                  :eq_props,
                  :keys,
                  :merge,

data/lib/ramda/object.rb

@@ -5,21 +5,40 @@ module Ramda
   module Object
     extend ::Ramda::Internal::CurriedMethod
 
+    # Makes a shallow clone of an object, setting or overriding the specified
+    # property with the given value. Note that this copies and flattens
+    # prototype properties onto the new object as well. All non-primitive
+    # properties are copied by reference.
+    #
+    # String -> a -> {k: v} -> {k: v}
+    #
+    curried_method(:assoc) do |key, val, obj|
+      obj.merge(key => val)
+    end
+
     # Creates a deep copy of the value which may contain (nested)
     # Arrays and Objects, Numbers, Strings, Booleans and Dates.
     # Functions are assigned by reference rather than copied
     #
     # {*} -> {*}
     #
-    curried_method(:clone) do |object|
-      case object
+    curried_method(:clone) do |obj|
+      case obj
       when Array
-        object.dup.map(&method(:clone))
+        obj.dup.map(&method(:clone))
       else
-        object.dup
+        obj.dup
       end
     end
 
+    # Returns a new object that does not contain a prop property.
+    #
+    # String -> {k: v} -> {k: v}
+    #
+    curried_method(:dissoc) do |prop, obj|
+      clone(obj).tap { |o| o.delete(prop) }
+    end
+
     # Reports whether two objects have the same value, in R.equals terms,
     # for the specified property. Useful as a curried predicate.
     #

data/lib/ramda/version.rb

@@ -1,3 +1,3 @@
 module Ramda
-  VERSION = '0.1.0.alpha'.freeze
+  VERSION = '0.1.0'.freeze
 end

data/spec/ramda/function_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+
+describe Ramda::Function do
+  let(:r) { described_class }
+
+  context '#always' do
+    it 'from docs' do
+      str = 'Tee'
+      expect(r.always(str).call).to be(str)
+    end
+
+    it 'is curried' do
+      str = 'Tee'
+      expect(r.always.call(str).call).to be(str)
+    end
+  end
+
+  context '#comparator' do
+    it 'from docs' do
+      sort_rule = r.comparator(->(a, b) { a < b })
+      numbers = [30, 25, 21]
+      expect(R.sort(sort_rule, numbers)).to eq([21, 25, 30])
+    end
+  end
+
+  context '#compose' do
+    it 'from docs' do
+      classy_greeting = lambda do |first_name, last_name|
+        "The name's #{last_name}, #{first_name} #{last_name}"
+      end
+      abs = ->(val) { val < 0 ? -1 * val : val }
+
+      expect(r.compose(R.to_upper, classy_greeting).call('James', 'Bond'))
+        .to eq("THE NAME'S BOND, JAMES BOND")
+
+      expect(r.compose(abs, R.add(1), R.multiply(2)).call(-4)).to be(7)
+    end
+  end
+
+  context '#construct' do
+    it 'from docs' do
+      array_builder = r.construct(Array)
+      expect(array_builder.call(2, 10)).to eq([10, 10])
+    end
+  end
+
+  context '#converge' do
+    it 'from docs' do
+      average = r.converge(R.divide, [R.sum, R.length])
+      expect(average.call([1, 2, 3, 4, 5, 6, 7])).to eq(4)
+
+      strange_concat = r.converge(R.concat, [R.to_upper, R.to_lower])
+      expect(strange_concat.call('Yodel')).to eq('YODELyodel')
+    end
+  end
+
+  context '#curry' do
+    it 'from docs' do
+      add_four_numbers = ->(a, b, c, d) { a + b + c + d }
+
+      curried_add_four_numbers = r.curry(add_four_numbers)
+      f = curried_add_four_numbers.call(1, 2)
+      g = f.call(3)
+      expect(g.call(4)).to be(10)
+    end
+
+    def test_method(a)
+      a
+    end
+
+    it 'can receive a method' do
+      expect(r.curry(method(:test_method)).call(100)).to eq(100)
+    end
+  end
+
+  context '#flip' do
+    def merge_tree
+      ->(a, b, c) { [a, b, c] }
+    end
+
+    it 'from docs' do
+      expect(merge_tree.call(1, 2, 3)).to eq([1, 2, 3])
+      expect(r.flip(merge_tree).call(1, 2, 3)).to eq([2, 1, 3])
+    end
+
+    it 'curried' do
+      expect(r.flip(merge_tree).call(1, 2).call(3)).to eq([2, 1, 3])
+      expect(r.flip(merge_tree).call(1).call(2).call(3)).to eq([2, 1, 3])
+    end
+  end
+
+  context '#identity' do
+    it 'from docs' do
+      expect(r.identity(1)).to be(1)
+      obj = {}
+      expect(r.identity(obj)).to be(obj)
+    end
+
+    it 'is curried' do
+      obj = {}
+      expect(r.identity.call(obj)).to be(obj)
+    end
+  end
+
+  context '#invoker' do
+    it 'from docs' do
+      slice_form = r.invoker(1, 'slice')
+      expect(slice_form.call(6, 'abcdefghijklm')).to eq('g')
+
+      slice_form6 = r.invoker(2, 'slice').call(6)
+      expect(slice_form6.call(8, 'abcdefghijklmnop')).to eq('ghijklmn')
+    end
+  end
+
+  context '#memoize' do
+    it 'from docs' do
+      count = 0
+
+      sum = r.memoize(lambda do |a, b, c|
+        count += 1
+        a + b + c
+      end)
+
+      expect(sum.call(10, 20, 30)).to be(60)
+      expect(sum.call(10, 20, 30)).to be(60)
+      expect(sum.call(10, 20, 30)).to be(60)
+
+      expect(count).to be(1)
+    end
+
+    it 'is curried' do
+      count = 0
+
+      sum = r.memoize(lambda do |a, b, c|
+        count += 1
+        a + b + c
+      end)
+
+      expect(sum.call(10).call(20).call(30)).to be(60)
+      expect(sum.call(10, 20).call(30)).to be(60)
+      expect(sum.call(10, 20, 30)).to be(60)
+
+      expect(count).to be(1)
+    end
+  end
+
+  context '#n_ary' do
+    it 'from docs' do
+      takes_two_args = ->(a, b) { [a, b] }
+
+      # expect(takes_two_args.arity).to be(2)
+      expect(takes_two_args.call(1, 2)).to eq([1, 2])
+
+      takes_one_arg = r.n_ary(1, takes_two_args)
+      # expect(takes_one_arg.arity).to be(1)
+      expect(takes_one_arg.call(1, 2)).to eq([1, nil])
+    end
+  end
+
+  context '#once' do
+    it 'from docs' do
+      add_one_once = r.once(->(x) { x + 1 })
+      expect(add_one_once.call(10)).to eq(11)
+      expect(add_one_once.call(add_one_once.call(50))).to eq(11)
+    end
+  end
+
+  context '#pipe' do
+    it 'from docs' do
+      classy_greeting = lambda do |first_name, last_name|
+        "The name's #{last_name}, #{first_name} #{last_name}"
+      end
+      abs = ->(val) { val < 0 ? -1 * val : val }
+
+      expect(r.pipe(classy_greeting, R.to_upper).call('James', 'Bond'))
+        .to eq("THE NAME'S BOND, JAMES BOND")
+
+      expect(r.pipe(R.multiply(2), R.add(1), abs).call(-4)).to be(7)
+    end
+  end
+
+  context '#tap' do
+    it 'from docs' do
+      say_x = instance_double(Proc)
+      expect(say_x).to receive(:call).with(100)
+      expect(r.tap(say_x, 100)).to be(100)
+    end
+  end
+
+  context '#use_with' do
+    it 'from docs' do
+      pow = ->(x, count) { Array.new(count, x).reduce(:*) }
+
+      expect(r.use_with(pow, [R.identity, R.identity]).call(3, 4)).to eq(81)
+      expect(r.use_with(pow, [R.identity, R.identity]).call(3).call(4)).to eq(81)
+      expect(r.use_with(pow, [R.dec, R.inc]).call(3, 4)).to eq(32)
+      expect(r.use_with(pow, [R.dec, R.inc]).call(3).call(4)).to eq(32)
+    end
+  end
+end

data/spec/ramda/internal/curried_method_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Ramda::Internal::CurriedMethod do
+  let(:instance) { Class.new { extend Ramda::Internal::CurriedMethod } }
+
+  it '#curried_method' do
+    instance.curried_method(:sample_method) do |a, b, c|
+      a + b + c
+    end
+
+    expect(instance.sample_method.call(1).call(2).call(3)).to be(6)
+    expect(instance.sample_method(1).call(2).call(3)).to be(6)
+    expect(instance.sample_method(1, 2).call(3)).to be(6)
+    expect(instance.sample_method(1, 2, 3)).to be(6)
+  end
+end

data/spec/ramda/list_spec.rb

@@ -0,0 +1,399 @@
+require 'spec_helper'
+
+describe Ramda::List do
+  let(:r) { described_class }
+
+  context '#all' do
+    it 'test' do
+      equals3 = R.equals(3)
+      expect(r.all(equals3, [3, 3, 3, 3])).to be_truthy
+      expect(r.all(equals3, [3, 3, 1, 3])).to be_falsey
+    end
+
+    it 'is curried' do
+      equals3 = R.equals(3)
+      expect(r.all(equals3).call([3, 3, 3])).to be_truthy
+    end
+  end
+
+  context '#any' do
+    it 'test' do
+      greater_than0 = R.lt(1)
+      greater_than2 = R.lt(2)
+
+      expect(r.any(greater_than0, [0, 1])).to be_falsey
+      expect(r.any(greater_than2, [2, 3])).to be_truthy
+    end
+
+    it 'is curried' do
+      greater_than0 = R.lt(1)
+
+      expect(r.any(greater_than0)[[0, 1]]).to be_falsey
+    end
+  end
+
+  context '#append' do
+    it 'from docs' do
+      expect(r.append('tests', ['write', 'more'])).to eq(['write', 'more', 'tests'])
+      expect(r.append('tests', [])).to eq(['tests'])
+      expect(r.append(['tests'], ['write', 'more'])).to eq(['write', 'more', ['tests']])
+    end
+
+    it 'is curried' do
+      expect(R.append(1).call([4, 3, 2])).to eq([4, 3, 2, 1])
+    end
+  end
+
+  context '#concat' do
+    it 'from docs' do
+      expect(r.concat('ABC', 'DEF')).to eq('ABCDEF')
+      expect(r.concat([4, 5, 6], [1, 2, 3])).to eql([4, 5, 6, 1, 2, 3])
+      expect(r.concat([], [])).to eql([])
+    end
+
+    it 'is curried' do
+      expect(r.concat('ABC').call('DEF')).to eq('ABCDEF')
+    end
+  end
+
+  context '#contains' do
+    it 'from docs' do
+      expect(r.contains(3, [1, 2, 3])).to be_truthy
+      expect(r.contains(4, [1, 2, 3])).to be_falsey
+      expect(r.contains({ name: 'Fred' }, [{ name: 'Fred' }])).to be_truthy
+      expect(r.contains([42], [[42]])).to be_truthy
+    end
+
+    it 'is curried' do
+      expect(r.contains(3).call([1, 2, 3]))
+    end
+  end
+
+  context '#drop' do
+    it 'from docs' do
+      expect(r.drop(1, ['foo', 'bar', 'baz'])).to eq(['bar', 'baz'])
+      expect(r.drop(2, ['foo', 'bar', 'baz'])).to eq(['baz'])
+      expect(r.drop(3, ['foo', 'bar', 'baz'])).to eq([])
+      expect(r.drop(4, ['foo', 'bar', 'baz'])).to eq([])
+      expect(r.drop(3, 'ramda')).to eq('da')
+    end
+
+    it 'is curried' do
+      expect(r.drop(3).call('ramda')).to eq('da')
+    end
+  end
+
+  context '#filter' do
+    def is_even
+      ->(n) { n.even? }
+    end
+
+    it 'from docs' do
+      expect(r.filter(is_even, [1, 2, 3, 4])).to eq([2, 4])
+      expect(r.filter(is_even, a: 1, b: 2, c: 3, d: 4)).to eq(b: 2, d: 4)
+    end
+
+    it 'is curried' do
+      expect(r.filter(is_even).call([1, 2, 3, 4])).to eq([2, 4])
+    end
+  end
+
+  context '#find' do
+    it 'from docs' do
+      list = [{ a: 1 }, { a: 2 }, { a: 3 }]
+
+      expect(r.find(R.prop_eq(:a, 2), list)).to eq(a: 2)
+      expect(r.find(R.prop_eq(:a, 4), list)).to be_nil
+    end
+
+    it 'is curried' do
+      list = [{ a: 1 }, { a: 2 }, { a: 3 }]
+
+      expect(r.find(R.prop_eq(:a, 2)).call(list)).to eq(a: 2)
+    end
+  end
+
+  context '#flatten' do
+    it 'from docs' do
+      expect(r.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]))
+        .to eq([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
+    end
+  end
+
+  context '#group_by' do
+    it 'from docs' do
+      by_grade = lambda do |student|
+        case student.fetch(:score)
+        when 0...65 then 'F'
+        when 0...70 then 'D'
+        when 0...80 then 'C'
+        when 0...90 then 'B'
+        else
+          'A'
+        end
+      end
+      students = [
+        { name: 'Abby', score: 84 },
+        { name: 'Eddy', score: 58 },
+        { name: 'Jack', score: 69 }
+      ]
+      expect(r.group_by(by_grade, students)).to eq(
+        'D' => [{ name: 'Jack', score: 69 }],
+        'F' => [{ name: 'Eddy', score: 58 }],
+        'B' => [{ name: 'Abby', score: 84 }]
+      )
+    end
+
+    it 'is curried' do
+      students = [
+        { name: 'Mike', age: 30 },
+        { name: 'Tom', age: 25 },
+        { name: 'Tom', age: 20 }
+      ]
+
+      group_by_name = r.group_by(->(a) { a.fetch(:name) })
+      expect(group_by_name.call(students)).to eq(
+        'Tom' => [{ name: 'Tom', age: 25 }, { name: 'Tom', age: 20 }],
+        'Mike' => [{ name: 'Mike', age: 30 }]
+      )
+    end
+  end
+
+  context '#head' do
+    it 'from docs' do
+      expect(r.head(['fi', 'fo', 'fum'])).to eq('fi')
+      expect(r.head([])).to be_nil
+      expect(r.head('abc')).to eq('a')
+      expect(r.head('')).to eq('')
+    end
+  end
+
+  context '#index_of' do
+    it 'from docs' do
+      expect(r.index_of(3, [1, 2, 3, 4])).to be(2)
+      expect(r.index_of(1, [1, 2, 3, 4])).to be(0)
+      expect(r.index_of(10, [1, 2, 3, 4])).to be(-1)
+    end
+  end
+
+  context '#join' do
+    it 'from docs' do
+      expect(r.join('|', [1, 2, 3])).to eq('1|2|3')
+    end
+
+    it 'is curried' do
+      spacer = r.join(' ')
+      expect(spacer.call(['a', 2, 3.4])).to eq('a 2 3.4')
+    end
+  end
+
+  context '#last_index_of' do
+    it 'from docs' do
+      expect(r.last_index_of(3, [-1, 3, 3, 0, 1, 2, 3, 4])).to be(6)
+      expect(r.last_index_of(10, [1, 2, 3, 4])).to be(-1)
+    end
+  end
+
+  context '#length' do
+    it 'from docs' do
+      expect(r.length([])).to eq(0)
+      expect(r.length([1, 2, 3])).to eq(3)
+    end
+  end
+
+  context '#map' do
+    it 'from docs' do
+      double_fn = ->(x) { x * 2 }
+
+      expect(r.map(double_fn, [1, 2, 3])).to eq([2, 4, 6])
+      expect(r.map(double_fn, x: 1, y: 2, z: 3)).to eq(x: 2, y: 4, z: 6)
+    end
+
+    it 'is curried' do
+      double_fn = ->(x) { x * 2 }
+
+      expect(r.map(double_fn).call([1, 2, 3])).to eq([2, 4, 6])
+    end
+  end
+
+  context '#nth' do
+    it 'from docs' do
+      list = ['foo', 'bar', 'baz', 'quux']
+      expect(r.nth(1, list)).to eq('bar')
+      expect(r.nth(-1, list)).to eq('quux')
+      expect(r.nth(-99, list)).to be_nil
+
+      expect(r.nth(2, 'abc')).to eq('c')
+      expect(r.nth(3, 'abc')).to eq('')
+    end
+  end
+
+  context '#pluck' do
+    it 'from docs' do
+      expect(r.pluck(:a).call([{ a: 1 }, { a: 2 }])).to eq([1, 2])
+      expect(r.pluck(0).call([[1, 2], [3, 4]])).to eq([1, 3])
+    end
+  end
+
+  context '#prepend' do
+    it 'from docs' do
+      expect(r.prepend('fee').call(['fi', 'fo', 'fum'])).to eq(['fee', 'fi', 'fo', 'fum'])
+    end
+  end
+
+  context '#range' do
+    it 'from docs' do
+      expect(r.range(1, 5)).to eq([1, 2, 3, 4])
+      expect(r.range(50, 53)).to eq([50, 51, 52])
+    end
+  end
+
+  context '#reduce' do
+    it 'from docs' do
+      # ((((0 - 1) - 2) - 3) - 4) = -10
+      expect(r.reduce(R.subtract, 0, [1, 2, 3, 4])).to be(-10)
+    end
+  end
+
+  context '#reduce_right' do
+    def avg
+      ->(a, b) { (a + b) / 2 }
+    end
+
+    it 'from docs' do
+      # (1 - (2 - (3 - (4 - 0)))))
+      expect(r.reduce_right(R.subtract, 0, [1, 2, 3, 4])).to be(-2)
+    end
+
+    it 'returns the accumulator for an empty array' do
+      expect(r.reduce_right(avg, 0, [])).to eq(0)
+    end
+
+    it 'is curried' do
+      something = r.reduce_right(avg, 54)
+      rcat = r.reduce_right(R.concat, '')
+      expect(something.call([12, 4, 10, 6])).to eq(12)
+      expect(rcat.call(['1', '2', '3', '4'])).to eq('1234')
+    end
+  end
+
+  context '#reverse' do
+    it 'from docs' do
+      expect(r.reverse([1, 2, 3])).to eq([3, 2, 1])
+      expect(r.reverse([1, 2])).to eq([2, 1])
+      expect(r.reverse([1])).to eq([1])
+      expect(r.reverse([])).to eq([])
+
+      expect(r.reverse('abc')).to eq('cba')
+      expect(r.reverse('ab')).to eq('ba')
+      expect(r.reverse('a')).to eq('a')
+      expect(r.reverse('')).to eq('')
+    end
+  end
+
+  context '#reject' do
+    it 'from docs' do
+      is_odd = ->(n) { n.odd? }
+
+      expect(r.reject(is_odd, [1, 2, 3, 4])).to eq([2, 4])
+      expect(r.reject(is_odd, a: 1, b: 2, c: 3, d: 4)).to eq(b: 2, d: 4)
+    end
+  end
+
+  context '#sort' do
+    it 'from docs' do
+      diff = ->(a, b) { a - b }
+      expect(r.sort(diff, [4, 2, 7, 5])).to eq([2, 4, 5, 7])
+    end
+  end
+
+  context '#tail' do
+    it 'from docs' do
+      expect(r.tail([1, 2, 3])).to eq([2, 3])
+      expect(r.tail([1, 2])).to eq([2])
+      expect(r.tail([1])).to eq([])
+      expect(r.tail([])).to eq([])
+
+      expect(r.tail('abc')).to eq('bc')
+      expect(r.tail('ab')).to eq('b')
+      expect(r.tail('a')).to eq('')
+      expect(r.tail('')).to eq('')
+    end
+  end
+
+  context '#take' do
+    it 'is curried' do
+      personnel = [
+        'Dave Brubeck',
+        'Paul Desmond',
+        'Eugene Wright',
+        'Joe Morello',
+        'Gerry Mulligan',
+        'Bob Bates',
+        'Joe Dodge',
+        'Ron Crotty'
+      ]
+
+      take_five = r.take(5)
+      expect(take_five.call(personnel)).to eq(
+        ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']
+      )
+    end
+
+    it 'can operate on arrays' do
+      expect(r.take(10, [])).to eq([])
+      expect(r.take(4, ['foo', 'bar', 'baz'])).to eq(['foo', 'bar', 'baz'])
+      expect(r.take(3, ['foo', 'bar', 'baz'])).to eq(['foo', 'bar', 'baz'])
+      expect(r.take(2, ['foo', 'bar', 'baz'])).to eq(['foo', 'bar'])
+      expect(r.take(1, ['foo', 'bar', 'baz'])).to eq(['foo'])
+      expect(r.take(0, ['foo', 'bar', 'baz'])).to eq([])
+    end
+
+    it 'can operate on strings' do
+      expect(r.take(10, 'Ramda')).to eq('Ramda')
+      expect(r.take(3, 'Ramda')).to eq('Ram')
+      expect(r.take(2, 'Ramda')).to eq('Ra')
+      expect(r.take(1, 'Ramda')).to eq('R')
+      expect(r.take(0, 'Ramda')).to eq('')
+    end
+  end
+
+  context '#take_while' do
+    it 'from docs' do
+      is_not_four = ->(x) { x != 4 }
+
+      expect(r.take_while(is_not_four, [1, 2, 3, 4, 3, 2, 1])).to eq([1, 2, 3])
+      expect(r.take_while(is_not_four, [1, 2, 3])).to eq([1, 2, 3])
+    end
+  end
+
+  context '#uniq' do
+    it 'from docs' do
+      expect(r.uniq([1, 1, 2, 1])).to eq([1, 2])
+      expect(r.uniq([1, '1'])).to eq([1, '1'])
+      expect(r.uniq([[42], [42]])).to eq([[42]])
+    end
+  end
+
+  context '#xprod' do
+    it 'from docs' do
+      expect(r.xprod([1, 2], ['a', 'b']))
+        .to eq([[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']])
+    end
+  end
+
+  context '#zip' do
+    it 'from docs' do
+      expect(r.zip([1, 2, 3], ['a', 'b', 'c'])).to eq([[1, 'a'], [2, 'b'], [3, 'c']])
+      expect(r.zip([1, 2, 3], ['a', 'b', 'c', 'd'])).to eq([[1, 'a'], [2, 'b'], [3, 'c']])
+    end
+  end
+
+  context '#zip_with' do
+    it 'from docs' do
+      f = ->(x, y) { Ramda.join('', [x, y]) }
+
+      expect(r.zip_with(f, [1, 2, 3], ['a', 'b', 'c'])).to eq(['1a', '2b', '3c'])
+    end
+  end
+end