Post 2.0 Algebraic Data Types and Features

[baetheus]

I'd like to start thinking about useful ADTs and utils to land in fun after the 2.0 release stuff is done. Following is an initial list of the ones I know I'd like to have:

• - ReaderTaskEither (@pixeleet)
• - StateReaderTaskEither (@pixeleet)
• - Algebraic Graph
• - Date
• - Promise (Implemented)
• - Parser
• - Profunctor optics? (Implemented as Arrow Optics)
• - ReadableStream/WriteableStream?
• - Observable (implemented in the style of most-js, since observable taps out at ~300 iters/second)

[baetheus]

I've been thinking about adding a somewhat generic Error type to fun, it's primary use is to wrap code from outside of fun that might throw in or out of a promise. Currently, tryCatch in Option, Either, and TaskEither are very useful for wrapping these types. However, I find myself often doing the following for each function brought in from an external library:

import * as TE from "./task_either.ts";

export type FetchError = {
  tag: "FetchError",
  args: Parameters<typeof Fetch>,
  error: unknown,
};

export const fetchError = (error: unknown, args: Parameters<typeof Fetch>): FetchError => ({
  tag: "FetchError",
  args,
  error,
});

export const safeFetch = TE.tryCatch(fetch, fetchError);

One or two of these isn't a big issue for me, but as I use more external code it starts to feel very boilerplatey. This morning I was mucking around with rss parsing (because I will probably land an rss aggregator/reader at some point) and tried out this TaggedError pattern. It's inspired a bit by the anyhow crate that is popular in rust.

This simple implementation adds a type level string for tag and an arguments context (a little more specific than an anyhow context). If made into an ADT we could wrap it in Free to add more options for context.

[pixeleet]

@baetheus I'm planning to pick up work the coming weeks for RE/RTE, have you touched Either/Reader yet for 2.0?

[baetheus]

I'm doing a bit of work there in https://github.com/baetheus/fun/tree/feat/kind-variance which is turning into another big PR. I probably should have broken up the work, but it's a bit late for that now. Anyway, the exports for those should be pretty solid. If you find something missing let me know.

[pixeleet]

Will give it a look in the evening, thanks!

[baetheus]

Instead of implementing our own observable I'm going to make a compatibility layer over mostjs core via esm.sh. It'll live in contrib/stream.ts and create standard exports over https://esm.sh/@most/[email protected] and https://esm.sh/@most/[email protected]. This is probably a small project, perhaps a day at most.

[baetheus]

Also, I've been working on a prototype http router lib called pick and have been poking at an ADT that is a bit like a mashup of State, Async, and Reader, but not in the standard ReaderStateAsync format, more like (s: S) => Promise<[A, S]>. Although, I did read about something called IndexedStateT from Cats in Scala recently which is an Indexed State monad transformer. It might also be interesting.

Unfortunately, the limitations of the higher kinded type implementation in typescript make it impossible to use the existing type class definitions for indexed monads. This means extra definitions for IxFlatmappable, IxMappable, etc etc etc. It also adds to the complexity of the pick library, which should certainly be kept as simple as possible.