Monads, bind and do

[lucasavila00]

I'm re-implementing parts of fp-ts in Gleam.

It works very well, inference and type-checking works perfectly.

As an example:

// reader.gleam

pub type Reader(r, t) =
  fn(r) -> t

pub fn of(a: a) -> Reader(r, a) {
  fn(_r: r) { a }
}

pub fn ap(fa: Reader(r, a), f: Reader(r, fn(a) -> b)) -> Reader(r, b) {
  fn(r: r) { f(r)(fa(r)) }
}

pub fn map(fa: Reader(r, a), f: fn(a) -> b) -> Reader(r, b) {
  fn(r: r) { f(fa(r)) }
}

pub fn chain(fa: Reader(r, a), f: fn(a) -> Reader(r, b)) -> Reader(r, b) {
  fn(r: r) { f(fa(r))(r) }
}

// reader_result.gleam

import reader as r

pub type ReaderResult(r, e, a) =
  fn(r) -> Result(a, e)

pub fn of(a: a) -> ReaderResult(r, e, a) {
  fn(_r: r) { Ok(a) }
}

pub fn map(fa: ReaderResult(r, e, a), f: fn(a) -> b) -> ReaderResult(r, e, b) {
  fn(r: r) {
    try result = fa(r)
    Ok(f(result))
  }
}

pub fn chain(
  fa: ReaderResult(r, e, a),
  f: fn(a) -> ReaderResult(r, e, b),
) -> ReaderResult(r, e, b) {
  fn(r: r) {
    try result = fa(r)
    f(result)(r)
  }
}

pub fn from_reader(fa: r.Reader(r, a)) -> ReaderResult(r, e, a) {
  fn(r: r) { Ok(fa(r)) }
}

pub fn chain_reader_k(
  fa: ReaderResult(r, e, a),
  f: fn(a) -> r.Reader(r, b),
) -> ReaderResult(r, e, b) {
  fn(r: r) {
    try result = fa(r)
    Ok(f(result)(r))
  }
}

import gleam/io
import gleam/int
import gleam/string
import reader as r
import reader_result as rr

fn lazy(it) {
  fn() { it }
}

type Deps {
  Deps(get_count: fn() -> Int, logger: fn(String) -> Nil)
}

fn log_it(it) {
  fn(d: Deps) {
    d.logger(int.to_string(it))
    it
  }
}

fn maybe_log_it(it) {
  fn(d: Deps) {
    d.logger(int.to_string(it))
    Ok(it)
  }
}

fn add_one(it) {
  it + 1
}

fn make_operation() {
  fn(d: Deps) { d.get_count() }
  |> r.chain(log_it)
  |> r.map(add_one)
  |> r.chain(log_it)
  |> r.map(add_one)
}

pub fn main() {
  let deps =
    Deps(
      get_count: lazy(3),
      logger: fn(s) { io.println(string.concat(["log: ", s])) },
    )

  let operation =
    make_operation()
    |> r.chain(log_it)

  let result = operation(deps)

  io.debug(result)

  let operation2 =
    operation
    |> rr.from_reader()
    |> rr.map(add_one)
    |> rr.chain(maybe_log_it)
    |> rr.map(add_one)
    |> rr.chain_reader_k(log_it)

  let result2 = operation2(deps)

  io.debug(result2)
}

But I can't get any way to implement bind, or do notation.

fp-ts uses typescript records to simulate a scope: https://gcanti.github.io/fp-ts/guides/do-notation.html

On ocaml, there are the let operators: https://v2.ocaml.org/manual/bindingops.html

On haskell, there is do notation: https://en.wikibooks.org/wiki/Haskell/do_notation

In gleam there is something close to it that is the try keyword used for Results.

Is there a way to work around it? Are there plans to extend something similar to, or try but for any other monad?

To sum it up, I'd like to turn this:

let op =
  r.of("x")
  |> r.chain(fn(x) {
    r.of("y")
    |> r.chain(fn(y) {
      io.println(x)
      io.println(y)
      r.of(string.concat([x, y]))
    })
  })

io.debug(op(deps))

into something similar to haskell/ocaml

// some syntax for binding then to a function
let op = with r.chain as then {
    then x = r.of("x")
    then y = r.of("y")
    io.println(x)
    io.println(y)
    r.of(string.concat([x, y])
}

io.debug(op(deps))

import gleam/result
let op2 = with result.then as then {
  then x = Ok("a")
  then y = Ok("b")
  io.debug(x)
  io.debug(y)
  Ok(string.concat([x, y])
}
io.debug(op2)

import gleam/javascript/promise
let op3 = with promise.then as then {
  then x = promise.resolve("a")
  then y = promise.resolve("b")
  io.debug(x)
  io.debug(y)
  promise.resolve(string.concat([x, y])
}
io.debug(op3)

or fp-ts

let op =
  r.of("x")
  |> r.bind_to(X)
  |> r.bind(Y, fn (_accumulator) { r.of("y")} )
  |> r.chain(fn (accumulator) { 
     io.prinln(accumulator.X)
     io.prinln(accumulator.Y)
     r.of(string.concat([accumulator.X, accumulator.Y]))
  })

io.debug(op(deps))

let op =
  r.do()
  |> r.bind(X, fn (_accumulator) { r.of("x")} )
  |> r.bind(Y, fn (_accumulator) { r.of("y")} )
  |> r.chain(fn (accumulator) { 
     io.prinln(accumulator.X)
     io.prinln(accumulator.Y)
     r.of(string.concat([accumulator.X, accumulator.Y]))
  })

io.debug(op(deps))

[lucasavila00]

We can also have reader_promise and so on:

import gleam/javascript/promise

pub type ReaderPromise(r, t) =
  fn(r) -> promise.Promise(t)

pub fn of(a: a) -> ReaderPromise(r, a) {
  fn(_r: r) { promise.resolve(a) }
}

pub fn map(fa: ReaderPromise(r, a), f: fn(a) -> b) -> ReaderPromise(r, b) {
  fn(r: r) { promise.map(fa(r), f) }
}

pub fn chain(
  fa: ReaderPromise(r, a),
  f: fn(a) -> ReaderPromise(r, b),
) -> ReaderPromise(r, b) {
  fn(r: r) { promise.then(fa(r), fn(then) { f(then)(r) }) }
}

It would be a solution to the callback example shown in https://gleam.run/news/v0.16-gleam-compiles-to-javascript/

Specifically, we could have a task monad, which is a lazy promise. It wouldn't auto-flatten, aswell.

[lpil]

This is really cool! I've left some thoughts in the issue you made relating to a rebindable syntax