Argumente opționale pentru funcții de ordin superior

Question 1

Am încercat să scrie un caracter obligatoriu pentru soclu.io.

Am probleme cu o funcție (next() în exemplul de cod de mai jos), care fie nevoie de nici un argument sau o eroare obiect (Js.Exn.raiseError("ERROR!")).

Eu nu pot găsi o modalitate de a defini o funcție, semnătură care pot avea ambele tipuri de argument ca prima valoare.

Nu sunt chiar sigur, dacă ceea ce îți cer este posibilă în rescrieri, orice ajutor pentru a rezolva această problemă în buna rescrieri fel, ar fi de apreciat.

Meu actual de punere în aplicare arată astfel:

type server
type socket
type next = (. unit) => unit 

@new @module("socket.io") external socketIO: unit => server = "Server"
@send external use: (server, (socket, next) => unit) => unit = "use"
@send external listen: (server, int) => unit = "listen"
@send external on: (server, @string [ #connection(socket => unit) ] ) => unit = "on"

let io = socketIO()

io->use((socket, next) => {
    Js.log("FIRST")
    next(.)
})

io->use((socket, next) => {
    Js.log("SECOND")
    next(.)
})

io->on(#connection(socket => 
    Js.log("CONNECT")
))

io->listen(3000)

Question 2

Nu este posibil în general să aibă o funcție cu număr variabil de argumente, dar este posibil să treacă, fie undefined sau o valoare, care, în cele mai multe cazuri va fi echivalentă.

O modalitate de a face acest lucru este de a folosi pur și simplu option tip. Dacă ne-am re-defini next ca

type next = (. option<int>) => unit

putem folosi astfel de prognoze

io->use((_socket, next) => {
    next(. None)
    next(. Some(42))
})

care va genera următoarele JavaScript:

io.use(function (_socket, next) {
      next(undefined);
      return next(42);
    });

O altă opțiune ar fi de a utiliza argumente opționale, dar acest lucru nu pare să funcționeze cu uncurrying, și, recent, au fost bug-uri cu curtau pe care compilatorul autorul pare să aibă nici un interes în stabilirea, așa că nu ar merge nici acolo, dar ar putea fi în valoare de o lovitură:

type next = (~error: int=?, unit) => unit
...
io->use((_socket, next) => {
    next(())
    next(~error=42, ())
})

În cele din urmă, există deja unele legături pentru soclu.io (bs-socket.io). Acestea, de asemenea, să nu se ocupe de acest caz, din păcate, dar s-ar putea salva de la re-inventa niște roți cel puțin.

glennsl · Answer 1 · 2021-11-20T18:44:49

Nu este posibil în general să aibă o funcție cu număr variabil de argumente, dar este posibil să treacă, fie undefined sau o valoare, care, în cele mai multe cazuri va fi echivalentă.

O modalitate de a face acest lucru este de a folosi pur și simplu option tip. Dacă ne-am re-defini next ca

type next = (. option<int>) => unit

putem folosi astfel de prognoze

io->use((_socket, next) => {
    next(. None)
    next(. Some(42))
})

care va genera următoarele JavaScript:

io.use(function (_socket, next) {
      next(undefined);
      return next(42);
    });

O altă opțiune ar fi de a utiliza argumente opționale, dar acest lucru nu pare să funcționeze cu uncurrying, și, recent, au fost bug-uri cu curtau pe care compilatorul autorul pare să aibă nici un interes în stabilirea, așa că nu ar merge nici acolo, dar ar putea fi în valoare de o lovitură:

type next = (~error: int=?, unit) => unit
...
io->use((_socket, next) => {
    next(())
    next(~error=42, ())
})

În cele din urmă, există deja unele legături pentru soclu.io (bs-socket.io). Acestea, de asemenea, să nu se ocupe de acest caz, din păcate, dar s-ar putea salva de la re-inventa niște roți cel puțin.

Argumente opționale pentru funcții de ordin superior

Problema

Cel mai bun răspuns

În alte limbi

Această pagină este în alte limbi

Popular în această categorie

Întrebări frecvente în această categorie