Std.App

32 public declarations

• App

  The program: what it is called, what it was told, what it serves, what has

  type
• AppError

  Why a program could not run.

  type
• configOf&Std.App.App -> Std.App.Config.Config

  What the application was told.

  fn
• explain&Std.App.AppError -> Str

  What a refusal says.

  fn
• explainReport&Std.App.Report -> Str

  What went wrong, as text.

  fn
• LifecycleReport

  Successful callbacks and every typed failure, in occurrence order.

  type
• measuring&Std.App.App -> Std.Sync.Cell[Std.App.Metrics.Metrics] -> Str -> Std.App.App

  The application measuring its own traffic into a cell the program holds,

  fn
• nameOf&Std.App.App -> Str

  What the application is called.

  fn
• onceStr -> fn() -> Result[(), Str] -> Std.App.Stage.Stage

  A stage that has something to start and nothing to undo.

  fn
• overStr -> &Std.App.Config.Config -> &Std.Http.Server.Route.Router -> Std.App.App

  An application over settings the caller already has, for a program whose

  fn
• Report

  What a start or a stop did.

  type
• reporting&Std.App.App -> Str -> Str -> &Array[Std.App.Health.Liveness] -> &Array[Std.App.Health.Readiness] -> Std.App.Health.Reading -> Std.App.App

  The application answering what it is asked about itself.

  fn
• requestMeasurementsStd.App.Metrics.Metrics

  Measurements a service takes of itself, declared and ready to be added to.

  fn
• routerOf&Std.App.App -> Std.Http.Server.Route.Router

  What the application serves.

  fn
• run&Std.App.App -> Result[Int, Std.App.AppError]

  Start everything, serve until the work is finished, then stop everything.

  fn
• serveStr -> &Std.Http.Server.Route.Router -> Result[Int, Std.App.AppError]

  A name and a router, and a service is running.

  fn
• serving&Std.App.App -> &Std.Http.Server.Route.Router -> Std.App.App

  An application with different routes.

  fn
• sharing&Std.App.App -> &Array[Str] -> Std.App.App

  The application, permitting the named origins to read its answers.

  fn
• stageStr -> fn() -> Result[(), Str] -> fn() -> Result[(), Str] -> Std.App.Stage.Stage

  A stage from its two halves.

  fn
• Stage

  One thing that starts and later stops.

  type
• stageNames&Std.App.App -> Array[Str]

  The names of the stages, in start order, for a program reporting itself.

  fn
• stagesOf&Std.App.App -> Array[Std.App.Stage.Stage]

  What has to be running before it serves, in the order it starts.

  fn
• start&Std.App.App -> Std.App.Report

  Start every stage in order.

  fn
• startDetailed&Std.App.App -> Std.App.LifecycleReport

  Start in declaration order and retain failures from unwinding the started prefix.

  fn
• steppedBy&Std.App.App -> &Array[fn(Std.Http.Server.Route.Request, fn(Std.Http.Server.Route.Request) -> Std.Http.Response) -> Std.Http.Response] -> Std.App.App

  The application with steps a program chose instead of the usual ones.

  fn
• stepsOf&Std.App.App -> Array[fn(Std.Http.Server.Route.Request, fn(Std.Http.Server.Route.Request) -> Std.Http.Response) -> Std.Http.Response]

  The steps wrapped around this application's handlers.

  fn
• stop&Std.App.App -> Std.App.Report

  Stop every stage in reverse and summarize all failures.

  fn
• stopDetailed&Std.App.App -> Std.App.LifecycleReport

  Stop every stage in reverse, retaining each failure separately.

  fn
• succeeded&Std.App.Report -> Bool

  Whether a report says everything worked.

  fn
• using&Std.App.App -> Std.App.Stage.Stage -> Std.App.App

  An application with one more thing to start.

  fn
• webStr -> &Std.Http.Server.Route.Router -> Result[Std.App.App, Std.App.AppError]

  The same application, built and not run.

  fn
• wrapping&Std.App.App -> fn(Std.Http.Server.Route.Request, fn(Std.Http.Server.Route.Request) -> Std.Http.Response) -> Std.Http.Response -> Std.App.App

  The application with one more step around every handler, outside the ones

  fn