Gleam

//// to document a module
/// to document what is below (types,functions)
fn a_function_name(a: Int) -> Int {}
Constructor
type AType = Int // type alias

• variable_name
• Constructor

• type alias

  type UserId = Int
  

pub fn sum(x: Int, y: Int) -> Int { // public
  x + y    // implicit return
}

• High order functions: can be passed as arguments or assined to variables

• Anonymous functions

  let mul = fn(x,y) { x * y }
  mul(1,2)
  

• Function Capture (shorthand for unary anonymous functions that pass its argument)

  let add_one_v1 = fn(x) { add(1,x) }
  let add_one_v2 = add(1,_)
  

• Generic Functions (aka parametric polymorphism)

  fn twice(argument: value, my_function: fn(value) -> value) -> value {
    my_function(my_function(argument))
  }
  

• Labelled Arguments

  pub fn replace(inside string: String, each pattern: String, with replacement: String) {}
  pub fn replace(inside string        , each pattern        , with replacement) {
    go(string, patter, replacement)
  }
  replace(each: ",", with: " ", inside: "A,B,C")
  

• deprecation

  @deprecated("use new_fucntion instead") // attribute
  fn old_function() {
    Nil
  }
  

• +, +.
• <>
• = ! (structural equality, same for all types)
• && ||
• N / 0 (div by 0 returns 0)
• |>
  • a |> b(1,2)
    • b(a,1,2)
    • b(1,2)(a)

• for using callbacks in an unindented style

• before

  result.try(get_username(), fn(username) {
    result.try(get_password(), fn(password) {
      result.map(log_in(username, password), fn(greeting){
        greeting <> ", " <> username
      })
    })
  })
  

• after

  use username <- result.try(get_username())
  use password <- result.try(get_password())
  use greeting <- result.map(log_in(username, password))
  greeting <> ", " <> username
  

erlang + elixir

@external(erlang, "rand", "uniform")
pub fn random_float() -> Float

@external(erlang, "Elixir.IO", "inspect")
pub fn inspect(a) -> a

erlang + javascript

pub type Datetime

@external(erlang, "calendar", "local_time")
@external(javascript, "./my_package_ffi.mjs", "now") // export function now() { return new Date(); }
pub fn now() -> Datetime

now()

gleam + erlang

@external(erlang, "lists", "reverse")
pub fn reverse_list(items: List(e)) -> List(e) {
  tail_recursive_reverse(items, []) // gleam implementation
}

• no loops, only recursion, has TCO

• case

  • there is no if/else
  • has exhaustiveness checks

  type User {
    LoggedIn(name: String, age: Int)
    Guest
  }
  let user = Guest
  case user,10 { // multiple subjects
    // [1,..] -> "list starts with 1"
    LoggedIn(name,..),_        -> name                                        // spread to discard others
    "Tom" <> lastname,_ as usr -> "Hello " <> lastname <> " Tom..aka " <> usr // as
    Guest,10 | Guest,11        -> "Guest user 10-ish"                         // alternative pattern
    Guest,i if i > 20          -> "Guest user " <> int.to_string(i)           // guard, CANNOT call functions
    Guest,_                    -> "Guest user"
  }
  

• result
  • map: takes fn -> value (aka Functor?)
  • try: takes fn -> Result() (aka Monad?)
  • unwrap: extracts the Ok(success) value, or given default

https://gleam.run/writing-gleam/gleam-toml/

• /build/dev/javascript
  • module_name/
  • prelude.mjs
  • gleam.mjs
• /build/dev/erlang
  • gleam_stdlib
  • module_name/ebin/*.beam