gralha-http-server

Releases (1):
  0.1.0.0  0xfbae09b27ff064ae28a2dd82f08f4391  indexed  https://jend.leeeet.dev/files.txt?path=gralha-http-server@0.1.0.0

Definitions (22):
  Server.read.chunk (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=read.chunk)
   def read.chunk(socket: Socket, +text: String, +max: U32, next: Socket -> String -> IO(Socket & String)) ->
     IO(Socket & String):
  Server.read.got (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=read.got)
   def read.got(got: Socket & Result<&1, &1, U32 & String, Maybe<&1, String>>, acc: String, +max: U32,
     next: Socket -> String -> IO(Socket & String)) -> IO(Socket & String):
  Server.read.go (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=read.go)
   def read.go?(socket: Socket, +max: U32, acc: String) -> IO(Socket & String):
  Server.read.text (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=read.text)
   # The request's text: received until it is whole (Http.request.complete),
   # the peer stops sending, or more than max bytes arrived; "" on an error.
   def read.text(socket: Socket, +max: U32) -> IO(Socket & String):
  Server.read.parse (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=read.parse)
   def read.parse(got: Socket & String) -> IO(Socket & Maybe<&2, Http.Request>):
  Server.read (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=read)
   # The request read and parsed, or None if it never became one.
   def read(socket: Socket, +max: U32) -> IO(Socket & Maybe<&2, Http.Request>):
  Server.send.done (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=send.done)
   # A failed send also hands back the unsent rest, which a closing reply drops.
   def send.done(got: Socket & Result<&1, &1, (U32 & String) & List<&2, U32>, Unit>) -> IO(Unit):
  Server.send.text (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=send.text)
   # Sends text as it is and closes the socket.
   def send.text(socket: Socket, text: String) -> IO(Unit):
  Server.closing (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=closing)
   # The response with Connection: close, unless it names a Connection.
   def closing(r: Http.Response) -> Http.Response:
  Server.send (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=send)
   # Sends a response (Http.response.text, with Connection: close) and closes
   # the socket.
   def send(socket: Socket, r: Http.Response) -> IO(Unit):
  Server.answer.sent (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=answer.sent)
   def answer.sent(-S: Type, socket: Socket, out: S & Http.Response) -> IO(S):
  Server.answer (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=answer)
   def answer(~S: Type, ~handle: Http.Request -> S -> IO(S & Http.Response),
     got: Socket & Maybe<&2, Http.Request>, state: S) -> IO(S):
  Server.answer.socket (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=answer.socket)
   def answer.socket(~S: Type, ~reply: Socket -> Http.Request -> S -> IO(S),
     got: Socket & Maybe<&2, Http.Request>, state: S) -> IO(S):
  Server.accepted (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=accepted)
   def accepted(~S: Type, ~handle: Http.Request -> S -> IO(S & Http.Response),
     got: Listener & Result<&1, &1, U32 & String, Socket>, state: S, +max: U32) -> IO(Listener & S):
  Server.accepted.socket (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=accepted.socket)
   def accepted.socket(~S: Type, ~reply: Socket -> Http.Request -> S -> IO(S),
     got: Listener & Result<&1, &1, U32 & String, Socket>, state: S, +max: U32) -> IO(Listener & S):
  Server.step (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=step)
   # Accepts one connection, reads its request (up to max bytes), answers it
   # with handle(request)(state) and closes it; a request that never parses
   # gets a 400. A failed accept leaves the state as it was.
   def step(~S: Type, ~handle: Http.Request -> S -> IO(S & Http.Response),
     listener: Listener, state: S, +max: U32) -> IO(Listener & S):
  Server.step.socket (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=step.socket)
   # As step, but reply(socket)(request)(state) answers on the socket itself
   # and must close it: for bodies the app streams through its own effect.
   def step.socket(~S: Type, ~reply: Socket -> Http.Request -> S -> IO(S),
     listener: Listener, state: S, +max: U32) -> IO(Listener & S):
  Server.loop.next (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=loop.next)
   def loop.next(-S: Type, got: Listener & S, next: Listener -> S -> IO(Listener & S)) -> IO(Listener & S):
  Server.serve.for (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=serve.for)
   # Serves n connections, then hands back the listener and the state.
   def serve.for(~S: Type, ~handle: Http.Request -> S -> IO(S & Http.Response),
     n: Nat, listener: Listener, state: S, +max: U32) -> IO(Listener & S):
  Server.serve.socket.for (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=serve.socket.for)
   def serve.socket.for(~S: Type, ~reply: Socket -> Http.Request -> S -> IO(S),
     n: Nat, listener: Listener, state: S, +max: U32) -> IO(Listener & S):
  Server.serve (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=serve)
   # Serves connections forever, one at a time (unsafe: it never ends).
   def serve?(~S: Type, ~handle: Http.Request -> S -> IO(S & Http.Response),
     listener: Listener, state: S, +max: U32) -> IO(Listener & S):
  Server.serve.socket (https://jend.leeeet.dev/definition.txt?path=gralha-http-server@0.1.0.0/server.bend&name=serve.socket)
   def serve.socket?(~S: Type, ~reply: Socket -> Http.Request -> S -> IO(S),
     listener: Listener, state: S, +max: U32) -> IO(Listener & S):