Hacker News Reader

My path is a little different. I have used Haskell, and I'm looking to get into OTP.

My original plan was either Elixir or vanilla Erlang depending on which one suits my sensibilities better. Reading about Gleam recently has me super, super excited. That's definitely going to be my path now.

I don't know if Gleam is the best entry into the world of rich types that you find in a language like Haskell--I'm yet to actually build something with it.

What I can tell you is that Haskell is a complete joy to use and it honestly ruins most other programming for me. So as a direction, I cannot recommend it enough, and I'm hoping, for my sake and yours, that Gleam offers a similarly stimulating sandbox.

Just a warning that it will take time to get used to "higher-kinded" types. It's an exercise in head scratching and frustration at first. The reward part arrives when you start thinking in types yourself and you know which ones to reach for and when you find the libraries you want by entering a signature on Hoogle.

View on HN

import gleam/option import otp/gen_server import otp/types.{type Pid} pub type State { State(count: Int, initial_count: Int) } pub type Message { Increment(Int) Decrement(Int) Reset } pub fn start(initial_count: Int) -> Result(Pid(Message), Nil) { let spec = gen_server.GenServerStartSpec( handle_cast:, init:, name: option.Some(gen_server.GlobalName("counter")), ) gen_server.start(spec, initial_count) } fn name() -> gen_server.ProcessReference(Message, String) { gen_server.ByGlobal("counter") } pub fn count() -> Result(Int, Nil) { gen_server.call(name(), fn(state: State) -> gen_server.CallResult(State, Int) { gen_server.CallOk(new_state: state, reply: state.count) }) } pub fn increment(count: Int) -> Nil { gen_server.cast(name(), Increment(count)) } pub fn decrement(count: Int) -> Nil { gen_server.cast(name(), Decrement(count)) } pub fn reset() -> Nil { gen_server.cast(name(), Reset) } pub fn init(initial_count: Int) -> State { State(count: initial_count, initial_count:) } pub fn handle_cast( message: Message, state: State, ) -> gen_server.CastResult(State) { case message { Increment(count) -> gen_server.CastOk(State(..state, count: state.count + count)) Decrement(count) -> gen_server.CastOk(State(..state, count: state.count - count)) Reset -> gen_server.CastOk(State(..state, count: state.initial_count)) } }

pub type ProcessReference(message, term) { ByPid(Pid(message)) ByGlobal(term) ByLocal(Atom) } @external(erlang, "otp_server", "call") fn gen_server_call( pid: ProcessReference(message, term), call_func: CallFunc(state, reply), ) -> Result(reply, Nil)

call({by_pid, Pid}, CallFunc) -> {ok, gen_server:call(Pid, {call_by_func, CallFunc})}; call({by_global, Name}, CallFunc) -> {ok, gen_server:call({global, Name}, {call_by_func, CallFunc})}; call({by_local, Name}, CallFunc) -> {ok, gen_server:call(Name, {call_by_func, CallFunc})}.