tom-weatherhead/thaw-grammar

File operators.ts has 281 lines of code (exceeds 250 allowed). Consider refactoring.

Open

// tom-weatherhead/thaw-grammar/src/languages/lambda-calculus/operators.ts

import { ifDefinedThenElse } from 'thaw-common-utilities.ts';

import { ILCExpression } from './domain-object-model/interfaces/expression';

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function lcaHeadUsage(
    ll: ILCExpression,
    options: { h?: string; t?: string } = {}
): ILCExpression {
    const h = v(options.h, 'h');

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function lcaTailUsage(
    ll: ILCExpression,
    options: { h?: string; t?: string } = {}
): ILCExpression {
    const h = v(options.h, 'h');

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createFunctionCreatePair(
    options: { f?: string; a?: string; b?: string } = {}
): ILCExpression {
    const a = v(options.a, 'a');
    const b = v(options.b, 'b');

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function lcaCons(options: { h?: string; t?: string; f?: string } = {}): ILCExpression {
    const h = v(options.h, 'h');
    const t = v(options.t, 't');

    return l(h, l(t, lcaConsUsage(h, t, options)));

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createOperatorAnd(options: { p?: string; q?: string } = {}): ILCExpression {
    // && (and) : λp.λq.((p q) FALSE)
    const p = v(options.p, 'p');
    const q = v(options.q, 'q');

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createOperatorOr(options: { p?: string; q?: string } = {}): ILCExpression {
    // || (or) : λp.λq.(((IF p) TRUE) q)
    const p = v(options.p, 'p');
    const q = v(options.q, 'q');

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createValueFalse(options: { x?: string; y?: string } = {}): ILCExpression {
    const x = v(options.x, 'x');
    const y = v(options.y, 'y');

    return l(x, l(y, y));

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createValueTrue(options: { x?: string; y?: string } = {}): ILCExpression {
    const x = v(options.x, 'x');
    const y = v(options.y, 'y');

    return l(x, l(y, x));

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function lcaConsUsage(
    h: ILCExpression,
    t: ILCExpression,
    options: { f?: string } = {}
): ILCExpression {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createPairUsage(
    first: ILCExpression,
    second: ILCExpression,
    options: { f?: string } = {}
): ILCExpression {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createOperatorDecrement(
    options: { n?: string; f?: string; x?: string } = {}
): ILCExpression {
    // -- (predecessor) : λn.λf.λx.(((n λg.λh.(h (g f))) λu.x) λu.u)
    const n = v(options.n, 'n');

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createOperatorIncrement(
    options: { n?: string; f?: string; x?: string } = {}
): ILCExpression {
    // ++ (successor) : λn.λf.λx.(f ((n f) x))
    const n = v(options.n, 'n');

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function lcaTail(options: { l?: string; h?: string; t?: string } = {}): ILCExpression {
    const ll = v(options.l, 'l');

    return l(ll, lcaTailUsage(ll, options));
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function lcaHead(options: { l?: string; h?: string; t?: string } = {}): ILCExpression {
    const ll = v(options.l, 'l');

    return l(ll, lcaHeadUsage(ll, options));
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createOperatorMultiply(
    options: { m?: string; n?: string; f?: string } = {}
): ILCExpression {
    // * : λm.λn.λf.(m (n f))
    const m = v(options.m, 'm');

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createOperatorAdd(
    options: { m?: string; n?: string; f?: string; x?: string } = {}
): ILCExpression {
    // + : λm.λn.λf.λx.((n f) ((m f) x))
    const m = v(options.m, 'm');

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createStatementLetUsage(
    vv: LCVariable,
    e1: ILCExpression,
    e2: ILCExpression
): ILCExpression {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createOperatorIfUsage(
    condition: ILCExpression,
    thenPart: ILCExpression,
    elsePart: ILCExpression
): ILCExpression {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createFunctionGetFirstOfPair(
    options: { x?: string; y?: string } = {}
): ILCExpression {
    return createValueTrue(options);
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function createFunctionGetSecondOfPair(
    options: { x?: string; y?: string } = {}
): ILCExpression {
    return createValueFalse(options);
}

• Read up
  Read up