Use-kifejezések ebben a kurzusban:

A(z) Use-kifejezések fogalomról

Gleamben gyakori, hogy magasabb rendű függvényeket írunk és használunk, vagyis olyan függvényeket, amelyek más függvényeket kapnak argumentumként. Ha egyszerre sok magasabb rendű függvényt használunk, a kód a sok egymásba ágyazott behúzás miatt nehezen olvashatóvá válhat.

Például itt van egy függvény, amely több olyan függvényt hív meg, amelyek Result(Int, Nil) értéket adnak vissza, és összegzi az értékeket, ha mind a négy sikeres.

import gleam/result

pub fn main() -> Result(Int, Nil) {
  result.try(function1(), fn(a) {
    result.try(function2(), fn(b) {
      result.try(function3(), fn(c) {
        result.try(function4(), fn(d) {
          Ok(a + b + c + d)
        })
      })
    })
  })
}

A Gleam use kifejezéseivel ezt a kódot behúzás nélkül is leírhatjuk, ami gyakran könnyebben olvashatóvá teszi.

import gleam/result

pub fn main() -> Result(Int, Nil) {
  use a <- result.try(function1())
  use b <- result.try(function2())
  use c <- result.try(function3())
  use d <- result.try(function4())
  Ok(a + b + c + d)
}

A use kifejezés a blokkban utána következő összes utasítást összegyűjti, és visszahívó függvényként adja át a függvényhívás utolsó argumentumaként. A use kulcsszó és a <- szimbólum közötti változók azoknak az argumentumoknak a nevei, amelyeket a visszahívó függvény megkap.

// This use expression
use a <- function(1, 2)
io.println("Hello!")
a

// Is equivalent to this normal function call
function(1, 2, fn(a) {
  io.println("Hello!")
  a
})

A visszahívó függvény tetszőleges számú argumentumot kaphat, de akár egyet sem.

use a, b, c, d <- call_4_function()

use <- call_0_function()

Nincs semmilyen különleges feltétel ahhoz, hogy egy függvényt use kifejezéssel lehessen meghívni, csak az, hogy az utolsó argumentuma egy visszahívó függvény legyen.

pub fn call_twice(function: fn() -> t) -> #(t, t) {
  let first = function()
  let second = function()
  #(first, second)
}

A Gleam use kifejezései nagyon hatékony eszközök, amelyek sokféle problémára alkalmazhatók, de ha túl sokat használod őket, a kód nehezen olvashatóvá válhat. Általában érdemes a szokásos függvényhívási szintaxist használni, és csak akkor nyúlni a use kifejezésekhez, ha azok tényleg könnyebben olvashatóvá teszik a kódot.