monocle-ts-esm/es6/Iso.js

A porting of scala monocle library to TypeScript

import { flow, identity } from 'fp-ts-esm/function';
import { pipe } from 'fp-ts-esm/pipeable';
import * as _ from './internal.js';
// -------------------------------------------------------------------------------------
// constructors
// -------------------------------------------------------------------------------------
/**
 * @category constructors
 * @since 2.3.8
 */
export const iso = _.iso;
/**
 * @category constructors
 * @since 2.3.0
 */
export const id = () => iso(identity, identity);
// -------------------------------------------------------------------------------------
// converters
// -------------------------------------------------------------------------------------
/**
 * View an `Iso` as a `Lens`.
 *
 * @category converters
 * @since 2.3.0
 */
export const asLens = _.isoAsLens;
/**
 * View an `Iso` as a `Prism`.
 *
 * @category converters
 * @since 2.3.0
 */
export const asPrism = _.isoAsPrism;
/**
 * View an `Iso` as a `Optional`.
 *
 * @category converters
 * @since 2.3.0
 */
export const asOptional = _.isoAsOptional;
/**
 * View an `Iso` as a `Traversal`.
 *
 * @category converters
 * @since 2.3.0
 */
export const asTraversal = _.isoAsTraversal;
// -------------------------------------------------------------------------------------
// compositions
// -------------------------------------------------------------------------------------
/**
 * Compose an `Iso` with an `Iso`.
 *
 * @category compositions
 * @since 2.3.0
 */
export const compose = (ab) => (sa) => iso(flow(sa.get, ab.get), flow(ab.reverseGet, sa.reverseGet));
/**
 * Alias of `compose`.
 *
 * @category compositions
 * @since 2.3.8
 */
export const composeIso = compose;
/**
 * Compose an `Iso` with a `Lens`.
 *
 * @category compositions
 * @since 2.3.8
 */
export const composeLens = (ab) => flow(asLens, _.lensComposeLens(ab));
/**
 * Compose an `Iso` with a `Prism`.
 *
 * @category compositions
 * @since 2.3.8
 */
export const composePrism = (ab) => flow(asPrism, _.prismComposePrism(ab));
/**
 * Compose an `Iso` with a `Optional`.
 *
 * @category compositions
 * @since 2.3.8
 */
export const composeOptional = (ab) => flow(asOptional, _.optionalComposeOptional(ab));
/**
 * Compose an `Iso` with a `Traversal`.
 *
 * @category compositions
 * @since 2.3.8
 */
export const composeTraversal = (ab) => flow(asTraversal, _.traversalComposeTraversal(ab));
// -------------------------------------------------------------------------------------
// combinators
// -------------------------------------------------------------------------------------
/**
 * @category constructors
 * @since 2.3.0
 */
export const reverse = (sa) => iso(sa.reverseGet, sa.get);
/**
 * @category combinators
 * @since 2.3.0
 */
export const modify = (f) => (sa) => (s) => sa.reverseGet(f(sa.get(s)));
export function modifyF(F) {
    return (f) => (sa) => (s) => pipe(sa.get(s), f, (fa) => F.map(fa, sa.reverseGet));
}
/**
 * Return a `Prism` from a `Iso` focused on a nullable value.
 *
 * @category combinators
 * @since 2.3.8
 */
export const fromNullable = (sa) => composePrism(_.prismFromNullable())(sa);
export function filter(predicate) {
    return composePrism(_.prismFromPredicate(predicate));
}
/**
 * Return a `Lens` from a `Iso` and a prop.
 *
 * @category combinators
 * @since 2.3.8
 */
export const prop = (prop) => flow(asLens, _.lensProp(prop));
/**
 * Return a `Lens` from a `Iso` and a list of props.
 *
 * @category combinators
 * @since 2.3.8
 */
export const props = (...props) => flow(asLens, _.lensProps(...props));
/**
 * Return a `Lens` from a `Iso` focused on a component of a tuple.
 *
 * @category combinators
 * @since 2.3.8
 */
export const component = (prop) => flow(asLens, _.lensComponent(prop));
/**
 * Return a `Optional` from a `Iso` focused on an index of a `ReadonlyArray`.
 *
 * @category combinators
 * @since 2.3.8
 */
export const index = (i) => flow(asOptional, _.optionalIndex(i));
/**
 * Return a `Optional` from a `Iso` focused on an index of a `ReadonlyNonEmptyArray`.
 *
 * @category combinators
 * @since 2.3.8
 */
export const indexNonEmpty = (i) => flow(asOptional, _.optionalIndexNonEmpty(i));
/**
 * Return a `Optional` from a `Iso` focused on a key of a `ReadonlyRecord`.
 *
 * @category combinators
 * @since 2.3.8
 */
export const key = (key) => flow(asOptional, _.optionalKey(key));
/**
 * Return a `Lens` from a `Iso` focused on a required key of a `ReadonlyRecord`.
 *
 * @category combinators
 * @since 2.3.8
 */
export const atKey = (key) => flow(asLens, _.lensAtKey(key));
/**
 * Return a `Prism` from a `Iso` focused on the `Some` of a `Option` type.
 *
 * @category combinators
 * @since 2.3.8
 */
export const some = 
/*#__PURE__*/
composePrism(/*#__PURE__*/ _.prismSome());
/**
 * Return a `Prism` from a `Iso` focused on the `Right` of a `Either` type.
 *
 * @category combinators
 * @since 2.3.8
 */
export const right = 
/*#__PURE__*/
composePrism(/*#__PURE__*/ _.prismRight());
/**
 * Return a `Prism` from a `Iso` focused on the `Left` of a `Either` type.
 *
 * @category combinators
 * @since 2.3.8
 */
export const left = 
/*#__PURE__*/
composePrism(/*#__PURE__*/ _.prismLeft());
/**
 * Return a `Traversal` from a `Iso` focused on a `Traversable`.
 *
 * @category combinators
 * @since 2.3.8
 */
export function traverse(T) {
    return flow(asTraversal, _.traversalTraverse(T));
}
export function findFirst(predicate) {
    return composeOptional(_.optionalFindFirst(predicate));
}
export function findFirstNonEmpty(predicate) {
    return composeOptional(_.optionalFindFirstNonEmpty(predicate));
}
// -------------------------------------------------------------------------------------
// pipeables
// -------------------------------------------------------------------------------------
/**
 * @category Invariant
 * @since 2.3.0
 */
export const imap = (f, g) => (ea) => imap_(ea, f, g);
// -------------------------------------------------------------------------------------
// instances
// -------------------------------------------------------------------------------------
const imap_ = (ea, ab, ba) => iso(flow(ea.get, ab), flow(ba, ea.reverseGet));
/**
 * @category instances
 * @since 2.3.0
 */
export const URI = 'monocle-ts/Iso';
/**
 * @category instances
 * @since 2.3.0
 */
export const Invariant = {
    URI,
    imap: imap_
};
/**
 * @category instances
 * @since 2.3.8
 */
export const Semigroupoid = {
    URI,
    compose: (ab, ea) => compose(ab)(ea)
};
/**
 * @category instances
 * @since 2.3.0
 */
export const Category = {
    URI,
    compose: Semigroupoid.compose,
    id
};