From 3b0578526655d3cf49c8ba85978136d5b9e4015e Mon Sep 17 00:00:00 2001
From: Victor Nascimento Bakke <gipphe@gmail.com>
Date: Fri, 12 Jul 2019 01:26:13 +0200
Subject: [PATCH] style: use es6

BREAKING CHANGE: requires either transpilation for older environments
and browsers, or requires you to stick to newer browsers and NodeJS
versions.
---
 .eslintrc.js       |  57 +-------------
 index.js           | 184 +++++++++++++--------------------------------
 package.json       |   2 +-
 test/index.spec.js |  34 ++++-----
 yarn.lock          |   7 ++
 5 files changed, 81 insertions(+), 203 deletions(-)

diff --git a/.eslintrc.js b/.eslintrc.js
index 8eed6e2..47bc9d4 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -1,57 +1,4 @@
 module.exports = {
 	root: true,
-	extends: ['./node_modules/sanctuary-style/eslint-es3.json'],
-	rules: {
-		strict: 'off',
-		indent: [
-			'error',
-			'tab',
-			{
-				'SwitchCase': 1,
-				'FunctionDeclaration': { 'parameters': 'first' },
-				'FunctionExpression': { 'parameters': 'first' },
-				'CallExpression': { 'arguments': 'first' },
-				'ArrayExpression': 'first',
-				'ObjectExpression': 'first',
-				'ignoredNodes': [
-					'CallExpression',
-					'CallExpression > *',
-					'CallExpression > ArrowFunctionExpression ArrowFunctionExpression > *',
-					'CallExpression > FunctionExpression > BlockStatement',
-					'ConditionalExpression',
-					'MemberExpression'
-				],
-			},
-		],
-		'no-tabs': 'off',
-	},
-	overrides: [
-		{
-			files: ['*.md'],
-			globals: {
-				'$': false,
-				'Cons': false,
-				'Descending': false,
-				'Just': false,
-				'Left': false,
-				'Nil': false,
-				'Nothing': false,
-				'Pair': false,
-				'R': false,
-				'Right': false,
-				'S': false,
-				'Sum': false,
-				'localStorage': false,
-				'sanctuary': false,
-				'window': false
-			},
-			rules: {
-				'comma-dangle': ['error', 'always-multiline'],
-				'indent': ['off'],
-				'no-eval': ['off'],
-				'no-extra-semi': ['off'],
-				'no-unused-vars': ['error', { 'varsIgnorePattern': '^([$]|S)$' }]
-			}
-		}
-	]
-}
+	extends: ['@gipphe/eslint-config-haskellish'],
+};
diff --git a/index.js b/index.js
index ebdc10f..2cb30ac 100644
--- a/index.js
+++ b/index.js
@@ -1,75 +1,17 @@
-// UMD setup ripped straight from Q.js
-
-(function(definition) {
-	'use strict';
-
-	// This file will function properly as a <script> tag, or a module
-	// using CommonJS and NodeJS or RequireJS module formats. In
-	// Common/Node/RequireJS, the module exports the caseof API and when
-	// executed as a simple <script>, it creates a caseof global instead.
-
-	/* istanbul ignore next */
-
-	// Montage Require
-	if (typeof bootstrap === 'function') {
-		/* global bootstrap: false */
-		bootstrap ('promise', definition);
-
-	// CommonJS
-	} else if (typeof exports === 'object' && typeof module === 'object') {
-		module.exports = definition ();
-
-	// RequireJS
-	} else if (typeof define === 'function' && define.amd) {
-		define (definition);
-
-	// SES (Secure EcmaScript)
-	} else if (typeof ses !== 'undefined') {
-		/* global ses: true */
-		if (!ses.ok ()) {
-			return;
-		} else {
-			ses.makeCaseof = definition;
-		}
-
-	// <script>
-	} else if (typeof window !== 'undefined' || typeof self !== 'undefined') {
-		/* global window: true */
-		// Prefer window over self for add-on scripts. Use self for
-		// non-windowed contexts.
-		var global = typeof window !== 'undefined' ? window : self;
-
-		// Get the `window` object, save the previous caseof global
-		// and initialize caseof as a global.
-		var previousCaseof = global.caseof;
-		global.caseof = definition ();
-
-		// Add a noConflict function so caseof can be removed from the
-		// global namespace.
-		global.caseof.noConflict = function() {
-			global.caseof = previousCaseof;
-			return this;
-		};
-
-	} else {
-		throw new Error ('This environment was not anticipated by caseof. ' +
-			'Please file a bug.');
-	}
-
-} (function() {
-'use strict';
-
-function assertIsFunction(x, msg) {
+//    assertIsFunction :: a -> String -> Undefined!
+const assertIsFunction = x => msg => {
 	if (typeof x !== 'function') {
 		throw new Error (msg);
 	}
-}
+};
 
-function assertIsFunctionAndExplain(x) {
-	assertIsFunction (x, 'First argument must be a function');
-}
+//    assertIsFunctionAndExplain :: a -> Undefined!
+const assertIsFunctionAndExplain = x => {
+	assertIsFunction (x) ('First argument must be a function');
+};
 
-function assertWasCalledWithOneParameterAndExplain(x, name) {
+//    assertWasCalledWithOneParameterAndExplain :: a -> String -> Undefined!
+const assertWasCalledWithOneParameterAndExplain = x => name => {
 	if (typeof x !== 'undefined') {
 		throw new Error (name + ': ' + name + ' is a curried ' +
 			'function, and as such only takes one argument. ' +
@@ -77,51 +19,41 @@ function assertWasCalledWithOneParameterAndExplain(x, name) {
 			'"fn (x) (y)", instead of ' +
 			'"fn (x, y)"');
 	}
-}
+};
 
-function assertMatchesNotEmpty(x) {
+//    assertMatchesNotEmpty :: [a] -> Undefined!
+const assertMatchesNotEmpty = x => {
 	if (x.length === 0) {
 		throw new Error ('None of the cases matches the value');
 	}
-}
-
-function when(matches) {
-	return function(value) {
-		return function(pred, x) {
-			assertWasCalledWithOneParameterAndExplain
-				(x, 'when');
-			assertIsFunction (pred, 'when: predicate must be a function');
-			return function(handler) {
-				assertIsFunction (handler, 'when: handler must be a function');
-				if (pred (value)) {
-					matches.push (handler (value));
-				}
-			};
-		};
+};
+
+//    when :: [a] -> a -> (a -> Bool) -> (a -> b) -> Undefined!
+const when = matches => value => (pred, x) => {
+	assertWasCalledWithOneParameterAndExplain (x) ('when');
+	assertIsFunction (pred) ('when: predicate must be a function');
+	return handler => {
+		assertIsFunction (handler) ('when: handler must be a function');
+		if (pred (value)) {
+			matches.push (handler (value));
+		}
 	};
-}
-
-function lazyWhen(continuationFn) {
-	return function(matches) {
-		return function(value) {
-			return function(pred, x) {
-				assertWasCalledWithOneParameterAndExplain
-					(x, 'when');
-				assertIsFunction (pred, 'when: predicate must be a function');
-				return function(handler) {
-					assertIsFunction
-						(handler, 'when: handler must be a function');
-					if (!continuationFn (matches)) {
-						return;
-					}
-					if (pred (value)) {
-						matches.push (handler (value));
-					}
-				};
-			};
-		};
+};
+
+//    lazyWhen :: ([a] -> Bool) -> [a] -> a -> (a -> Bool) -> Undefined!
+const lazyWhen = continuationFn => matches => value => (pred, x) => {
+	assertWasCalledWithOneParameterAndExplain (x) ('when');
+	assertIsFunction (pred) ('when: predicate must be a function');
+	return handler => {
+		assertIsFunction (handler) ('when: handler must be a function');
+		if (!continuationFn (matches)) {
+			return;
+		}
+		if (pred (value)) {
+			matches.push (handler (value));
+		}
 	};
-}
+};
 
 //# otherwise :: a -> Boolean
 //.
@@ -142,9 +74,7 @@ function lazyWhen(continuationFn) {
 //. . }) (23)
 //. 0
 //. ```
-function otherwise() {
-	return true;
-}
+const otherwise = () => true;
 
 //# caseOfAll :: ((a -> Boolean) -> (a -> b) -> Undefined) -> a -> Array b
 //.
@@ -173,23 +103,23 @@ function otherwise() {
 //. . }) (0)
 //. ! Error None of the cases matches the value
 //. ```
-function caseOfAll(specFn, x) {
-	assertWasCalledWithOneParameterAndExplain (x, 'caseOfAll');
+const caseOfAll = (specFn, x) => {
+	assertWasCalledWithOneParameterAndExplain (x) ('caseOfAll');
 	assertIsFunctionAndExplain (specFn);
 
-	return function(value) {
-		var matches = [];
-		var boundWhen = when (matches) (value);
+	return value => {
+		const matches = [];
+		const boundWhen = when (matches) (value);
 		specFn (boundWhen);
 		assertMatchesNotEmpty (matches);
 		return matches;
 	};
-}
+};
 
 //# caseOf :: ((a -> Boolean) -> (a -> b) -> Undefined) -> a -> b
 //.
-//. Returns the result of the first matching case. This function is lazy, and
-//. only the first matching handler is run.
+//. Returns the result of the first matching case. This function is lazy,
+//. and only the first matching handler is run.
 //.
 //. ```javascript
 //. > caseOf ((when) => {
@@ -227,24 +157,18 @@ function caseOfAll(specFn, x) {
 //. . }) ('quack')
 //. ! Error: None of the cases matches the value
 //. ```
-function caseOf(specFn, x) {
-	'use strict';
-	assertWasCalledWithOneParameterAndExplain (x, 'caseOf');
+const caseOf = (specFn, x) => {
+	assertWasCalledWithOneParameterAndExplain (x) ('caseOf');
 	assertIsFunctionAndExplain (specFn);
-	return function(value) {
-		var matches = [];
-		var boundWhen = lazyWhen
-			(function(m) { return m.length === 0; })
-			(matches)
-			(value);
+	return value => {
+		const matches = [];
+		const boundWhen = lazyWhen (m => m.length === 0) (matches) (value);
 		specFn (boundWhen);
 		assertMatchesNotEmpty (matches);
 		return matches[0];
 	};
-}
+};
 caseOf.all = caseOfAll;
 caseOf.otherwise = otherwise;
 
-return caseOf;
-
-}));
+module.exports = caseOf;
diff --git a/package.json b/package.json
index a0c9004..21567bb 100644
--- a/package.json
+++ b/package.json
@@ -31,11 +31,11 @@
     "release": "yarn lint && yarn test && yarn standard-version"
   },
   "devDependencies": {
+    "@gipphe/eslint-config-haskellish": "^0.1.3",
     "ava": "^2.2.0",
     "coveralls": "^3.0.2",
     "eslint": "5.16.0",
     "nyc": "^14.1.1",
-    "sanctuary-style": "^3.0.0",
     "standard-version": "^6.0.1",
     "transcribe": "^1.1.2"
   },
diff --git a/test/index.spec.js b/test/index.spec.js
index 099166d..12af3b8 100644
--- a/test/index.spec.js
+++ b/test/index.spec.js
@@ -1,45 +1,45 @@
 import test from 'ava';
 import caseof from '../';
 
-test ('throws when supplied something other than a function as the first argument', (t) => {
+test ('throws when supplied something other than a function as the first argument', t => {
 	const err = t.throws (() => caseof ({}) (), Error);
 	t.is (err.message, 'First argument must be a function');
 });
 
-test ('calls matched function, and returns result of said function', (t) => {
-	const res = caseof ((when) => {
+test ('calls matched function, and returns result of said function', t => {
+	const res = caseof (when => {
 		when (x => typeof x === 'number') (x => x + 1);
 	}) (1);
 	t.is (res, 2);
 });
 
-test ('throws if none of the predicates matched', (t) => {
-	const fn = () => caseof ((when) => {
+test ('throws if none of the predicates matched', t => {
+	const fn = () => caseof (when => {
 		when (x => x === 2) (x => x + 1);
 	}) (3);
 	const err = t.throws (fn, Error);
 	t.is (err.message, 'None of the cases matches the value');
 });
 
-test ('returns result of first handler', (t) => {
-	const res = caseof ((when) => {
+test ('returns result of first handler', t => {
+	const res = caseof (when => {
 		when (x => typeof x === 'number') (x => x + 1);
 		when (x => typeof x === 'number') (x => x - 1);
 	}) (1);
 	t.is (res, 2);
 });
 
-test ('function on a pure side-effect basis', (t) => {
+test ('function on a pure side-effect basis', t => {
 	const foo = 'foo';
-	const res = caseof ((when) => {
+	const res = caseof (when => {
 		when (() => foo === 'bar') (() => 'bar');
 		when (() => foo === 'foo') (() => 'foo');
 	}) ();
 	t.is (res, 'foo');
 });
 
-test ('throws when `when` is passed more than 1 argument as a time', (t) => {
-	const fn = () => caseof ((when) => {
+test ('throws when `when` is passed more than 1 argument as a time', t => {
+	const fn = () => caseof (when => {
 		when (() => {}, () => {});
 	}) ();
 	const err = t.throws (fn, Error);
@@ -49,8 +49,8 @@ test ('throws when `when` is passed more than 1 argument as a time', (t) => {
 		'of "fn (x, y)"');
 });
 
-test ('caseOf.all returns all results', (t) => {
-	const res = caseof.all ((when) => {
+test ('caseOf.all returns all results', t => {
+	const res = caseof.all (when => {
 		when (x => x === 1) (x => x + 1);
 		when (x => x === 1) (x => x - 1);
 		when (x => typeof x !== 'number') (() => 'foo');
@@ -58,11 +58,11 @@ test ('caseOf.all returns all results', (t) => {
 	t.deepEqual (res, [2, 0]);
 });
 
-test ('only first matching case is run', (t) => {
+test ('only first matching case is run', t => {
 	let side1 = false;
 	let side2 = false;
 	let side3 = false;
-	caseof ((when) => {
+	caseof (when => {
 		when (() => true) (() => { side1 = true; });
 		when (() => true) (() => { side2 = true; });
 		when (() => true) (() => { side3 = true; });
@@ -72,8 +72,8 @@ test ('only first matching case is run', (t) => {
 	t.is (side3, false);
 });
 
-test ('default case with otherwise', (t) => {
-	const res = caseof ((when) => {
+test ('default case with otherwise', t => {
+	const res = caseof (when => {
 		when (x => x < 20) (x => x + 10);
 		when (caseof.otherwise) (() => 0);
 	}) (23);
diff --git a/yarn.lock b/yarn.lock
index f523250..d337b30 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -273,6 +273,13 @@
   dependencies:
     arrify "^1.0.1"
 
+"@gipphe/eslint-config-haskellish@^0.1.3":
+  version "0.1.3"
+  resolved "https://registry.yarnpkg.com/@gipphe/eslint-config-haskellish/-/eslint-config-haskellish-0.1.3.tgz#91ea385b93348f86dc99360bc79394806811bc80"
+  integrity sha512-/gh488iR/8tOX6Az7h8GvHLanTX51PYb+XdfPUinJPGM5ur8TlOanu05mq7GDMuwTMo+SNbT2IGIEIrgPyHCig==
+  dependencies:
+    sanctuary-style "^3.0.0"
+
 "@nodelib/fs.scandir@2.1.1":
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.1.tgz#7fa8fed654939e1a39753d286b48b4836d00e0eb"