From a82f202690846adbe0ef7b4f2a87c92f5afc560f Mon Sep 17 00:00:00 2001
From: Avaq <aldwin.vlasblom@gmail.com>
Date: Sat, 4 Feb 2017 18:11:12 +0100
Subject: [PATCH] Rename S.flip to S.flip_ and S.C to S.flip

---
 index.js      | 44 +++++++++++++++-----------------------------
 test/C.js     | 18 ------------------
 test/flip.js  |  6 +++---
 test/flip_.js | 18 ++++++++++++++++++
 4 files changed, 36 insertions(+), 50 deletions(-)
 delete mode 100644 test/C.js
 create mode 100644 test/flip_.js

diff --git a/index.js b/index.js
index f2f48fcf..d3909cc4 100644
--- a/index.js
+++ b/index.js
@@ -571,28 +571,6 @@
   }
   S.T = def('T', {}, [a, Fn(a, b), b], T);
 
-  //# C :: (a -> b -> c) -> b -> a -> c
-  //.
-  //. The C combinator. Takes a curried binary function and two values, and
-  //. returns the result of applying the function to the values in reverse
-  //. order. Equivalent to Haskell's `flip` function.
-  //.
-  //. This function is very similar to [`flip`](#flip), except that its first
-  //. argument must be curried. This allows it to work with manually curried
-  //. functions.
-  //.
-  //. ```javascript
-  //. > S.C(S.concat, 'foo', 'bar')
-  //. 'barfoo'
-  //.
-  //. > Z.map(S.C(S.concat, '?'), ['foo', 'bar', 'baz'])
-  //. ['foo?', 'bar?', 'baz?']
-  //. ```
-  function C(f, x, y) {
-    return f(y)(x);
-  }
-  S.C = def('C', {}, [Fn(a, Fn(b, c)), b, a, c], C);
-
   //# S :: (a -> b -> c) -> (a -> b) -> a -> c
   //.
   //. The S combinator. Takes a curried binary function, a unary function,
@@ -711,21 +689,29 @@
       [$.Function([a, b, c, d, e, r]), a, b, c, d, e, r],
       curry5);
 
-  //# flip :: ((a, b) -> c) -> b -> a -> c
+  //# flip :: (a -> b -> c) -> b -> a -> c
   //.
-  //. Takes a binary function and two values, and returns the result of
-  //. applying the function to the values in reverse order.
+  //. Takes a curried binary function and two values, and returns the
+  //. result of applying the function to the values in reverse order.
   //.
-  //. See also [`C`](#C).
+  //. This is the C combinator from combinatory logic.
   //.
   //. ```javascript
-  //. > Z.map(S.flip(Math.pow)(2), [1, 2, 3, 4, 5])
-  //. [1, 4, 9, 16, 25]
+  //. > S.flip(S.concat, 'foo', 'bar')
+  //. 'barfoo'
   //. ```
   function flip(f, x, y) {
+    return f(y)(x);
+  }
+  S.flip = def('flip', {}, [Fn(a, Fn(b, c)), b, a, c], flip);
+
+  //# flip_ :: ((a, b) -> c) -> b -> a -> c
+  //.
+  //. Variant of [`flip`](#flip) which takes an uncurried binary function.
+  function flip_(f, x, y) {
     return f(y, x);
   }
-  S.flip = def('flip', {}, [$.Function([a, b, c]), b, a, c], flip);
+  S.flip_ = def('flip_', {}, [$.Function([a, b, c]), b, a, c], flip_);
 
   //# lift :: Functor f => (a -> b) -> f a -> f b
   //.
diff --git a/test/C.js b/test/C.js
deleted file mode 100644
index 7964f5c6..00000000
--- a/test/C.js
+++ /dev/null
@@ -1,18 +0,0 @@
-'use strict';
-
-var S = require('..');
-
-var eq = require('./internal/eq');
-var map = require('./internal/map');
-
-
-test('C', function() {
-
-  eq(typeof S.C, 'function');
-  eq(S.C.length, 3);
-  eq(S.C.toString(), 'C :: (a -> b -> c) -> b -> a -> c');
-
-  eq(S.C(S.concat, 'foo', 'bar'), 'barfoo');
-  eq(map(S.C(S.concat, '!'))(['BAM', 'POW', 'KA-POW']), ['BAM!', 'POW!', 'KA-POW!']);
-
-});
diff --git a/test/flip.js b/test/flip.js
index fd3d9a37..1bef6b89 100644
--- a/test/flip.js
+++ b/test/flip.js
@@ -10,9 +10,9 @@ test('flip', function() {
 
   eq(typeof S.flip, 'function');
   eq(S.flip.length, 3);
-  eq(S.flip.toString(), 'flip :: ((a, b) -> c) -> b -> a -> c');
+  eq(S.flip.toString(), 'flip :: (a -> b -> c) -> b -> a -> c');
 
-  eq(map(S.flip(Math.pow, 2))([1, 2, 3, 4, 5]), [1, 4, 9, 16, 25]);
-  eq(S.flip(S.indexOf, ['a', 'b', 'c', 'd'], 'c'), S.Just(2));
+  eq(S.flip(S.concat, 'foo', 'bar'), 'barfoo');
+  eq(map(S.flip(S.concat, '!'))(['BAM', 'POW', 'KA-POW']), ['BAM!', 'POW!', 'KA-POW!']);
 
 });
diff --git a/test/flip_.js b/test/flip_.js
new file mode 100644
index 00000000..ba18b892
--- /dev/null
+++ b/test/flip_.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var S = require('..');
+
+var eq = require('./internal/eq');
+var map = require('./internal/map');
+
+
+test('flip_', function() {
+
+  eq(typeof S.flip_, 'function');
+  eq(S.flip_.length, 3);
+  eq(S.flip_.toString(), 'flip_ :: ((a, b) -> c) -> b -> a -> c');
+
+  eq(map(S.flip_(Math.pow, 2))([1, 2, 3, 4, 5]), [1, 4, 9, 16, 25]);
+  eq(S.flip_(S.indexOf, ['a', 'b', 'c', 'd'], 'c'), S.Just(2));
+
+});