feat: adds a simple Http library to Std

src/Std/Internal.lean

@@ -9,6 +9,7 @@ prelude
 public import Std.Internal.Async
 public import Std.Internal.Parsec
 public import Std.Internal.UV
+public import Std.Internal.Http
 
 @[expose] public section
 

src/Std/Internal/Http.lean

@@ -0,0 +1,100 @@
+/-
+Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Sofia Rodrigues
+-/
+module
+
+prelude
+public import Std.Internal.Http.Server
+
+public section
+
+/-!
+# Http
+
+A "low-level" HTTP 1.1 Server implementation for Lean. It is designed to be used with or without the
+`Async` library if you want to implement a custom `Connection`.
+
+# Overview
+
+This module of the standard library defines many concepts related to the HTTP protocol and its semantics
+in a sans I/O format.
+
+**sans I/O** means that the core logic of the library doesn’t perform any actual input/output itself,
+it just defines how data *should* be processed. This separation allows the protocol implementation
+to remain pure and testable, while different transports (like TCP sockets or mocks) can handle
+the actual reading and writing of bytes.
+
+The main function of this library is `Std.Http.Server.serve`,
+located in the module `Std.Internal.Http.Server`. It starts a simple HTTP/1.1 server that
+handles all requests and sends them to a simple handler function. It uses the default `Std.Internal.Async`
+library, but it can be customized to use whatever IO library you want, as the protocol implementation
+is pure.
+
+If you want to customize how your server handles sockets, you can use `Std.Http.Server.serveConnection`,
+which is a simple function to bind a handler to a `Transport`.
+
+# Minimal Example
+
+```lean
+import Std.Internal.Http
+import Std.Internal.Async
+
+open Std.Internal.IO.Async
+open Std Http
+
+def handler (req : Request Body) : ContextAsync (Response Body) := do
+  let some data ← req.body.collectString
+    | return Response.badRequest "expected a utf8 body"
+
+  return Response.ok ("hi, " ++ data)
+
+def mainAsync : Async Unit := do
+  let address := .v4 (.mk (.ofParts 0 0 0 0) 8080)
+  let server ← Server.serve address handler
+  server.waitShutdown
+
+def main := mainAsync.block
+```
+
+# Main Concepts
+
+## Transport
+
+`Std.Http.Server.Transport` is a type class that defines how communication occurs between a `Connection`
+and the outside world. It can be implemented by, for example, a `Mock.Client`, which sends and receives
+byte arrays for deterministic HTTP connection testing, or by a `TCP.Socket.Client`, which is the
+standard way to communicate over the internet in HTTP/1.1.
+
+## Connection
+
+`Std.Http.Server.Connection` is a structure that holds both a `Transport` and a `Machine`. The machine is
+a `Protocol.H1.Machine`, which implements the state machine responsible for parsing HTTP/1.1 requests and responses.
+It can change in the future if some other protocols are implemented
+
+If you want to customize how your server handles sockets, you can use `Std.Http.Server.serveConnection`,
+a simple function that binds a handler to a `ClientConnection`.
+
+# Minimal Example
+
+```lean
+import Std.Internal.Http
+import Std.Internal.Async
+
+open Std.Internal.IO.Async
+open Std Http
+
+def handler (req : Request Body) : ContextAsync (Response Body) := do
+  let some data ← req.body.collectString
+    | return Response.badRequest "expected a utf8 body"
+
+  return Response.ok ("hi, " ++ data)
+
+def mainAsync : Async Unit := do
+  let server ← Server.serve (.v4 (.mk (.ofParts 0 0 0 0) 8080)) handler
+  server.waitShutdown
+
+def main := mainAsync.block
+```
+-/

src/Std/Internal/Http/Data.lean

@@ -0,0 +1,17 @@
+/-
+Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Sofia Rodrigues
+-/
+module
+
+prelude
+public import Std.Internal.Http.Data.Body
+public import Std.Internal.Http.Data.Headers
+public import Std.Internal.Http.Data.Method
+public import Std.Internal.Http.Data.Version
+public import Std.Internal.Http.Data.Request
+public import Std.Internal.Http.Data.Response
+public import Std.Internal.Http.Data.URI
+public import Std.Internal.Http.Data.Status
+public import Std.Internal.Http.Data.Version

src/Std/Internal/Http/Data/Body.lean

@@ -0,0 +1,109 @@
+/-
+Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Sofia Rodrigues
+-/
+module
+
+prelude
+public import Std.Internal.Async.Context
+public import Std.Internal.Http.Data.Body.Length
+public import Std.Internal.Http.Data.Body.ByteStream
+
+public section
+
+/-!
+# Body
+
+This module defines the `Body` type, which represents the body of an HTTP request or response.
+-/
+
+namespace Std.Http
+
+open Std Internal IO Async
+
+/--
+Type that represents the body of a request or response with streams of byte arrays or byte arrays of fixed
+size.
+-/
+inductive Body where
+  /--
+  Empty body with no content
+  -/
+  | zero
+
+  /--
+  Body containing raw byte data stored in memory
+  -/
+  | bytes (data : ByteArray)
+
+  /--
+  Body containing streaming data from a byte stream channel
+  -/
+  | stream (channel : Body.ByteStream)
+deriving Inhabited
+
+namespace Body
+
+/--
+Get content length of a body (if known).
+-/
+def getContentLength (body : Body) : Length :=
+  match body with
+  | zero => .fixed 0
+  | .bytes data => .fixed data.size
+  | .stream _ => .chunked
+
+/--
+Close the body and release any associated resources. For streaming bodies, this closes the underlying
+channel. For other body types, this is a no-op.
+-/
+def close (body : Body) : Async Unit :=
+  match body with
+  | .stream channel => channel.close
+  | _ => pure ()
+
+instance : Coe String Body where
+  coe := .bytes ∘ String.toUTF8
+
+instance : Coe ByteArray Body where
+  coe := .bytes
+
+instance : Coe Body.ByteStream Body where
+  coe := .stream
+
+instance : EmptyCollection Body where
+  emptyCollection := Body.zero
+
+instance : ForIn Async Body Chunk where
+  forIn body acc step :=
+    match body with
+    | .zero => pure acc
+    | .bytes data => return (← step (Chunk.mk data #[]) acc).value
+    | .stream stream' => ByteStream.forIn stream' acc step
+
+instance : ForIn ContextAsync Body Chunk where
+  forIn body acc step :=
+    match body with
+    | .zero => pure acc
+    | .bytes data => return (← step (Chunk.mk data #[]) acc).value
+    | .stream stream' => ByteStream.forIn' stream' acc step
+
+/--
+Collect all data from the body into a single `ByteArray`. This reads the entire body content into memory
+and consumes significant memory for large bodies.
+-/
+def collectByteArray (body : Body) : Async ByteArray := do
+  let mut result := .empty
+  for x in body do result := result ++ x.data
+  return result
+
+/--
+Collect all data from the body into a single `String`. This reads the entire body content into memory
+and consumes significant memory for large bodies. Returns `some` if the data is valid UTF-8, otherwise
+`none`.
+-/
+def collectString (body : Body) : Async (Option String) := do
+  let mut result := .empty
+  for x in body do result := result ++ x.data
+  return String.fromUTF8? result