Methods
(inner) aint(a, b) → {Boolean}
!==
as a function
const { strictEqual: assertIs } = require('assert');
const { assertSequenceEquals, aint, filter, pipe } = require('ferrum');
assertIs(aint(42, 42), false);
assertIs(aint(42)(42), false);
assertIs(aint(42, ""), true);
assertIs(aint(42)(""), true);
assertIs(aint({}, {}), true); // Can only successfully compare primitives
assertIs(aint({})({}), true);
// Remove the value 42 from the list
assertSequenceEquals(
filter([1,2,3,4,42,5,24], aint(42)),
[1,2,3,4,5,24]);
Parameters:
Name | Type | Description |
---|---|---|
a |
A | |
b |
B |
Returns:
- Type
- Boolean
(inner) and(a, b) → {A|B}
The &&
operator as a function.
const { strictEqual: assertIs } = require('assert');
const { and } = require('ferrum');
assertIs(and("", true), "");
assertIs(and(true)(""), "");
assertIs(and(true, 42), 42);
assertIs(and(42)(true), 42);
Parameters:
Name | Type | Description |
---|---|---|
a |
A | |
b |
B |
Returns:
- Type
- A | B
(inner) is(a, b) → {Boolean}
===
as a function
See eq() for a content aware comparison function.
const { strictEqual: assertIs } = require('assert');
const {is, count, filter, pipe} = require('ferrum');
assertIs(is(42, 42), true);
assertIs(is(42)(42), true);
assertIs(is(42, ""), false);
assertIs(is(42)(""), false);
assertIs(is({}, {}), false); // Can only successfully compare primitives
assertIs(is({})({}), false);
// Count how many times the value `42` occurs in the list
const cnt = pipe(
[42, 23, 1, 4, 17, 22, 42],
filter(is(42)),
count);
assertIs(cnt, 2);
Parameters:
Name | Type | Description |
---|---|---|
a |
A | |
b |
B |
Returns:
- Type
- Boolean
(inner) mul(a, b) → {Number}
The *
operator as a function:
const { strictEqual: assertIs } = require('assert');
const { assertSequenceEquals, mul, map } = require('ferrum');
assertIs(mul(3, 4), 12)
assertIs(mul(4)(3), 12);
assertIs(mul(10, 1/2), 5); // Can also be used for division
assertIs(mul(1/2)(10), 5);
// Divide each element in the list by two
assertSequenceEquals(
map([2, 4, 6, 8], mul(1/2)),
[1, 2, 3, 4]);
NOTE: There is no division function, if you need division just
do this: const div = (a, b) => mul(a, 1/b)
;
Parameters:
Name | Type | Description |
---|---|---|
a |
Number | |
b |
Number |
Returns:
- Type
- Number
(inner) nand(a, b) → {Boolean}
NAND as a function.
const { strictEqual: assertIs } = require('assert');
const { nand } = require('ferrum');
assertIs(nand(true, 42), false);
assertIs(nand(true)(42), false);
assertIs(nand(null, false), true);
assertIs(nand(null)(false), true);
assertIs(nand(true, false), true);
assertIs(nand(true)(false), true);
Parameters:
Name | Type | Description |
---|---|---|
a |
A | |
b |
B |
Returns:
- Type
- Boolean
(inner) nor(a, b) → {Boolean}
NOR as a function.
const { strictEqual: assertIs } = require('assert');
const { nor } = require('ferrum');
assertIs(nor(true, true), false);
assertIs(nor(true)(true), false);
assertIs(nor(false, true), false);
assertIs(nor(false)(true), false);
assertIs(nor(false, false), true);
assertIs(nor(false)(false), true);
Parameters:
Name | Type | Description |
---|---|---|
a |
A | |
b |
B |
Returns:
- Type
- Boolean
(inner) not(a) → {Boolean}
The !
as a function
const { strictEqual: assertIs } = require('assert');
const { not } = require('ferrum');
assertIs(not(42), false);
assertIs(not(null), true);
Parameters:
Name | Type | Description |
---|---|---|
a |
A |
Returns:
- Type
- Boolean
(inner) or(a, b) → {A|B}
The ||
operator as a function
const { strictEqual: assertIs } = require('assert');
const { or } = require('ferrum');
assertIs(or(42, false), 42);
assertIs(or(false)(42), 42);
assertIs(or(5, true), 5);
assertIs(or(true)(5), 5);
Parameters:
Name | Type | Description |
---|---|---|
a |
A | |
b |
B |
Returns:
- Type
- A | B
(inner) plus(a, b) → {Number|String}
The +
operator as a function:
const { strictEqual: assertIs } = require('assert');
const { assertSequenceEquals, plus, list, map, pipe } = require('ferrum');
assertIs(plus(3, 4), 7);
assertIs(plus(3)(4), 7);
assertIs(plus(3, -4), -1); // Can also be used for subtraction
assertIs(plus(3)(-4), -1);
assertIs(plus("foo", "bar"), "foobar");
assertIs(plus("bar")("foo"), "foobar");
// Subtract one from each element in the list
assertSequenceEquals(
map([1, 2, 3, 4, 5], plus(-1)),
[0, 1, 2, 3, 4]);
NOTE: There is no subtract function, if you need subtraction just
negate the value to subtract with the operator please: const minus = (a, b) => plus(a, -b)
Parameters:
Name | Type | Description |
---|---|---|
a |
Number | String | |
b |
Number | String |
Returns:
- Type
- Number | String
(inner) xnor(a, b) → {Boolean}
XNOR as a function.
const { strictEqual: assertIs } = require('assert');
const { xnor } = require('ferrum');
assertIs(xnor(true, true), true);
assertIs(xnor(true)(true), true);
assertIs(xnor(false, false), true);
assertIs(xnor(false)(false), true);
assertIs(xnor(false, true), false);
assertIs(xnor(true)(false), false);
assertIs(xnor(true, false), false);
assertIs(xnor(false)(true), false);
Parameters:
Name | Type | Description |
---|---|---|
a |
A | |
b |
B |
Returns:
- Type
- Boolean
(inner) xor(a, b) → {Boolean}
XOR as a function.
const { strictEqual: assertIs } = require('assert');
const { xor } = require('ferrum');
assertIs(xor(true, true), false);
assertIs(xor(true)(true), false);
assertIs(xor(false, false), false);
assertIs(xor(false)(false), false);
assertIs(xor(false, true), true);
assertIs(xor(true)(false), true);
assertIs(xor(true, false), true);
assertIs(xor(false)(true), true);
Parameters:
Name | Type | Description |
---|---|---|
a |
A | |
b |
B |
Returns:
- Type
- Boolean