init component
This commit is contained in:
Robin COuret
223
node_modules/fp-ts/lib/Eq.js
generated
vendored
Normal file
223
node_modules/fp-ts/lib/Eq.js
generated
vendored
Normal file
@@ -0,0 +1,223 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.eqDate = exports.eqNumber = exports.eqString = exports.eqBoolean = exports.eq = exports.strictEqual = exports.getStructEq = exports.getTupleEq = exports.Contravariant = exports.getMonoid = exports.getSemigroup = exports.eqStrict = exports.URI = exports.contramap = exports.tuple = exports.struct = exports.fromEquals = void 0;
|
||||
var function_1 = require("./function");
|
||||
// -------------------------------------------------------------------------------------
|
||||
// constructors
|
||||
// -------------------------------------------------------------------------------------
|
||||
/**
|
||||
* @category constructors
|
||||
* @since 2.0.0
|
||||
*/
|
||||
var fromEquals = function (equals) { return ({
|
||||
equals: function (x, y) { return x === y || equals(x, y); }
|
||||
}); };
|
||||
exports.fromEquals = fromEquals;
|
||||
// -------------------------------------------------------------------------------------
|
||||
// combinators
|
||||
// -------------------------------------------------------------------------------------
|
||||
/**
|
||||
* @since 2.10.0
|
||||
*/
|
||||
var struct = function (eqs) {
|
||||
return (0, exports.fromEquals)(function (first, second) {
|
||||
for (var key in eqs) {
|
||||
if (!eqs[key].equals(first[key], second[key])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
});
|
||||
};
|
||||
exports.struct = struct;
|
||||
/**
|
||||
* Given a tuple of `Eq`s returns a `Eq` for the tuple
|
||||
*
|
||||
* @example
|
||||
* import { tuple } from 'fp-ts/Eq'
|
||||
* import * as S from 'fp-ts/string'
|
||||
* import * as N from 'fp-ts/number'
|
||||
* import * as B from 'fp-ts/boolean'
|
||||
*
|
||||
* const E = tuple(S.Eq, N.Eq, B.Eq)
|
||||
* assert.strictEqual(E.equals(['a', 1, true], ['a', 1, true]), true)
|
||||
* assert.strictEqual(E.equals(['a', 1, true], ['b', 1, true]), false)
|
||||
* assert.strictEqual(E.equals(['a', 1, true], ['a', 2, true]), false)
|
||||
* assert.strictEqual(E.equals(['a', 1, true], ['a', 1, false]), false)
|
||||
*
|
||||
* @since 2.10.0
|
||||
*/
|
||||
var tuple = function () {
|
||||
var eqs = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
eqs[_i] = arguments[_i];
|
||||
}
|
||||
return (0, exports.fromEquals)(function (first, second) { return eqs.every(function (E, i) { return E.equals(first[i], second[i]); }); });
|
||||
};
|
||||
exports.tuple = tuple;
|
||||
/* istanbul ignore next */
|
||||
var contramap_ = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.contramap)(f)); };
|
||||
/**
|
||||
* A typical use case for `contramap` would be like, given some `User` type, to construct an `Eq<User>`.
|
||||
*
|
||||
* We can do so with a function from `User -> X` where `X` is some value that we know how to compare
|
||||
* for equality (meaning we have an `Eq<X>`)
|
||||
*
|
||||
* For example, given the following `User` type, we want to construct an `Eq<User>` that just looks at the `key` field
|
||||
* for each user (since it's known to be unique).
|
||||
*
|
||||
* If we have a way of comparing `UUID`s for equality (`eqUUID: Eq<UUID>`) and we know how to go from `User -> UUID`,
|
||||
* using `contramap` we can do this
|
||||
*
|
||||
* @example
|
||||
* import { contramap, Eq } from 'fp-ts/Eq'
|
||||
* import { pipe } from 'fp-ts/function'
|
||||
* import * as S from 'fp-ts/string'
|
||||
*
|
||||
* type UUID = string
|
||||
*
|
||||
* interface User {
|
||||
* readonly key: UUID
|
||||
* readonly firstName: string
|
||||
* readonly lastName: string
|
||||
* }
|
||||
*
|
||||
* const eqUUID: Eq<UUID> = S.Eq
|
||||
*
|
||||
* const eqUserByKey: Eq<User> = pipe(
|
||||
* eqUUID,
|
||||
* contramap((user) => user.key)
|
||||
* )
|
||||
*
|
||||
* assert.deepStrictEqual(
|
||||
* eqUserByKey.equals(
|
||||
* { key: 'k1', firstName: 'a1', lastName: 'b1' },
|
||||
* { key: 'k2', firstName: 'a1', lastName: 'b1' }
|
||||
* ),
|
||||
* false
|
||||
* )
|
||||
* assert.deepStrictEqual(
|
||||
* eqUserByKey.equals(
|
||||
* { key: 'k1', firstName: 'a1', lastName: 'b1' },
|
||||
* { key: 'k1', firstName: 'a2', lastName: 'b1' }
|
||||
* ),
|
||||
* true
|
||||
* )
|
||||
*
|
||||
* @since 2.0.0
|
||||
*/
|
||||
var contramap = function (f) { return function (fa) {
|
||||
return (0, exports.fromEquals)(function (x, y) { return fa.equals(f(x), f(y)); });
|
||||
}; };
|
||||
exports.contramap = contramap;
|
||||
/**
|
||||
* @category type lambdas
|
||||
* @since 2.0.0
|
||||
*/
|
||||
exports.URI = 'Eq';
|
||||
/**
|
||||
* @category instances
|
||||
* @since 2.5.0
|
||||
*/
|
||||
exports.eqStrict = {
|
||||
equals: function (a, b) { return a === b; }
|
||||
};
|
||||
var empty = {
|
||||
equals: function () { return true; }
|
||||
};
|
||||
/**
|
||||
* @category instances
|
||||
* @since 2.10.0
|
||||
*/
|
||||
var getSemigroup = function () { return ({
|
||||
concat: function (x, y) { return (0, exports.fromEquals)(function (a, b) { return x.equals(a, b) && y.equals(a, b); }); }
|
||||
}); };
|
||||
exports.getSemigroup = getSemigroup;
|
||||
/**
|
||||
* @category instances
|
||||
* @since 2.6.0
|
||||
*/
|
||||
var getMonoid = function () { return ({
|
||||
concat: (0, exports.getSemigroup)().concat,
|
||||
empty: empty
|
||||
}); };
|
||||
exports.getMonoid = getMonoid;
|
||||
/**
|
||||
* @category instances
|
||||
* @since 2.7.0
|
||||
*/
|
||||
exports.Contravariant = {
|
||||
URI: exports.URI,
|
||||
contramap: contramap_
|
||||
};
|
||||
// -------------------------------------------------------------------------------------
|
||||
// deprecated
|
||||
// -------------------------------------------------------------------------------------
|
||||
/**
|
||||
* Use [`tuple`](#tuple) instead.
|
||||
*
|
||||
* @category zone of death
|
||||
* @since 2.0.0
|
||||
* @deprecated
|
||||
*/
|
||||
exports.getTupleEq = exports.tuple;
|
||||
/**
|
||||
* Use [`struct`](#struct) instead.
|
||||
*
|
||||
* @category zone of death
|
||||
* @since 2.0.0
|
||||
* @deprecated
|
||||
*/
|
||||
exports.getStructEq = exports.struct;
|
||||
/**
|
||||
* Use [`eqStrict`](#eqstrict) instead
|
||||
*
|
||||
* @category zone of death
|
||||
* @since 2.0.0
|
||||
* @deprecated
|
||||
*/
|
||||
exports.strictEqual = exports.eqStrict.equals;
|
||||
/**
|
||||
* This instance is deprecated, use small, specific instances instead.
|
||||
* For example if a function needs a `Contravariant` instance, pass `E.Contravariant` instead of `E.eq`
|
||||
* (where `E` is from `import E from 'fp-ts/Eq'`)
|
||||
*
|
||||
* @category zone of death
|
||||
* @since 2.0.0
|
||||
* @deprecated
|
||||
*/
|
||||
exports.eq = exports.Contravariant;
|
||||
/**
|
||||
* Use [`Eq`](./boolean.ts.html#eq) instead.
|
||||
*
|
||||
* @category zone of death
|
||||
* @since 2.0.0
|
||||
* @deprecated
|
||||
*/
|
||||
exports.eqBoolean = exports.eqStrict;
|
||||
/**
|
||||
* Use [`Eq`](./string.ts.html#eq) instead.
|
||||
*
|
||||
* @category zone of death
|
||||
* @since 2.0.0
|
||||
* @deprecated
|
||||
*/
|
||||
exports.eqString = exports.eqStrict;
|
||||
/**
|
||||
* Use [`Eq`](./number.ts.html#eq) instead.
|
||||
*
|
||||
* @category zone of death
|
||||
* @since 2.0.0
|
||||
* @deprecated
|
||||
*/
|
||||
exports.eqNumber = exports.eqStrict;
|
||||
/**
|
||||
* Use [`Eq`](./Date.ts.html#eq) instead.
|
||||
*
|
||||
* @category zone of death
|
||||
* @since 2.0.0
|
||||
* @deprecated
|
||||
*/
|
||||
exports.eqDate = {
|
||||
equals: function (first, second) { return first.valueOf() === second.valueOf(); }
|
||||
};
|
||||
Reference in New Issue
Block a user