Exploring the depths of nested data retrieval using the fp-ts library: a labyrinth

Question

Exploring the depths of nested data retrieval using the fp-ts library: a labyrinth

Embark on your journey into the world of functional programming in typescript using the fp-ts library.

I find myself tangled in a complex web of nested data fetching, reminiscent of the ancient Egyptian pyramids. How can I tackle this problem with a more streamlined and less imperative approach?

The Challenge

export const getProgramWithAllElements = (programId: FirestoreDocumentId): TE.TaskEither<FirestoreError, Program> =>
  pipe(
    getProgram(programId),
    TE.chain((program) =>
      pipe(
        getCollCollectionsFromPath(program.id),
        TE.chain((collections) =>
          pipe(
            collections,
            A.map((collection) =>
              pipe(
                getWeekCollectionsFromPath(program.id)(collection.id),
                TE.chain((weeks) =>
                  pipe(
                    weeks,
                    A.map((week) =>
                      pipe(
                        getDayCollectionsFromPath(program.id)(collection.id)(week.id),
                        TE.chain((days) =>
                          pipe(
                            days,
                            A.map((day) =>
                              pipe(
                                getExerciseCollectionsFromPath(program.id)(collection.id)(week.id)(day.id),
                                TE.map(
                                  (exercises) =>
                                    ({
                                      ...day,
                                      exercises: exercises,
                                    } as Day)
                                )
                              )
                            ),
                            A.sequence(TE.taskEither)
                          )
                        ),
                        TE.map(
                          (days) =>
                            ({
                              ...week,
                              days: days,
                            } as Week)
                        )
                      )
                    ),
                    A.sequence(TE.taskEither)
                  )
                ),
                TE.map(
                  (weeks) =>
                    ({
                      ...collection,
                      weeks: weeks,
                    } as Collection)
                )
              )
            ),
            A.sequence(TE.taskEither)
          )
        ),
        TE.map(
          (collections) =>
            ({
              ...program,
              collections: collections,
            } as Program)
        )
      )
    )
  );

Methods utilized in script

declare const getProgram: (programId: FirestoreDocumentId) => TE.TaskEither<FirestoreError, Program>;

declare const getCollCollectionsFromPath: (
  programId: FirestoreDocumentId
) => TE.TaskEither<FirestoreError, Collection[]>;

declare const getWeekCollectionsFromPath: (
  programId: FirestoreDocumentId
) => (collectionId: FirestoreDocumentId) => TE.TaskEither<FirestoreError, Week[]>;

declare const getDayCollectionsFromPath: (programId: FirestoreDocumentId) => (collectionId: FirestoreDocumentId) => (
  weekId: FirestoreDocumentId
) => TE.TaskEither<FirestoreError, Day[]>;

declare const getExerciseCollectionsFromPath: (programId: FirestoreDocumentId) => (collectionId: FirestoreDocumentId) => (
  weekId: FirestoreDocumentId
) => (dayId: FirestoreDocumentId) => TE.TaskEither<FirestoreError, Exercise[]>;

Refined Data Structure

export interface Program {
    id: string;
    // Other Fields
    collections?: Collection[];
}

export interface Collection {
    id: string;
    // Other Fields
    weeks?: Week[];
}

export interface Week {
    id: string;
    // Other Fields
    days?: Day[];
}

export interface Day {
    id: string;
    // Other Fields
    exercises: ProgramExercise[];
}

export interface ProgramExercise {
    id: string;
    // Other Fields
}

typescript functional-programming fp-ts

Answer 1

Answer №1

While I'm not familiar with FP-TS, I can offer a broad response that highlights the consistent algebraic principles at play.

To begin, monads naturally create nested structures. Although this is unavoidable, you can conceal it if equipped with the appropriate tool (such as the `do` notation in Haskell). Regrettably, in Javascript, evading nesting altogether isn't feasible generally; however, by using generators, you can sustain a flat structure for deterministic computations. The code provided below relies on the scriptum lib, which I curate:

const record = (type, o) => (
  o[Symbol.toStringTag] = type.name || type, o);

const Cont = k => record(Cont, {cont: k});

const contOf = x => Cont(k => k(x));

const contChain = mx => fm =>
  Cont(k =>
    mx.cont(x =>
      fm(x).cont(k)));

const _do = ({chain, of}) => init => gtor => {
  const go = ({done, value: x}) =>
    done
      ? of(x)
      : chain(x) (y => go(it.next(y)));

  const it = gtor(init);
  return go(it.next());
};

const log = (...ss) =>
  (console.log(...ss), ss[ss.length - 1]);

const inck = x => Cont(k => k(x + 1));

const sqrk = x => Cont(k =>
  Promise.resolve(null)
    .then(k(x * x)));

const mainM = _do({chain: contChain, of: contOf}) (5) (function* (init) {
  const x = yield inck(init),
    y = yield sqrk(init);

  return [x, y];
});

mainM.cont(log)

However, based on your code snippet, it appears that you may not necessarily require a monad since subsequent computations do not rely on previous values, akin to

chain(tx) (x => x === 0 ? of(x) : of(2/x)

. An Applicative functor should suffice:

const record = (type, o) => (
  o[Symbol.toStringTag] = type.name || type, o);

const Cont = k => record(Cont, {cont: k});

const contMap = f => tx =>
  Cont(k => tx.cont(x => k(f(x))));

const contAp = tf => tx =>
  Cont(k =>
    tf.cont(f =>
      tx.cont(x =>
        k(f(x)))));

const contOf = x => Cont(k => k(x));

const liftA2 = ({map, ap}) => f => tx => ty =>
  ap(map(f) (tx)) (ty);

const contLiftA2 = liftA2({map: contMap, ap: contAp});

const log = (...ss) =>
  (console.log(...ss), ss[ss.length - 1]);

const inck = x => Cont(k => k(x + 1));

const sqrk = x => Cont(k =>
  Promise.resolve(null)
    .then(k(x * x)));

const mainA = contLiftA2(x => y => [x, y]) (inck(5)) (sqrk(5))

mainA.cont(log);

It's essential to note that incorporating generators with non-deterministic computations like linked lists or arrays poses a challenge. Nonetheless, leveraging monads applicatively can alleviate the complication:

const arrChain = mx => fm =>
  mx.flatMap(fm);

const chain2 = chain => mx => my => fm =>
  chain(chain(mx) (x => fm(x)))
    (gm => chain(my) (y => gm(y)));

const log = (...ss) =>
  (console.log(...ss), ss[ss.length - 1]);

const xs = [1,2],
  ys = [3,4];

main3 = chain2(arrChain) (xs) (ys) (x => [y => [x, y]]);

log(main3);

Although a nested structure remains evident, the overall presentation looks more organized and clean.

I cannot be entirely certain if this method is universally applicable to all monads, as it executes effects twice as frequently as usual. Thus far, no issues have emerged, instilling confidence in its effectiveness.

Answer 2

While I'm not familiar with FP-TS, I can offer a broad response that highlights the consistent algebraic principles at play.

To begin, monads naturally create nested structures. Although this is unavoidable, you can conceal it if equipped with the appropriate tool (such as the `do` notation in Haskell). Regrettably, in Javascript, evading nesting altogether isn't feasible generally; however, by using generators, you can sustain a flat structure for deterministic computations. The code provided below relies on the scriptum lib, which I curate:

const record = (type, o) => (
  o[Symbol.toStringTag] = type.name || type, o);

const Cont = k => record(Cont, {cont: k});

const contOf = x => Cont(k => k(x));

const contChain = mx => fm =>
  Cont(k =>
    mx.cont(x =>
      fm(x).cont(k)));

const _do = ({chain, of}) => init => gtor => {
  const go = ({done, value: x}) =>
    done
      ? of(x)
      : chain(x) (y => go(it.next(y)));

  const it = gtor(init);
  return go(it.next());
};

const log = (...ss) =>
  (console.log(...ss), ss[ss.length - 1]);

const inck = x => Cont(k => k(x + 1));

const sqrk = x => Cont(k =>
  Promise.resolve(null)
    .then(k(x * x)));

const mainM = _do({chain: contChain, of: contOf}) (5) (function* (init) {
  const x = yield inck(init),
    y = yield sqrk(init);

  return [x, y];
});

mainM.cont(log)

However, based on your code snippet, it appears that you may not necessarily require a monad since subsequent computations do not rely on previous values, akin to

chain(tx) (x => x === 0 ? of(x) : of(2/x)

. An Applicative functor should suffice:

const record = (type, o) => (
  o[Symbol.toStringTag] = type.name || type, o);

const Cont = k => record(Cont, {cont: k});

const contMap = f => tx =>
  Cont(k => tx.cont(x => k(f(x))));

const contAp = tf => tx =>
  Cont(k =>
    tf.cont(f =>
      tx.cont(x =>
        k(f(x)))));

const contOf = x => Cont(k => k(x));

const liftA2 = ({map, ap}) => f => tx => ty =>
  ap(map(f) (tx)) (ty);

const contLiftA2 = liftA2({map: contMap, ap: contAp});

const log = (...ss) =>
  (console.log(...ss), ss[ss.length - 1]);

const inck = x => Cont(k => k(x + 1));

const sqrk = x => Cont(k =>
  Promise.resolve(null)
    .then(k(x * x)));

const mainA = contLiftA2(x => y => [x, y]) (inck(5)) (sqrk(5))

mainA.cont(log);

It's essential to note that incorporating generators with non-deterministic computations like linked lists or arrays poses a challenge. Nonetheless, leveraging monads applicatively can alleviate the complication:

const arrChain = mx => fm =>
  mx.flatMap(fm);

const chain2 = chain => mx => my => fm =>
  chain(chain(mx) (x => fm(x)))
    (gm => chain(my) (y => gm(y)));

const log = (...ss) =>
  (console.log(...ss), ss[ss.length - 1]);

const xs = [1,2],
  ys = [3,4];

main3 = chain2(arrChain) (xs) (ys) (x => [y => [x, y]]);

log(main3);

Although a nested structure remains evident, the overall presentation looks more organized and clean.

I cannot be entirely certain if this method is universally applicable to all monads, as it executes effects twice as frequently as usual. Thus far, no issues have emerged, instilling confidence in its effectiveness.

Answer 3

Answer №2

Attempting to abstract and simplify repetitive patterns:

import * as B from "fp-ts/Array";
import { compose, pipe } from "fp-ts/lib/function";

type DocumentId = number;
interface Collection {
  id: number;
}
interface Error {
  id: number;
}
interface Day {
  id: number;
}
interface Week {
  id: number;
}
interface Program {
  id: number;
}
interface Exercise {
  id: number;
}

declare const fetchProgram: (
  programId: DocumentId
) => TE.TaskEither<Error, Program>;

declare const fetchCollectionsAtPath: (
  programId: DocumentId
) => TE.TaskEither<Error, Collection[]>;

declare const fetchWeeksAtPath: (
  programId: DocumentId
) => (
  collectionId: DocumentId
) => TE.TaskEither<Error, Week[]>;

declare const fetchDaysAtPath: (
  programId: DocumentId
) => (
  collectionId: DocumentId
) => (weekId: DocumentId) => TE.TaskEither<Error, Day[]>;

declare const fetchExercisesAtPath: (
  programId: DocumentId
) => (
  collectionId: DocumentId
) => (
  weekId: DocumentId
) => (dayId: DocumentId) => TE.TaskEither<Error, Exercise[]>;

const assignTo = <K extends string>(prop: K) => <T>(obj: T) => <E, A>(
  task: TE.TaskEither<E, A>
) =>
  pipe(
    task,
    TE.map(
      (data): T & { [P in K]: A } =>
        Object.assign({}, obj, { [prop]: data }) as any
    )
  );

const sequenceChained = <E, A, B>(f: (t: A) => TE.TaskEither<E, B>) =>
  TE.chain(compose(B.map(f), B.sequence(TE.taskEither)));

const chainSequenceAndAssignTo = <K extends string>(prop: K) => <E, B>(
  f: (id: number) => TE.TaskEither<E, B[]>
) => <A extends { id: number }>(
  task: TE.TaskEither<E, A[]>
) =>
  pipe(
    task,
    sequenceChained((a) => pipe(f(a.id), assignTo(prop)(a)))
  );

export const fetchProgramWithElements = (programId: DocumentId) =>
  pipe(
    fetchProgram(programId),
    TE.chain((program) =>
      pipe(
        fetchCollectionsAtPath(program.id),
        chainSequenceAndAssignTo("collections")((collectionId) =>
          pipe(
            fetchWeeksAtPath(program.id)(collectionId),
            chainSequenceAndAssignTo("weeks")((weekId) =>
              pipe(
                fetchDaysAtPath(program.id)(collectionId)(weekId),
                chainSequenceAndAssignTo("exercises")(
                  fetchExercisesAtPath(program.id)(collectionId)(
                    weekId
                  )
                )
              )
            )
          )
        )
      )
    )
  );

Answer 4

Attempting to abstract and simplify repetitive patterns:

import * as B from "fp-ts/Array";
import { compose, pipe } from "fp-ts/lib/function";

type DocumentId = number;
interface Collection {
  id: number;
}
interface Error {
  id: number;
}
interface Day {
  id: number;
}
interface Week {
  id: number;
}
interface Program {
  id: number;
}
interface Exercise {
  id: number;
}

declare const fetchProgram: (
  programId: DocumentId
) => TE.TaskEither<Error, Program>;

declare const fetchCollectionsAtPath: (
  programId: DocumentId
) => TE.TaskEither<Error, Collection[]>;

declare const fetchWeeksAtPath: (
  programId: DocumentId
) => (
  collectionId: DocumentId
) => TE.TaskEither<Error, Week[]>;

declare const fetchDaysAtPath: (
  programId: DocumentId
) => (
  collectionId: DocumentId
) => (weekId: DocumentId) => TE.TaskEither<Error, Day[]>;

declare const fetchExercisesAtPath: (
  programId: DocumentId
) => (
  collectionId: DocumentId
) => (
  weekId: DocumentId
) => (dayId: DocumentId) => TE.TaskEither<Error, Exercise[]>;

const assignTo = <K extends string>(prop: K) => <T>(obj: T) => <E, A>(
  task: TE.TaskEither<E, A>
) =>
  pipe(
    task,
    TE.map(
      (data): T & { [P in K]: A } =>
        Object.assign({}, obj, { [prop]: data }) as any
    )
  );

const sequenceChained = <E, A, B>(f: (t: A) => TE.TaskEither<E, B>) =>
  TE.chain(compose(B.map(f), B.sequence(TE.taskEither)));

const chainSequenceAndAssignTo = <K extends string>(prop: K) => <E, B>(
  f: (id: number) => TE.TaskEither<E, B[]>
) => <A extends { id: number }>(
  task: TE.TaskEither<E, A[]>
) =>
  pipe(
    task,
    sequenceChained((a) => pipe(f(a.id), assignTo(prop)(a)))
  );

export const fetchProgramWithElements = (programId: DocumentId) =>
  pipe(
    fetchProgram(programId),
    TE.chain((program) =>
      pipe(
        fetchCollectionsAtPath(program.id),
        chainSequenceAndAssignTo("collections")((collectionId) =>
          pipe(
            fetchWeeksAtPath(program.id)(collectionId),
            chainSequenceAndAssignTo("weeks")((weekId) =>
              pipe(
                fetchDaysAtPath(program.id)(collectionId)(weekId),
                chainSequenceAndAssignTo("exercises")(
                  fetchExercisesAtPath(program.id)(collectionId)(
                    weekId
                  )
                )
              )
            )
          )
        )
      )
    )
  );

Exploring the depths of nested data retrieval using the fp-ts library: a labyrinth

Answer №1

Answer №2

Similar questions

Angular 2: Dynamically Adjusting View Components Based on URL Path

All-encompassing NextJS App router with a focus on Internationalization

The data in the Angular variable is not persisting

What could be causing the "Failed to compile" error to occur following the execution of npm

Utilizing ngModel within a nested ngFor loop in Angular to capture changing values dynamically

"Exploring the world of 3rd party libraries in Angular2 with Typescript and Webpack

Errors related to reducer types in createSlice of Redux Toolkit

Querying data conditionally with Angular rxjs

Transforming a detailed JSON structure into a more simplified format with Angular 2

What is the best way to create TypeScript declarations for both commonjs modules and global variables?

Trouble with Excel Office Script setInterval functionality

Troubleshooting Puppeteer compatibility issues when using TypeScript and esModuleInterop

Unsynchronized state of affairs in the context of Angular navigation

Differences between Typescript Import and JavaScript import

When utilizing Jest, the issue arises that `uuid` is not recognized as

Expanding a TypeScript type by creating an alias for a property

Error encountered in Snap SVG combined with Typescript and Webpack: "Encountered the error 'Cannot read property 'on' of undefined'"

Initial 16 characters of the deciphered message are nonsensical

How can I integrate keydown.control with a unique click function in Angular?

Guide on accessing device details with Angular2 and Typescript