Os argumentos opcionais para funções de ordem superior

Question 1

Eu tento escrever uma ligação por socket.io.

Eu estou tendo problemas com uma função (next() no meu código de exemplo na parte inferior), que leva nenhum argumento ou um objeto de erro (Js.Exn.raiseError("ERROR!")).

Eu não consigo encontrar uma maneira de definir uma função de assinatura que pode ter os dois tipos de argumento como o primeiro valor.

Eu não estou mesmo certo que, se o que eu estou pedindo é possível em decreto, qualquer ajuda para resolver o problema no próprio decreto forma, seria apreciada.

Meu implementação atual se parece com isso:

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

Não é possível, em geral, ter uma função com um número variável de argumentos, mas é possível passar undefined ou um valor que, na maioria dos casos vão ser equivalentes.

Uma maneira de fazer isso é simplesmente usar o option escreva. Se nós re-definir next como

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

podemos usá-lo como este

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

que irá gerar o seguinte JavaScript:

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

Outra opção pode ser usar argumentos opcionais, mas isto não parece trabalhar com uncurrying, e recentemente houve erros com pelaria que o compilador autor parece não ter nenhum interesse em fixar, por isso não pode trabalhar lá, mas pode valer a pena um tiro.:

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

Por fim, já existe algumas ligações para o soquete.io (bs-soquete.io). Estes também não lidar com esse caso, infelizmente, mas ele pode salvar você de re-inventar algumas rodas de, no mínimo.

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

Não é possível, em geral, ter uma função com um número variável de argumentos, mas é possível passar undefined ou um valor que, na maioria dos casos vão ser equivalentes.

Uma maneira de fazer isso é simplesmente usar o option escreva. Se nós re-definir next como

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

podemos usá-lo como este

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

que irá gerar o seguinte JavaScript:

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

Outra opção pode ser usar argumentos opcionais, mas isto não parece trabalhar com uncurrying, e recentemente houve erros com pelaria que o compilador autor parece não ter nenhum interesse em fixar, por isso não pode trabalhar lá, mas pode valer a pena um tiro.:

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

Por fim, já existe algumas ligações para o soquete.io (bs-soquete.io). Estes também não lidar com esse caso, infelizmente, mas ele pode salvar você de re-inventar algumas rodas de, no mínimo.

Os argumentos opcionais para funções de ordem superior

Pergunta

Melhor resposta

Em outros idiomas

Esta página está em outros idiomas

Popular nesta categoria

Perguntas populares nesta categoria