fix spelling of returing to returning (#178)

src/Async/eitherToAsync.js

@@ -19,7 +19,7 @@ function eitherToAsync(either) {
       const m = either(x)
 
       if(!isSameType(Either, m)) {
-        throw new TypeError('eitherToAsync: Either returing function required')
+        throw new TypeError('eitherToAsync: Either returning function required')
       }
 
       return applyTransform(m)
@@ -30,7 +30,7 @@ function eitherToAsync(either) {
     return applyTransform(either)
   }
 
-  throw new TypeError('eitherToAsync: Either or Either returing function required')
+  throw new TypeError('eitherToAsync: Either or Either returning function required')
 }
 
 module.exports = curry(eitherToAsync)

src/Async/eitherToAsync.spec.js

@@ -20,7 +20,7 @@ test('eitherToAsync transform', t => {
 
   t.ok(isFunction(eitherToAsync), 'is a function')
 
-  const err = /eitherToAsync: Either or Either returing function required/
+  const err = /eitherToAsync: Either or Either returning function required/
   t.throws(f(undefined), err, 'throws if arg is undefined')
   t.throws(f(null), err, 'throws if arg is null')
   t.throws(f(0), err, 'throws if arg is a falsey number')
@@ -65,7 +65,7 @@ test('eitherToAsync with Either returning function', t => {
 
   const f = bindFunc(eitherToAsync(identity))
 
-  const err = /eitherToAsync: Either returing function required/
+  const err = /eitherToAsync: Either returning function required/
   t.throws(f(undefined), err, 'throws if function returns undefined')
   t.throws(f(null), err, 'throws if function returns null')
   t.throws(f(0), err, 'throws if function returns a falsey number')

src/Async/firstToAsync.js

@@ -24,7 +24,7 @@ function firstToAsync(left, first) {
       const m = first(x)
 
       if(!isSameType(First, m)) {
-        throw new TypeError('firstToAsync: First returing function required for second argument')
+        throw new TypeError('firstToAsync: First returning function required for second argument')
       }
 
       return applyTransform(left, m)
@@ -35,7 +35,7 @@ function firstToAsync(left, first) {
     return applyTransform(left, first)
   }
 
-  throw new TypeError('firstToAsync: First or First returing function required for second argument')
+  throw new TypeError('firstToAsync: First or First returning function required for second argument')
 }
 
 module.exports = curry(firstToAsync)

src/Async/firstToAsync.spec.js

@@ -22,7 +22,7 @@ test('firstToAsync transform', t => {
 
   t.ok(isFunction(firstToAsync), 'is a function')
 
-  const err = /firstToAsync: First or First returing function required for second argument/
+  const err = /firstToAsync: First or First returning function required for second argument/
   t.throws(f(x, undefined), err, 'throws if second arg is undefined')
   t.throws(f(x, null), err, 'throws if second arg is null')
   t.throws(f(x, 0), err, 'throws if second arg is a falsey number')
@@ -67,7 +67,7 @@ test('firstToAsync with First returning function', t => {
 
   const f = bindFunc(firstToAsync(none, identity))
 
-  const err = /firstToAsync: First returing function required for second argument/
+  const err = /firstToAsync: First returning function required for second argument/
   t.throws(f(undefined), err, 'throws if function returns undefined')
   t.throws(f(null), err, 'throws if function returns null')
   t.throws(f(0), err, 'throws if function returns a falsey number')

src/Async/lastToAsync.js

@@ -24,7 +24,7 @@ function lastToAsync(left, last) {
       const m = last(x)
 
       if(!isSameType(Last, m)) {
-        throw new TypeError('lastToAsync: Last returing function required for second argument')
+        throw new TypeError('lastToAsync: Last returning function required for second argument')
       }
 
       return applyTransform(left, m)
@@ -35,7 +35,7 @@ function lastToAsync(left, last) {
     return applyTransform(left, last)
   }
 
-  throw new TypeError('lastToAsync: Last or Last returing function required for second argument')
+  throw new TypeError('lastToAsync: Last or Last returning function required for second argument')
 }
 
 module.exports = curry(lastToAsync)

src/Async/lastToAsync.spec.js

@@ -22,7 +22,7 @@ test('lastToAsync transform', t => {
 
   t.ok(isFunction(lastToAsync), 'is a function')
 
-  const err = /lastToAsync: Last or Last returing function required for second argument/
+  const err = /lastToAsync: Last or Last returning function required for second argument/
   t.throws(f(x, undefined), err, 'throws if second arg is undefined')
   t.throws(f(x, null), err, 'throws if second arg is null')
   t.throws(f(x, 0), err, 'throws if second arg is a falsey number')
@@ -67,7 +67,7 @@ test('lastToAsync with Last returning function', t => {
 
   const f = bindFunc(lastToAsync(none, identity))
 
-  const err = /lastToAsync: Last returing function required for second argument/
+  const err = /lastToAsync: Last returning function required for second argument/
   t.throws(f(undefined), err, 'throws if function returns undefined')
   t.throws(f(null), err, 'throws if function returns null')
   t.throws(f(0), err, 'throws if function returns a falsey number')

src/Async/maybeToAsync.js

@@ -24,7 +24,7 @@ function maybeToAsync(left, maybe) {
       const m = maybe(x)
 
       if(!isSameType(Maybe, m)) {
-        throw new TypeError('maybeToAsync: Maybe returing function required for second argument')
+        throw new TypeError('maybeToAsync: Maybe returning function required for second argument')
       }
 
       return applyTransform(left, m)
@@ -35,7 +35,7 @@ function maybeToAsync(left, maybe) {
     return applyTransform(left, maybe)
   }
 
-  throw new TypeError('maybeToAsync: Maybe or Maybe returing function required for second argument')
+  throw new TypeError('maybeToAsync: Maybe or Maybe returning function required for second argument')
 }
 
 module.exports = curry(maybeToAsync)

src/Async/maybeToAsync.spec.js

@@ -22,7 +22,7 @@ test('maybeToAsync transform', t => {
 
   t.ok(isFunction(maybeToAsync), 'is a function')
 
-  const err = /maybeToAsync: Maybe or Maybe returing function required for second argument/
+  const err = /maybeToAsync: Maybe or Maybe returning function required for second argument/
   t.throws(f(x, undefined), err, 'throws if second arg is undefined')
   t.throws(f(x, null), err, 'throws if second arg is null')
   t.throws(f(x, 0), err, 'throws if second arg is a falsey number')
@@ -67,7 +67,7 @@ test('maybeToAsync with Maybe returning function', t => {
 
   const f = bindFunc(maybeToAsync(none, identity))
 
-  const err = /maybeToAsync: Maybe returing function required for second argument/
+  const err = /maybeToAsync: Maybe returning function required for second argument/
   t.throws(f(undefined), err, 'throws if function returns undefined')
   t.throws(f(null), err, 'throws if function returns null')
   t.throws(f(0), err, 'throws if function returns a falsey number')

src/Async/resultToAsync.js

@@ -19,7 +19,7 @@ function resultToAsync(result) {
       const m = result(x)
 
       if(!isSameType(Result, m)) {
-        throw new TypeError('resultToAsync: Result returing function required')
+        throw new TypeError('resultToAsync: Result returning function required')
       }
 
       return applyTransform(m)
@@ -30,7 +30,7 @@ function resultToAsync(result) {
     return applyTransform(result)
   }
 
-  throw new TypeError('resultToAsync: Result or Result returing function required')
+  throw new TypeError('resultToAsync: Result or Result returning function required')
 }
 
 module.exports = curry(resultToAsync)

src/Async/resultToAsync.spec.js

@@ -19,7 +19,7 @@ test('resultToAsync transform', t => {
 
   t.ok(isFunction(resultToAsync), 'is a function')
 
-  const err = /resultToAsync: Result or Result returing function required/
+  const err = /resultToAsync: Result or Result returning function required/
   t.throws(f(undefined), err, 'throws if arg is undefined')
   t.throws(f(null), err, 'throws if arg is null')
   t.throws(f(0), err, 'throws if arg is a falsey number')
@@ -64,7 +64,7 @@ test('resultToAsync with Result returning function', t => {
 
   const f = bindFunc(resultToAsync(identity))
 
-  const err = /resultToAsync: Result returing function required/
+  const err = /resultToAsync: Result returning function required/
   t.throws(f(undefined), err, 'throws if function returns undefined')
   t.throws(f(null), err, 'throws if function returns null')
   t.throws(f(0), err, 'throws if function returns a falsey number')

src/Either/firstToEither.js

@@ -24,7 +24,7 @@ function firstToEither(left, first) {
       const m = first(x)
 
       if(!isSameType(First, m)) {
-        throw new TypeError('firstToEither: First returing function required for second argument')
+        throw new TypeError('firstToEither: First returning function required for second argument')
       }
 
       return applyTransform(left, m)
@@ -35,7 +35,7 @@ function firstToEither(left, first) {
     return applyTransform(left, first)
   }
 
-  throw new TypeError('firstToEither: First or First returing function required for second argument')
+  throw new TypeError('firstToEither: First or First returning function required for second argument')
 }
 
 module.exports = curry(firstToEither)

src/Either/firstToEither.spec.js

@@ -19,7 +19,7 @@ test('firstToEither transform', t => {
 
   t.ok(isFunction(firstToEither), 'is a function')
 
-  const err = /firstToEither: First or First returing function required for second argument/
+  const err = /firstToEither: First or First returning function required for second argument/
   t.throws(f(x, undefined), err, 'throws if second arg is undefined')
   t.throws(f(x, null), err, 'throws if second arg is null')
   t.throws(f(x, 0), err, 'throws if second arg is a falsey number')
@@ -58,7 +58,7 @@ test('firstToEither with First returning function', t => {
 
   const f = bindFunc(firstToEither(none, identity))
 
-  const err = /firstToEither: First returing function required for second argument/
+  const err = /firstToEither: First returning function required for second argument/
   t.throws(f(undefined), err, 'throws if function returns undefined')
   t.throws(f(null), err, 'throws if function returns null')
   t.throws(f(0), err, 'throws if function returns a falsey number')

src/Either/lastToEither.js

@@ -24,7 +24,7 @@ function lastToEither(left, last) {
       const m = last(x)
 
       if(!isSameType(Last, m)) {
-        throw new TypeError('lastToEither: Last returing function required for second argument')
+        throw new TypeError('lastToEither: Last returning function required for second argument')
       }
 
       return applyTransform(left, m)
@@ -35,7 +35,7 @@ function lastToEither(left, last) {
     return applyTransform(left, last)
   }
 
-  throw new TypeError('lastToEither: Last or Last returing function required for second argument')
+  throw new TypeError('lastToEither: Last or Last returning function required for second argument')
 }
 
 module.exports = curry(lastToEither)

src/Either/lastToEither.spec.js

@@ -18,7 +18,7 @@ test('lastToEither transform', t => {
 
   t.ok(isFunction(lastToEither), 'is a function')
 
-  const err = /lastToEither: Last or Last returing function required for second argument/
+  const err = /lastToEither: Last or Last returning function required for second argument/
   t.throws(f(x, undefined), err, 'throws if second arg is undefined')
   t.throws(f(x, null), err, 'throws if second arg is null')
   t.throws(f(x, 0), err, 'throws if second arg is a falsey number')
@@ -57,7 +57,7 @@ test('lastToEither with Last returning function', t => {
 
   const f = bindFunc(lastToEither(none, identity))
 
-  const err = /lastToEither: Last returing function required for second argument/
+  const err = /lastToEither: Last returning function required for second argument/
   t.throws(f(undefined), err, 'throws if function returns undefined')
   t.throws(f(null), err, 'throws if function returns null')
   t.throws(f(0), err, 'throws if function returns a falsey number')

src/Either/maybeToEither.js

@@ -24,7 +24,7 @@ function maybeToEither(left, maybe) {
       const m = maybe(x)
 
       if(!isSameType(Maybe, m)) {
-        throw new TypeError('maybeToEither: Maybe returing function required for second argument')
+        throw new TypeError('maybeToEither: Maybe returning function required for second argument')
       }
 
       return applyTransform(left, m)
@@ -35,7 +35,7 @@ function maybeToEither(left, maybe) {
     return applyTransform(left, maybe)
   }
 
-  throw new TypeError('maybeToEither: Maybe or Maybe returing function required for second argument')
+  throw new TypeError('maybeToEither: Maybe or Maybe returning function required for second argument')
 }
 
 module.exports = curry(maybeToEither)

src/Either/maybeToEither.spec.js

@@ -19,7 +19,7 @@ test('maybeToEither transform', t => {
 
   t.ok(isFunction(maybeToEither), 'is a function')
 
-  const err = /maybeToEither: Maybe or Maybe returing function required for second argument/
+  const err = /maybeToEither: Maybe or Maybe returning function required for second argument/
   t.throws(f(x, undefined), err, 'throws if second arg is undefined')
   t.throws(f(x, null), err, 'throws if second arg is null')
   t.throws(f(x, 0), err, 'throws if second arg is a falsey number')
@@ -58,7 +58,7 @@ test('maybeToEither with Maybe returning function', t => {
 
   const f = bindFunc(maybeToEither(none, identity))
 
-  const err = /maybeToEither: Maybe returing function required for second argument/
+  const err = /maybeToEither: Maybe returning function required for second argument/
   t.throws(f(undefined), err, 'throws if function returns undefined')
   t.throws(f(null), err, 'throws if function returns null')
   t.throws(f(0), err, 'throws if function returns a falsey number')

src/Either/resultToEither.js

@@ -19,7 +19,7 @@ function resultToEither(result) {
       const m = result(x)
 
       if(!isSameType(Result, m)) {
-        throw new TypeError('resultToEither: Result returing function required')
+        throw new TypeError('resultToEither: Result returning function required')
       }
 
       return applyTransform(m)
@@ -30,7 +30,7 @@ function resultToEither(result) {
     return applyTransform(result)
   }
 
-  throw new TypeError('resultToEither: Result or Result returing function required')
+  throw new TypeError('resultToEither: Result or Result returning function required')
 }
 
 module.exports = curry(resultToEither)

src/Either/resultToEither.spec.js

@@ -19,7 +19,7 @@ test('resultToEither transform', t => {
 
   t.ok(isFunction(resultToEither), 'is a function')
 
-  const err = /resultToEither: Result or Result returing function required/
+  const err = /resultToEither: Result or Result returning function required/
   t.throws(f(undefined), err, 'throws if arg is undefined')
   t.throws(f(null), err, 'throws if arg is null')
   t.throws(f(0), err, 'throws if arg is a falsey number')
@@ -58,7 +58,7 @@ test('resultToEither with Result returning function', t => {
 
   const f = bindFunc(resultToEither(identity))
 
-  const err = /resultToEither: Result returing function required/
+  const err = /resultToEither: Result returning function required/
   t.throws(f(undefined), err, 'throws if function returns undefined')
   t.throws(f(null), err, 'throws if function returns null')
   t.throws(f(0), err, 'throws if function returns a falsey number')

src/First/eitherToFirst.js

@@ -19,7 +19,7 @@ function eitherToFirst(either) {
       const m = either(x)
 
       if(!isSameType(Either, m)) {
-        throw new TypeError('eitherToFirst: Either returing function required')
+        throw new TypeError('eitherToFirst: Either returning function required')
       }
 
       return applyTransform(m)
@@ -30,7 +30,7 @@ function eitherToFirst(either) {
     return applyTransform(either)
   }
 
-  throw new TypeError('eitherToFirst: Either or Either returing function required')
+  throw new TypeError('eitherToFirst: Either or Either returning function required')
 }
 
 module.exports = curry(eitherToFirst)

src/First/eitherToFirst.spec.js

@@ -18,7 +18,7 @@ test('eitherToFirst transform', t => {
 
   t.ok(isFunction(eitherToFirst), 'is a function')
 
-  const err = /eitherToFirst: Either or Either returing function required/
+  const err = /eitherToFirst: Either or Either returning function required/
   t.throws(f(undefined), err, 'throws if arg is undefined')
   t.throws(f(null), err, 'throws if arg is null')
   t.throws(f(0), err, 'throws if arg is a falsey number')
@@ -57,7 +57,7 @@ test('eitherToFirst with Either returning function', t => {
 
   const f = bindFunc(eitherToFirst(identity))
 
-  const err = /eitherToFirst: Either returing function required/
+  const err = /eitherToFirst: Either returning function required/
   t.throws(f(undefined), err, 'throws if function returns undefined')
   t.throws(f(null), err, 'throws if function returns null')
   t.throws(f(0), err, 'throws if function returns a falsey number')

src/First/lastToFirst.js

@@ -19,7 +19,7 @@ function lastToFirst(last) {
       const m = last(x)
 
       if(!isSameType(Last, m)) {
-        throw new TypeError('lastToFirst: Last returing function required')
+        throw new TypeError('lastToFirst: Last returning function required')
       }
 
       return applyTransform(m)
@@ -30,7 +30,7 @@ function lastToFirst(last) {
     return applyTransform(last)
   }
 
-  throw new TypeError('lastToFirst: Last or Last returing function required')
+  throw new TypeError('lastToFirst: Last or Last returning function required')
 }
 
 module.exports = curry(lastToFirst)

src/First/lastToFirst.spec.js

@@ -18,7 +18,7 @@ test('lastToFirst transform', t => {
 
   t.ok(isFunction(lastToFirst), 'is a function')
 
-  const err = /lastToFirst: Last or Last returing function required/
+  const err = /lastToFirst: Last or Last returning function required/
   t.throws(f(undefined), err, 'throws if arg is undefined')
   t.throws(f(null), err, 'throws if arg is null')
   t.throws(f(0), err, 'throws if arg is a falsey number')
@@ -57,7 +57,7 @@ test('lastToFirst with Last returning function', t => {
 
   const f = bindFunc(lastToFirst(identity))
 
-  const err = /lastToFirst: Last returing function required/
+  const err = /lastToFirst: Last returning function required/
   t.throws(f(undefined), err, 'throws if function returns undefined')
   t.throws(f(null), err, 'throws if function returns null')
   t.throws(f(0), err, 'throws if function returns a falsey number')