Argumentos opcionales para funciones de orden superior

Question 1

Trato de escribir un enlace para el socket.io.

Estoy teniendo problemas con una función (next() en mi ejemplo de código en la parte inferior), que no toma ningún argumento o un objeto de error (Js.Exn.raiseError("ERROR!")).

No puedo encontrar una forma de definir una función de firma que puede tomar ambos tipos de argumento como el primer valor.

Ni siquiera estoy seguro de que, si lo que estoy pidiendo es posible en el rescripto, cualquier ayuda para solucionar ese problema en el buen rescripto manera, se agradece.

Mi aplicación actual se parece a esto:

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

No es posible, en general, tenga una función con un número variable de argumentos, pero es posible pasar a cualquiera undefined o un valor, que en la mayoría de los casos será equivalente.

Una manera de hacerlo es utilizar simplemente el option tipo. Si nos re-definir next como

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

podemos usarlo como este

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

que va a generar el JavaScript siguiente:

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

Otra opción podría ser la utilización de argumentos opcionales, pero esto no parece funcionar con uncurrying, y recientemente ha habido errores con alarmada que el compilador autor parece no tener interés en la fijación, así que no podría trabajar allí, pero podría ser vale la pena un tiro:

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

Por último, existe ya algunos enlaces para el socket.io (bs-socket.io). Estos también no manejan este caso, por desgracia, pero es posible ahorrar de re-inventar unas ruedas por lo menos.

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

No es posible, en general, tenga una función con un número variable de argumentos, pero es posible pasar a cualquiera undefined o un valor, que en la mayoría de los casos será equivalente.

Una manera de hacerlo es utilizar simplemente el option tipo. Si nos re-definir next como

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

podemos usarlo como este

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

que va a generar el JavaScript siguiente:

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

Otra opción podría ser la utilización de argumentos opcionales, pero esto no parece funcionar con uncurrying, y recientemente ha habido errores con alarmada que el compilador autor parece no tener interés en la fijación, así que no podría trabajar allí, pero podría ser vale la pena un tiro:

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

Por último, existe ya algunos enlaces para el socket.io (bs-socket.io). Estos también no manejan este caso, por desgracia, pero es posible ahorrar de re-inventar unas ruedas por lo menos.

Argumentos opcionales para funciones de orden superior

Pregunta

Mejor respuesta

En otros idiomas

Esta página está en otros idiomas

Popular en esta categoría

Las preguntas más habituales en esta categoría