The following notes come from an internal discussion I had with some coworkers with no pretension to be an accurate explanation of the Reader monad. Still, my teammates claimed they were helpful to understand the concept; so better put them online.
We'll start with a function whose job is to insert an user in a database:
type User = { username: string; age: number; }; declare function createUser( user: string, details: unknown ): Promise<User>; Let's write some code to implement the function:
type User = { username: string; age: number; }; declare function userExists(user: string): Promise<boolean>; declare function createUserAccount( user: string ): Promise<boolean>; declare function runAutomaticTrigger( user: string ): Promise<boolean>; async function insertInDb(user: User): Promise<boolean> { const db = []; db.push(user); return runAutomaticTrigger(user.username); } async function createUser(details: User): Promise<User> { const isPresent = await userExists(details.username); if (isPresent) { const inserted = await insertInDb(details); if (inserted) { const accountCreated = await createUserAccount( details.username ); if (accountCreated) return details; else throw new Error("unable to create user account"); } else throw new Error("unable to insert user in Db"); } else { throw new Error("user already exists"); } } Now let's say that somebody comes says we need to add logging with this object.
type Logger = { info: (msg: string) => undefined, debug: (msg: string) => undefined, warn: (msg: string) => undefined, error: (msg: string) => undefined, }; Additionally, let's put the constraint in place that the logger is not a singleton instance — thus it's an instance that needs to be carried around.
declare function userExists(user: string, l: Logger): Promise<boolean>; declare function createUserAccount(user: string, l: Logger): Promise<boolean>; declare function runAutomaticTrigger(user: string, l: Logger): Promise<boolean>; async function insertInDb(user: User, l: Logger): Promise<boolean> { const db = []; db.push(user); l.info("User inserted, running trigger"); return runAutomaticTrigger(user.username, l); } async function createUser(details: User): Promise<User> { const isPresent = await userExists(details.username, l); if (isPresent) { const inserted = await insertInDb(details, l); if (inserted) { const accountCreated = await createUserAccount(details.username, l); if (accountCreated) return details; else { throw new Error("unable to create user account"); } } else { throw new Error("unable to insert user in Db"); } } else { { throw new Error("user already exists"); } } } Two things aren't really cool with such approach:
- I have to pass the logger in every single function that needs this — every function must be aware of the new dependency
- The logger is a dependency, not really a function argument.
To start fixing this, let's try to put the dependency elsewhere:
- declare function userExists(user: string, l: Logger): Promise<boolean>; + declare function userExists(user: string): (l: Logger) => Promise<boolean>; So that we change the way we use the function:
- const promise = userExists(user, logger); + const promise = userExists(user)(logger); The result is:
declare function userExists(user: string): (l: Logger) => Promise<boolean>; declare function createUserAccount( user: string ): (l: Logger) => Promise<boolean>; declare function runAutomaticTrigger( user: string ): (l: Logger) => Promise<boolean>; function insertInDb(user: User) { return (l: Logger) => { const db = []; db.push(user); return runAutomaticTrigger(user.username)(l); }; } async function createUser(details: User) { return async (l: Logger) => { const isPresent = await userExists(details.username)(l); if (isPresent) { const inserted = await insertInDb(details)(l); if (inserted) { const accountCreated = await createUserAccount(details.username)(l); if (accountCreated) return details; else { throw new Error("unable to create user account"); } } else { throw new Error("unable to insert user in Db"); } } else { { throw new Error("user already exists"); } } }; } Let's now introduce a type to help us out to model this:
type Reader<R, A> = (r: R) => A;
And so we can now rewrite userExists as:
- declare function userExists(user: string): (l: Logger) => Promise<boolean>; + declare function userExists(user: string): Reader<Logger, Promise<boolean>>; Since TypeScript does not support HKT (but I still pray everyday that eventually it will), I am going to define a more specific type
interface ReaderPromise<R, A> { (r: R): Promise<A> } So I can make the following replacement:
- declare function userExists(user: string): Reader<Logger, Promise<boolean>>; + declare function userExists(user: string): ReaderPromise<Logger, boolean>; …and if I define an helper function called chain:
const chain = <R, A, B>(ma: ReaderPromise<R, A>, f: (a: A) => ReaderPromise<R, B>): ReaderPromise<R, B> => (r) => ma(r).then((a) => f(a)(r)) I can now rewrite the entire flow in such way:
function createUser(details: User): ReaderPromise<Logger, User> { return chain(userExists(details.username), (isPresent) => { if (isPresent) { return chain(insertInDb(details), (inserted) => { if (inserted) { return chain(createUserAccount(details.username), (accountCreated) => { if (accountCreated) { return (logger) => Promise.resolve(details); } else { throw new Error("unable to insert user in Db"); } }); } else { throw new Error("unable to create user account"); } }); } else { throw new Error("user already exists"); } }); } but that ain't that cool, since we're nesting nesting and nesting. We need to move to the next level.
Let's rewrite chain to be curried…
- const chain = <R, A, B>(ma: ReaderPromise<R, A>, f: (a: A) => ReaderPromise<R, B>): ReaderPromise<R, B> => (r) => ma(r).then((a) => f(a)(r)) + const chain = <R, A, B>(f: (a: A) => ReaderPromise<R, B>) => (ma: ReaderPromise<R, A>): ReaderPromise<R, B> => (r) => ma(r).then((a) => f(a)(r)) Well what happens now is that I can use ANY implementation of the pipe operator (the one in lodash will do), and write the flow in this way:
function createUser2(details: User): ReaderPromise<Logger, User> { return pipe( userExists(details.username), chain((isPresent) => { if (isPresent) return insertInDb(details); throw new Error("user already exists"); }), chain((inserted) => { if (inserted) return createUserAccount(details.username); throw new Error("unable to create user account"); }), chain((accountCreated) => { if (accountCreated) return DoSomething; throw new Error("unable to create user account"); }) ); } I can introduce another abstraction called Task
type Task<T> = () => Promise<T>
and then, just for commodity
type ReaderTask<R, A> = Reader<R, Task<A>>
Then I can refactor this part a little bit:
- declare function userExists(user: string): Reader<Logger, Promise<boolean>>; + declare function userExists(user: string): ReaderTask<Logger, boolean>; It turns out fp-ts already has a bunch of these defined, so I'm not going to bother using mines:
import * as R from "fp-ts/Reader"; import * as RT from "fp-ts/ReaderTask"; import { pipe } from "fp-ts/pipeable"; type User = { username: string; age: number; }; type Logger = { info: (msg: string) => void; debug: (msg: string) => void; warn: (msg: string) => void; error: (msg: string) => void; }; declare function userExists(user: string): RT.ReaderTask<Logger, boolean>; declare function createUserAccount( user: string ): RT.ReaderTask<Logger, boolean>; declare function runAutomaticTrigger( user: string ): RT.ReaderTask<Logger, boolean>; function insertInDb(user: User): RT.ReaderTask<Logger, boolean> { const db = []; db.push(user); return runAutomaticTrigger(user.username); } function createUser(details: User): RT.ReaderTask<Logger, Promise<User>> { return pipe( RT.ask<Logger>(), RT.chain(l => userExists(details.username)), RT.chain(isPresent => { if (isPresent) { return insertInDb(details); } else { throw new Error("user already exists"); } }), RT.chain(inserted => { if (inserted) { return createUserAccount(details.username); } else { throw new Error("unable to create user account"); } }), RT.map(accountCreated => { if (accountCreated) { return Promise.resolve(details); } else { throw new Error("unable to insert user in Db"); } }) ); } What are the differences with the original, naive, solution?
- Functions are not aware of the dependency at all. You just chain them and inject the dependency once:
const user = await createUser(details)(logger)() - The logger is now a separate set of arguments, making really clear what is a dependency and what is a function argument
- You can reason about the result of the computation even though you haven't executed anything yet.
Top comments (0)