Innovenergy_trunk/frontend/node_modules/fp-ts/lib/Applicative.js

45 lines
1.8 KiB
JavaScript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getApplicativeComposition = exports.getApplicativeMonoid = void 0;
/**
* The `Applicative` type class extends the `Apply` type class with a `of` function, which can be used to create values
* of type `f a` from values of type `a`.
*
* Where `Apply` provides the ability to lift functions of two or more arguments to functions whose arguments are
* wrapped using `f`, and `Functor` provides the ability to lift functions of one argument, `pure` can be seen as the
* function which lifts functions of _zero_ arguments. That is, `Applicative` functors support a lifting operation for
* any number of function arguments.
*
* Instances must satisfy the following laws in addition to the `Apply` laws:
*
* 1. Identity: `A.ap(A.of(a => a), fa) <-> fa`
* 2. Homomorphism: `A.ap(A.of(ab), A.of(a)) <-> A.of(ab(a))`
* 3. Interchange: `A.ap(fab, A.of(a)) <-> A.ap(A.of(ab => ab(a)), fab)`
*
* Note. `Functor`'s `map` can be derived: `A.map(x, f) = A.ap(A.of(f), x)`
*
* @since 2.0.0
*/
var Apply_1 = require("./Apply");
var function_1 = require("./function");
var Functor_1 = require("./Functor");
function getApplicativeMonoid(F) {
var f = (0, Apply_1.getApplySemigroup)(F);
return function (M) { return ({
concat: f(M).concat,
empty: F.of(M.empty)
}); };
}
exports.getApplicativeMonoid = getApplicativeMonoid;
/** @deprecated */
function getApplicativeComposition(F, G) {
var map = (0, Functor_1.getFunctorComposition)(F, G).map;
var _ap = (0, Apply_1.ap)(F, G);
return {
map: map,
of: function (a) { return F.of(G.of(a)); },
ap: function (fgab, fga) { return (0, function_1.pipe)(fgab, _ap(fga)); }
};
}
exports.getApplicativeComposition = getApplicativeComposition;