Bevezetés
A use kifejezések használata
Gleamben gyakori, hogy magasabb rendű függvényeket írunk és használunk, vagyis olyan függvényeket, amelyek más függvényeket fogadnak argumentumként. Előfordul, hogy amikor egyszerre sok magasabb rendű függvényt használunk, a kód a sok behúzási szint miatt nehezen olvashatóvá válik.
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 olvashatóbbá 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 összegyűjti a blokkban utána következő összes utasítást, és azokat callback függvényként adja át a függvényhívás utolsó argumentumaként. A use kulcsszó és a <- szimbólum között álló változók azoknak az argumentumoknak a nevei, amelyeket a callback függvény meg fog kapni.
// 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 callback 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 különösebb követelmény az olyan függvények létrehozásához, amelyeket use kifejezéssel lehet meghívni, azon kívül, hogy utolsó argumentumként egy callback függvényt fogadnak.
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 lehetőséget kínálnak, és sok problémára alkalmazhatók, de ha túl sokat használjuk őket, nehezen olvashatóvá tehetik a kódot. Általában jobb a szokásos függvényhívási szintaxist használni, és csak akkor nyúlni a use kifejezésekhez, amikor olvashatóbbá teszik a kódot.
Utasítások
Daphne egy rendszert fejlesztett, amellyel a kísérleteit futtatja és rögzíti azok eredményeit. A kód egy része kicsit bőbeszédűvé és ismétlődővé vált, ezért megkért, hogy írj néhány use kifejezést, amelyek segítenek letisztázni.
1. Definiáld a with_retry függvényt
Néha egy kísérlet egy egyszeri hiba miatt elbukhat, ezért ha egy kísérlet sikertelen, Daphne szeretné újra megpróbálni, hogy lássa, másodszorra sikerül-e.
Definiáld a with_retry függvényt, amely argumentumként egy eredményt visszaadó függvényt kap.
Ha a függvény Ok értéket ad vissza, akkor a with_retry is azt az értéket adja vissza.
Ha a függvény Error értéket ad vissza, akkor a with_retry újra meghívja a függvényt, és annak a hívásnak az eredményét adja vissza.
Daphne így fogja használni a függvényt:
pub fn main() {
use <- with_retry
// Perform the experiment here
}
2. Definiáld a record_timing függvényt
Daphne úgy rögzíti, hogy mennyi ideig tart az egyes kísérletek futtatása, hogy minden kísérlet előtt és után meghív egy időnaplózó függvényt.
Definiáld a record_timing függvényt, amely két argumentumot kap:
- Egy időnaplózó függvényt, amely nem kap argumentumot, és
Nil-t ad vissza.
- Egy kísérletfüggvényt, amely nem kap argumentumot, és egy eredményt ad vissza.
A record_timing először meghívja az időnaplózó függvényt, majd a kísérletfüggvényt, aztán ismét az időnaplózó függvényt, végül pedig visszaadja a kísérletfüggvény eredményét.
Daphne így fogja használni a függvényt:
pub fn main() {
use <- record_timing(time_logger)
// Perform the experiment here
}
3. Definiáld a run_experiment függvényt
A kísérletek három fázisból állnak: az előkészítésből, a végrehajtásból és a rögzítésből. Mindhárom fázis eredményt ad vissza, és mindegyik fázisnak szüksége van az előző fázis sikeres eredményére ahhoz, hogy lefusson.
Definiáld a run_experiment függvényt, amely négy argumentumot kap:
- A kísérlet nevét egy
String-ként.
- Egy előkészítő függvényt, amely nem kap argumentumot, és egy eredményt ad vissza.
- Egy végrehajtó függvényt, amely argumentumként az előkészítő függvény
Ok értékét kapja, és egy eredményt ad vissza.
- Egy rögzítő függvényt, amely argumentumként az előkészítő és a végrehajtó függvény
Ok értékét kapja, és egy eredményt ad vissza.
Ha mindhárom függvény sikeresen lefut, akkor a run_experiment a Ok(#(experiment_name, recording_data)) értéket adja vissza.
Ha bármelyik függvény Error értéket ad vissza, akkor a run_experiment azt az értéket adja vissza.
Daphne így fogja használni a függvényt:
pub fn main() {
use setup_data, action_data <- run_experiment("Test 1", setup, action)
// Record the results here
}
Tanulófeladat
