How to translate Elixir types to Gleam FFI?

[evaogbe]

I am trying to use an Elixir Redis client in Gleam. The spec for the start_link function is @spec start_link(binary() | keyword()) :: {:ok, pid()} | :ignore | {:error, term()}. How would I translate the return type to Gleam?

[GearsDatapacks]

In Gleam you would make a custom type. You could either make a type which translates to the exact same thing, like this:

type LinkResult {
  Ok(Pid)
  Ignore
  Error(Dynamic)
}

However this isn't great as it shadows the Ok and Error constructors of the Result type.

What I would probably do instead is write a short function in elixir, which calls the start_link function, pattern matches on the result, and turns it into a Gleam type which you define that better suits your API. This is also good practise for when the return type doesn't map so neatly to a Gleam type

[evaogbe]

If I wanted to do something like:

type StartResult {
  Connected(Pid)
  StartError
}

how would I do the Elixir atoms to match the Gleam type? Is there autocapitalization?

[giacomocavalieri]

A gleam custom type is turned into a tuple with an atom as its first item, names in PascalCase are turned into snake_case. If a constructor has no arguments it is just an atom.

So these Gleam values:

pub type Wibble {
  Wobble
  WibbleWoo(Int)
}

Wobble
WibbleWoo(1)

Would be represented as

:wobble
{:wibble_woo, 1}

[GearsDatapacks]

Yep, Gleam variants are always PascalCase, but they are transformed into snake_case atoms (or tuples with atoms as the first element) on the Erlang target. Your elixir return type for the above would be {:connected, pid()} | :start_error

[GearsDatapacks]

Wow we sent those messages within seconds of each other

[evaogbe]

Thank you. That worked