←back to thread

Everything Is Just Functions: 1 week with David Beazley and SICP

(ezzeriesa.notion.site)
389 points kurinikku | 2 comments | 17 Nov 24 15:07 UTC | HN request time: 0.001s | source
Show context
marvinborner ◴[17 Nov 24 16:10 UTC] No.42164919[source]▶
They give a nice introduction to encoding state as pure functions. In fact, there are many more purely functional encodings for all kinds of data like trees, integers, sum/product types, images, monads, ...

The encodings can be a bit confusing, but really elegant and tiny at the same time. Take for example a functional implementation of the Maybe monad in javascript:

  Nothing = nothing => just => nothing
  Just = v => nothing => just => just(v)
  
  pure = Just
  bind = mx => f => mx(mx)(f)
  
  evalMaybe = maybe => maybe("Nothing")(v => "Just " + v)
  console.log(evalMaybe(bind(Nothing)(n => pure(n + 1)))) // Nothing
  console.log(evalMaybe(bind(Just(42))(n => pure(n + 1)))) // Just 43
replies(5): >>42166462 #>>42166688 #>>42166841 #>>42168370 #>>42173549 #
hinkley ◴[17 Nov 24 19:38 UTC] No.42166462[source]▶
[flagged]
replies(4): >>42166679 #>>42167412 #>>42167730 #>>42167790 #
marvinborner ◴[17 Nov 24 21:22 UTC] No.42167412[source]▶
I think it's all right if you're used to the notation. The first two lines are tagged unions and will be recognisable as such if you're familiar with encodings like Scott/Church pairs/lists/numbers. Once you understand the structure, the definition of `bind` becomes obvious, as its two arguments represent the cases "is nothing" and "is just", where in the first case Nothing is returned, and in the second case the function is applied to the value inside the Just.

I think that writing such code, if only for educational purposes, can be really helpful in actually understanding how the state "flows" during the monadic bind/return. Typical monad instantiations of Maybe do not give such deep insight (at least to me).

> Just because you can do a thing doesn’t mean you should.

Of course you should, where would be the fun in that?

replies(3): >>42167560 #>>42167804 #>>42167828 #
1. tmtvl ◴[17 Nov 24 22:10 UTC] No.42167804[source]▶
> The first two lines are tagged unions

Are they? But in the Nothing you have 2 identical members (`nothing' without arguments), won't that throw an exception?

To borrow Rust syntax (pun intended):

  enum Nothing {
    nothing,
    just
    nothing
  };
That's just weird.
replies(2): >>42167978 #>>42168288 #
2. marvinborner ◴[17 Nov 24 22:34 UTC] No.42167978[source]▶
When encoding tagged unions as lambdas, the tags are arguments. In this case `Nothing` has two available tags (`nothing` and `just`) and uses the tag `nothing`. `Just` does the same with the tag `just`, only that the tag gets an additional argument (as does its constructor `Just`), such that the value can be extracted afterwards - just like in an enum:

  enum Maybe<T> {
    Nothing,
    Just(T),
  }