Results for “Result”

200 matching declarations

Use module:Std.List, kind:fn, or is:exact. Put a Pudu type after ::.

Std.Result.all&Array[Result[T, E]] -> Result[Array[T], E]
Every success, or the first failure.
fn · Std.Result
Std.Result.andThenResult[T, E] -> fn(T) -> Result[U, E] -> Result[U, E]
The success transformed into another result, flattened.
fn · Std.Result
Std.Result.errResult[T, E] -> Option[E]
The failure if there was one.
fn · Std.Result
Std.Result.errOrResult[T, E] -> E -> E
The failure, or a fallback when the operation succeeded.
fn · Std.Result
Std.Result.failures&Array[Result[T, E]] -> Array[E]
Every failure, with the successes dropped.
fn · Std.Result
Std.Result.flattenResult[Result[T, E], E] -> Result[T, E]
A nested result flattened by one level.
fn · Std.Result
Std.Result.foldResult[T, E] -> fn(T) -> A -> fn(E) -> A -> A
One of two transformations, whichever side the result holds.
fn · Std.Result
Std.Result.holds&Result[T, E] -> fn(T) -> Bool -> Bool
Whether the operation succeeded and the predicate accepts the value.
fn · Std.Result
Std.Result.isErr&Result[T, E] -> Bool
Whether the operation failed.
fn · Std.Result
Std.Result.isOk&Result[T, E] -> Bool
Whether the operation succeeded.
fn · Std.Result
Std.Result.mapResult[T, E] -> fn(T) -> U -> Result[U, E]
The success transformed, if there was one.
fn · Std.Result
Std.Result.map2Result[T, E] -> Result[U, E] -> fn(T, U) -> V -> Result[V, E]
Both successes combined, or the first failure.
fn · Std.Result
Std.Result.mapErrResult[T, E] -> fn(E) -> F -> Result[T, F]
The failure transformed, if there was one.
fn · Std.Result
Std.Result.okResult[T, E] -> Option[T]
The value if there is one, forgetting why there was not.
fn · Std.Result
Std.Result.orElseResult[T, E] -> Result[T, E] -> Result[T, E]
The first result if it succeeded, otherwise the second.
fn · Std.Result
Std.Result.partition&Array[Result[T, E]] -> (Array[T], Array[E])
The two sides separated: every success, and every failure.
fn · Std.Result
Std.Result.requireBool -> E -> Result[(), E]
A success when a condition holds, and a named failure otherwise.
fn · Std.Result
Std.Result.successes&Array[Result[T, E]] -> Array[T]
Every success, with the failures dropped.
fn · Std.Result
Std.Result.swapResult[T, E] -> Result[E, T]
The sides exchanged, so a failure becomes a success and back.
fn · Std.Result
Std.Result.toArrayResult[T, E] -> Array[T]
The value as an array of nought or one element.
fn · Std.Result
Std.Result.toOptionResult[T, E] -> Option[T]
The success, or `None` when there was a failure, keeping neither.
fn · Std.Result
Std.Result.traverse&Array[A] -> fn(A) -> Result[B, E] -> Result[Array[B], E]
Every result transformed and collected, stopping at the first failure.
fn · Std.Result
Std.Result.unwrapOrResult[T, E] -> T -> T
The value, or a fallback when the operation failed.
fn · Std.Result
Std.Result.unwrapOrElseResult[T, E] -> fn(E) -> T -> T
The success, or a fallback computed from the failure.
fn · Std.Result
Std.Show.result&Result[T, E] -> Str
A result rendered as its success or its failure, with a marker for which.
fn · Std.Show
Std.Concurrent.mapResultBounded&Array[T] -> Int -> fn(T) -> Result[U, E] -> Result[Result[Array[U], E], Std.Concurrent.ConcurrentError]
Apply a fallible transform with bounded concurrency, returning the first error in input order.
fn · Std.Concurrent
Std.RateLimiter.AcquireResult
Result of an acquisition attempt containing the updated limiter and success status.
type · Std.RateLimiter
Std.RingBuffer.PopResult
The result of a successful pop operation containing the updated buffer and the dequeued item.
type · Std.RingBuffer
Std.Tree.mapResult&Std.Tree.Tree[A] -> fn(A) -> Result[B, E] -> Result[Std.Tree.Tree[B], E]
Every value transformed, keeping the shape, where transforming may fail.
fn · Std.Tree
Std.Tree.sequenceResult&Std.Tree.Tree[Result[T, E]] -> Result[Std.Tree.Tree[T], E]
A tree of results turned into a result holding a tree.
fn · Std.Tree
Std.Tree.unfoldResultS -> fn(S) -> Result[(T, Array[S]), E] -> Result[Std.Tree.Tree[T], E]
A tree grown from a starting value, where growing may fail.
fn · Std.Tree
Std.Varint.SignedVarintDecodeResult
Decoded signed 64-bit varint value and the number of bytes consumed.
type · Std.Varint
Std.Varint.VarintDecodeResult
Decoded unsigned 64-bit varint value and the number of bytes consumed.
type · Std.Varint
Std.App.Bind.binding&Std.Http.Server.Route.Request -> &Array[Std.App.Bind.Wanted] -> Result[Std.App.Bind.Bound, Std.Http.Response]
The bound values, or the refusal, in one step for the common handler.
fn · Std.App.Bind
Std.App.Config.discover&Array[(Str, Str)] -> Str -> Result[Std.App.Config.Config, Std.App.Config.ConfigError]
The configuration a program gets when it does not say otherwise: its own
fn · Std.App.Config
Std.App.Config.fractional&Std.App.Config.Config -> Str -> Result[Decimal, Std.App.Config.ConfigError]
A setting as an exact fractional number.
fn · Std.App.Config
Std.App.Config.list&Std.App.Config.Config -> Str -> Result[Array[Str], Std.App.Config.ConfigError]
A setting as a list, written separated by commas.
fn · Std.App.Config
Std.App.Config.require&Std.App.Config.Config -> Str -> Result[Str, Std.App.Config.ConfigError]
A setting that must be there, for one the program cannot invent.
fn · Std.App.Config
Std.App.Config.text&Std.App.Config.Config -> Str -> Result[Str, Std.App.Config.ConfigError]
A setting as text.
fn · Std.App.Config
Std.App.Config.truth&Std.App.Config.Config -> Str -> Result[Bool, Std.App.Config.ConfigError]
A setting as a truth.
fn · Std.App.Config
Std.App.Config.whole&Std.App.Config.Config -> Str -> Result[Int, Std.App.Config.ConfigError]
A setting as a whole number.
fn · Std.App.Config
Std.App.Database.createStr -> Int -> Result[Std.App.Database.Database, Std.Db.Driver.Error]
Select a bundled connector from the connection-string scheme.
fn · Std.App.Database
Std.App.Database.execute&Std.App.Database.Database -> Str -> Result[Std.Db.Driver.Rows, Std.Db.Driver.Error]
Run a statement that carries no values.
fn · Std.App.Database
Std.App.Database.fromConfig&Std.App.Config.Config -> Str -> Int -> Result[Std.App.Database.Database, Std.Db.Driver.Error]
Prepare a database from the connection string a setting names.
fn · Std.App.Database
Std.App.Database.fromConfigWithStd.Db.Driver.Driver -> &Std.App.Config.Config -> Str -> Int -> Result[Std.App.Database.Database, Std.Db.Driver.Error]
Prepare a database from a setting, using the given driver.
fn · Std.App.Database
Std.App.Database.migrate&Std.App.Database.Database -> &Array[Std.Db.Migrate.Migration] -> Result[Int, Std.Db.Migrate.MigrationError]
Bring the schema to what the program holds, through this database's driver.
fn · Std.App.Database
Std.App.Database.query&Std.App.Database.Database -> Str -> &Array[Std.Db.Driver.Value] -> Result[Std.Db.Driver.Rows, Std.Db.Driver.Error]
SQL and placeholders follow the selected driver; values are always separate.
fn · Std.App.Database
Std.App.Database.queryAll&Std.App.Database.Database -> Str -> &Array[Std.Db.Driver.Value] -> fn(Std.Db.Driver.Rows, Int) -> Result[T, Std.Db.Row.RowError] -> Result[Array[T], Std.App.Database.QueryError]
Every row a query answered, each read by the mapper.
fn · Std.App.Database
Std.App.Database.queryOne&Std.App.Database.Database -> Str -> &Array[Std.Db.Driver.Value] -> fn(Std.Db.Driver.Rows, Int) -> Result[T, Std.Db.Row.RowError] -> Result[T, Std.App.Database.QueryError]
The single row a query answered, or an error when it answered none or several.
fn · Std.App.Database
Std.App.Database.queryOptional&Std.App.Database.Database -> Str -> &Array[Std.Db.Driver.Value] -> fn(Std.Db.Driver.Rows, Int) -> Result[T, Std.Db.Row.RowError] -> Result[Option[T], Std.App.Database.QueryError]
The one row a query answered, or nothing.
fn · Std.App.Database
Std.App.Database.start&Std.App.Database.Database -> Result[(), Std.Db.Driver.Error]
Open the connections. Called by the stage rather than by a caller.
fn · Std.App.Database
Std.App.Database.stop&Std.App.Database.Database -> Result[(), Std.Db.Driver.Error]
Clear admission before closing; repeated stops are harmless.
fn · Std.App.Database
Std.App.Database.storeTarget&Std.App.Database.Database -> Result[Std.Db.Store.Target, Std.Db.Driver.Error]
This database as a store reads and writes it. A database that is not
fn · Std.App.Database
Std.App.Database.transaction&Std.App.Database.Database -> fn(Std.Db.Driver.Tx) -> Result[Std.Db.Driver.Rows, Std.Db.Driver.Error] -> Result[Std.Db.Driver.Rows, Std.Db.Driver.Error]
The selected driver owns the connection for the complete action.
fn · Std.App.Database
Std.App.Database.withDriverStd.Db.Driver.Driver -> Str -> Int -> Result[Std.App.Database.Database, Std.Db.Driver.Error]
Prepare any developer-supplied connector; sockets open during stage startup.
fn · Std.App.Database
Std.App.Database.withDrivers&Array[Std.Db.Driver.Driver] -> Str -> Int -> Result[Std.App.Database.Database, Std.Db.Driver.Error]
Select a connector from an explicit set, without a process-global registry.
fn · Std.App.Database
Std.App.Jwt.decodeStr -> &Bytes -> &Std.App.Jwt.JwtValidation -> Int -> Result[Std.App.Jwt.JwtClaims, Std.App.Jwt.JwtError]
Decodes and cryptographically verifies an RFC 7519 compact JWT against secret and validation rules.
fn · Std.App.Jwt
Std.App.Jwt.decodeUnverifiedStr -> Result[Std.App.Jwt.JwtClaims, Std.App.Jwt.JwtError]
Decodes claims without cryptographic signature verification.
fn · Std.App.Jwt
Std.App.Jwt.decodeWithKeyStr -> &Std.App.Jwt.PublicKey -> &Std.App.Jwt.JwtValidation -> Int -> Result[Std.App.Jwt.JwtClaims, Std.App.Jwt.JwtError]
Verify a token signed with a provider's private key, and read its claims.
fn · Std.App.Jwt
Std.App.Otlp.send&Std.App.Otlp.Exporter -> &Array[Std.App.Trace.Span] -> Result[Int, Std.App.Otlp.ExportError]
Send finished spans to the collector.
fn · Std.App.Otlp
Std.App.Password.parseStr -> Result[Std.App.Password.Stored, Std.App.Password.PasswordError]
A stored form read back from that text.
fn · Std.App.Password
Std.App.Password.storeStr -> Result[Std.App.Password.Stored, Std.App.Password.PasswordError]
A password in the form that proves it later without holding it.
fn · Std.App.Password
Std.App.Session.anonymousInt -> Result[Std.App.Session.Session, Std.App.Session.SessionError]
A session belonging to nobody in particular.
fn · Std.App.Session
Std.App.Session.signedIn&Std.App.Session.Session -> Str -> Int -> Result[Std.App.Session.Session, Std.App.Session.SessionError]
The session somebody has after signing in.
fn · Std.App.Session
Std.App.Session.signedOut&Std.App.Session.Session -> Int -> Result[Std.App.Session.Session, Std.App.Session.SessionError]
The session somebody has after signing out.
fn · Std.App.Session
Std.App.Session.startedStr -> Int -> Result[Std.App.Session.Session, Std.App.Session.SessionError]
A session for somebody who has just proved who they are, with nothing
fn · Std.App.Session
Std.App.Stage.createStr -> fn() -> Result[(), Str] -> fn() -> Result[(), Str] -> Std.App.Stage.Stage
A stage from its name and the two actions.
fn · Std.App.Stage
Std.App.Totp.decodeBase32Str -> Result[Bytes, Str]
RFC 4648 Base32 decoder with whitespace stripping and case normalization.
fn · Std.App.Totp
Std.App.Work.jobStr -> Std.App.Work.Due -> fn() -> Result[(), Str] -> Std.App.Work.Job
A job from its parts.
fn · Std.App.Work
Std.App.onceStr -> fn() -> Result[(), Str] -> Std.App.Stage.Stage
A stage that has something to start and nothing to undo.
fn · Std.App
Std.App.run&Std.App.App -> Result[Int, Std.App.AppError]
Start everything, serve until the work is finished, then stop everything.
fn · Std.App
Std.App.serveStr -> &Std.Http.Server.Route.Router -> Result[Int, Std.App.AppError]
A name and a router, and a service is running.
fn · Std.App
Std.App.stageStr -> fn() -> Result[(), Str] -> fn() -> Result[(), Str] -> Std.App.Stage.Stage
A stage from its two halves.
fn · Std.App
Std.App.webStr -> &Std.Http.Server.Route.Router -> Result[Std.App.App, Std.App.AppError]
The same application, built and not run.
fn · Std.App
Std.Archive.Tar.readArchive&Bytes -> Result[Array[Std.Archive.Tar.TarEntry], Std.Archive.Tar.TarError]
Decodes all TarEntries from a POSIX USTAR archive byte stream.
fn · Std.Archive.Tar
Std.Archive.Zip.readArchive&Bytes -> Result[Array[Std.Archive.Zip.Entry], Std.Archive.Zip.ZipError]
Read an archive.
fn · Std.Archive.Zip
Std.Archive.Zip.writeArchive&Array[Std.Archive.Zip.Entry] -> Result[Bytes, Std.Archive.Zip.ZipError]
Write an archive.
fn · Std.Archive.Zip
Std.Args.fromCommandLine&Std.Args.Spec -> Result[Std.Args.Args, Std.Args.ArgsError]
Read the command line this program was given.
fn · Std.Args
Std.Args.numberChecked&Std.Args.Args -> Str -> Result[Option[Int], Std.Args.ArgsError]
The value an option was given as a number, refusing text that is not one.
fn · Std.Args
Std.Args.parse&Std.Args.Spec -> &Array[Str] -> Result[Std.Args.Args, Std.Args.ArgsError]
Read arguments against a spec, in one pass.
fn · Std.Args
Std.Audio.Device.closeStream&Std.Audio.Device.Stream -> Bool -> Int -> Result[(), Std.Audio.Device.DeviceError]
Release the stream exactly once, optionally sounding every queued frame.
fn · Std.Audio.Device
Std.Audio.Device.openStream&Std.Audio.Device.StreamPlan -> Result[Std.Audio.Device.Stream, Std.Audio.Device.DeviceError]
Open the default output and return the format accepted by its queue.
fn · Std.Audio.Device
Std.Audio.Device.pause&Std.Audio.Device.Stream -> Result[(), Std.Audio.Device.DeviceError]
Stop consuming queued frames while keeping them and the stream's position.
fn · Std.Audio.Device
Std.Audio.Device.planInt -> Int -> Int -> Result[Std.Audio.Device.Plan, Std.Audio.Device.DeviceError]
Admit two to eight preallocated buffers of 16 through 4,096 frames each.
fn · Std.Audio.Device
Std.Audio.Device.play&Std.Audio.Device.Plan -> &Std.Audio.Pcm -> Result[Std.Audio.Device.Playback, Std.Audio.Device.DeviceError]
Play one admitted interleaved signed-16 clip and await exact completion.
fn · Std.Audio.Device
Std.Audio.Device.resume&Std.Audio.Device.Stream -> Result[(), Std.Audio.Device.DeviceError]
Continue consuming queued frames from where a pause left them.
fn · Std.Audio.Device
Std.Audio.Device.setVolume&Std.Audio.Device.Stream -> Float64 -> Result[(), Std.Audio.Device.DeviceError]
Set linear output volume from silence through unity.
fn · Std.Audio.Device
Std.Audio.Device.snapshot&Std.Audio.Device.Stream -> Result[Std.Audio.Device.StreamSnapshot, Std.Audio.Device.DeviceError]
Read one coherent telemetry sample and audio-master clock.
fn · Std.Audio.Device
Std.Audio.Device.streamPlanStd.Audio.Format -> Int -> Int -> Int -> Result[Std.Audio.Device.StreamPlan, Std.Audio.Device.DeviceError]
Admit a persistent stream request before touching a device.
fn · Std.Audio.Device
Std.Audio.Device.write&Std.Audio.Device.Stream -> &Std.Audio.Pcm -> Result[Int, Std.Audio.Device.DeviceError]
Enqueue one exact PCM chunk with bounded backpressure.
fn · Std.Audio.Device
Std.Audio.Graph.render&Std.Audio.Graph.Node -> &Std.Audio.Format -> Int -> Int -> Result[Std.Audio.Pcm, Std.Audio.Graph.GraphError]
Exactly `frames` frames of a graph starting at frame `start`.
fn · Std.Audio.Graph
Std.Audio.append&Std.Audio.Pcm -> &Std.Audio.Pcm -> Result[Std.Audio.Pcm, Std.Audio.AudioError]
One stream followed by another of the same format.
fn · Std.Audio
Std.Audio.decodeWav&Bytes -> Result[Std.Audio.Pcm, Std.Audio.AudioError]
Audio from a 16-bit PCM WAV document, within the default sample budget.
fn · Std.Audio
Std.Audio.decodeWavWithin&Bytes -> Int -> Result[Std.Audio.Pcm, Std.Audio.AudioError]
Audio from a 16-bit PCM WAV document holding at most `maxSamples` samples.
fn · Std.Audio
Std.Audio.downmix&Std.Audio.Pcm -> Result[Std.Audio.Pcm, Std.Audio.AudioError]
Mono audio averaging every channel of each frame, rounded half away from zero.
fn · Std.Audio
Std.Audio.encodeWav&Std.Audio.Pcm -> Result[Bytes, Std.Audio.AudioError]
A canonical 16-bit PCM WAV document.
fn · Std.Audio
Std.Audio.formatInt -> Int -> Result[Std.Audio.Format, Std.Audio.AudioError]
A format with a sample rate from 8,000 to 384,000 and one to eight channels.
fn · Std.Audio
Std.Audio.framesAt&Std.Audio.Format -> Int -> Int -> Result[Int, Std.Audio.AudioError]
The frame at a time given in seconds as a fraction, rounded down.
fn · Std.Audio
Std.Audio.fromSamples&Std.Audio.Format -> Array[Int] -> Result[Std.Audio.Pcm, Std.Audio.AudioError]
Audio from interleaved samples, refusing a partial frame or a sample that
fn · Std.Audio
Std.Audio.gain&Std.Audio.Pcm -> Int -> Result[Std.Audio.Pcm, Std.Audio.AudioError]
Audio scaled by a Q15 gain, where 32,768 is unity.
fn · Std.Audio
Std.Audio.mix&Std.Audio.Pcm -> &Std.Audio.Pcm -> Result[Std.Audio.Pcm, Std.Audio.AudioError]
Two streams summed sample by sample, saturating to 16 bits.
fn · Std.Audio
Std.Audio.remap&Std.Audio.Pcm -> &Array[Int] -> Result[Std.Audio.Pcm, Std.Audio.AudioError]
Audio whose channel `k` is the source's channel `order[k]`, so channels are
fn · Std.Audio
Std.Audio.resample&Std.Audio.Pcm -> Int -> Result[Std.Audio.Pcm, Std.Audio.AudioError]
Audio at another sample rate by linear interpolation in exact arithmetic.
fn · Std.Audio
Std.Audio.seconds&Std.Audio.Format -> Int -> Result[Std.Audio.Seconds, Std.Audio.AudioError]
The exact duration of a number of frames, as a reduced fraction of a second.
fn · Std.Audio
Std.Audio.silence&Std.Audio.Format -> Int -> Result[Std.Audio.Pcm, Std.Audio.AudioError]
Silent audio of a whole number of frames.
fn · Std.Audio
Std.Audio.slice&Std.Audio.Pcm -> Int -> Int -> Result[Std.Audio.Pcm, Std.Audio.AudioError]
Exactly `frames` frames starting at `start`, silent past the end.
fn · Std.Audio
Std.Audio.upmix&Std.Audio.Pcm -> Int -> Result[Std.Audio.Pcm, Std.Audio.AudioError]
Mono audio copied into every channel of a wider format.
fn · Std.Audio
Std.BitSet.fromBlocks&Map[UInt64, UInt64] -> Result[Std.BitSet.BitSet, UInt64]
Validate block addresses and omit empty blocks.
fn · Std.BitSet
Std.Bytes.Cursor.peek&Std.Bytes.Cursor.Cursor -> Result[Option[UInt8], Std.Bytes.Cursor.CursorError]
Observe the next byte without consuming it; EOF is `None`.
fn · Std.Bytes.Cursor
Std.Bytes.Cursor.remaining&Std.Bytes.Cursor.Cursor -> Result[Int, Std.Bytes.Cursor.CursorError]
Validate the cursor before subtracting its position from the input length.
fn · Std.Bytes.Cursor
Std.Bytes.Cursor.seek&Std.Bytes.Cursor.Cursor -> Int -> Result[Std.Bytes.Cursor.Cursor, Std.Bytes.Cursor.CursorError]
Move to an absolute byte position, including the end of input.
fn · Std.Bytes.Cursor
Std.Bytes.Cursor.skip&Std.Bytes.Cursor.Cursor -> Int -> Result[Std.Bytes.Cursor.Cursor, Std.Bytes.Cursor.CursorError]
Skip bytes using the same bounds contract as a read.
fn · Std.Bytes.Cursor
Std.Bytes.Cursor.take&Std.Bytes.Cursor.Cursor -> Int -> Result[(Bytes, Std.Bytes.Cursor.Cursor), Std.Bytes.Cursor.CursorError]
Read a shared view. A failed read leaves the original cursor usable.
fn · Std.Bytes.Cursor
Std.Bytes.Cursor.u16Be&Std.Bytes.Cursor.Cursor -> Result[(UInt16, Std.Bytes.Cursor.Cursor), Std.Bytes.Cursor.CursorError]
Read an unsigned integer in the byte order named by the function.
fn · Std.Bytes.Cursor
Std.Bytes.Cursor.u16Le&Std.Bytes.Cursor.Cursor -> Result[(UInt16, Std.Bytes.Cursor.Cursor), Std.Bytes.Cursor.CursorError]
The next two bytes as an unsigned number, least significant first.
fn · Std.Bytes.Cursor
Std.Bytes.Cursor.u32Be&Std.Bytes.Cursor.Cursor -> Result[(UInt32, Std.Bytes.Cursor.Cursor), Std.Bytes.Cursor.CursorError]
The next four bytes as an unsigned number, most significant first.
fn · Std.Bytes.Cursor
Std.Bytes.Cursor.u32Le&Std.Bytes.Cursor.Cursor -> Result[(UInt32, Std.Bytes.Cursor.Cursor), Std.Bytes.Cursor.CursorError]
The next four bytes as an unsigned number, least significant first.
fn · Std.Bytes.Cursor
Std.Bytes.Cursor.u64Be&Std.Bytes.Cursor.Cursor -> Result[(UInt64, Std.Bytes.Cursor.Cursor), Std.Bytes.Cursor.CursorError]
The next eight bytes as an unsigned number, most significant first.
fn · Std.Bytes.Cursor
Std.Bytes.Cursor.u64Le&Std.Bytes.Cursor.Cursor -> Result[(UInt64, Std.Bytes.Cursor.Cursor), Std.Bytes.Cursor.CursorError]
The next eight bytes as an unsigned number, least significant first.
fn · Std.Bytes.Cursor
Std.Bytes.Cursor.u8&Std.Bytes.Cursor.Cursor -> Result[(UInt8, Std.Bytes.Cursor.Cursor), Std.Bytes.Cursor.CursorError]
Read one octet without converting it through text.
fn · Std.Bytes.Cursor
Std.Bytes.decodeBase64Str -> Result[Bytes, Std.Bytes.BytesError]
The bytes base64 text spells, or why it spells none.
fn · Std.Bytes
Std.Bytes.decodeBase64UrlStr -> Result[Bytes, Std.Bytes.BytesError]
The bytes URL-alphabet base64 spells, padded or not.
fn · Std.Bytes
Std.Bytes.decodeHexStr -> Result[Bytes, Std.Bytes.BytesError]
The bytes hexadecimal text spells, or why it spells none.
fn · Std.Bytes
Std.Bytes.getBytes&Bytes -> Int -> Result[(Bytes, Bytes), Std.Bytes.BytesError]
The next bytes as their own sequence, and the rest of the input.
fn · Std.Bytes
Std.Bytes.getText&Bytes -> Int -> Result[(Str, Bytes), Std.Bytes.BytesError]
The next bytes decoded as text, and the rest of the input.
fn · Std.Bytes
Std.Bytes.getU16Be&Bytes -> Result[(UInt16, Bytes), Std.Bytes.BytesError]
Two bytes as a number, most significant first, and the rest of the input.
fn · Std.Bytes
Std.Bytes.getU16Le&Bytes -> Result[(UInt16, Bytes), Std.Bytes.BytesError]
Two bytes as a number, least significant first, and the rest of the input.
fn · Std.Bytes
Std.Bytes.getU32Be&Bytes -> Result[(UInt32, Bytes), Std.Bytes.BytesError]
Four bytes as a number, most significant first, and the rest of the input.
fn · Std.Bytes
Std.Bytes.getU32Le&Bytes -> Result[(UInt32, Bytes), Std.Bytes.BytesError]
Four bytes as a number, least significant first, and the rest of the input.
fn · Std.Bytes
Std.Bytes.getU64Be&Bytes -> Result[(UInt64, Bytes), Std.Bytes.BytesError]
Eight bytes as a number, most significant first, and the rest of the input.
fn · Std.Bytes
Std.Bytes.getU64Le&Bytes -> Result[(UInt64, Bytes), Std.Bytes.BytesError]
Eight bytes as a number, least significant first, and the rest of the input.
fn · Std.Bytes
Std.Bytes.getU8&Bytes -> Result[(UInt8, Bytes), Std.Bytes.BytesError]
One byte, and the rest of the input.
fn · Std.Bytes
Std.Bytes.toText&Bytes -> Result[Str, Std.Bytes.BytesError]
The text a sequence encodes, or the reason it is not text.
fn · Std.Bytes
Std.Channel.close&Std.Channel.Channel[T] -> Result[(), Std.Channel.ChannelError]
Say that nothing more will be sent, so every receiver's loop can end.
fn · Std.Channel
Std.Channel.drain&Std.Channel.Channel[T] -> Result[Array[T], Std.Channel.ChannelError]
Every value still to come, in the order it was sent.
fn · Std.Channel
Std.Channel.fold&Std.Channel.Channel[T] -> A -> fn(A, T) -> A -> Result[A, Std.Channel.ChannelError]
Take values until the channel closes, combining them into one value.
fn · Std.Channel
Std.Channel.pending&Std.Channel.Channel[T] -> Result[Int, Std.Channel.ChannelError]
How many values are waiting.
fn · Std.Channel
Std.Channel.receive&Std.Channel.Channel[T] -> Result[Option[T], Std.Channel.ChannelError]
Take the next value, waiting while the channel is empty.
fn · Std.Channel
Std.Channel.send&Std.Channel.Channel[T] -> T -> Result[(), Std.Channel.ChannelError]
Put a value in, waiting while the channel is full.
fn · Std.Channel
Std.Compress.Gzip.compressChecked&Bytes -> &Std.Compress.Gzip.GzipConfig -> Result[Bytes, Std.Compress.Gzip.GzipError]
Compress bytes using the configured zlib level; checked form exposes host failure.
fn · Std.Compress.Gzip
Std.Compress.Gzip.decompress&Bytes -> Result[Bytes, Std.Compress.Gzip.GzipError]
Decode one gzip member with a default 64 MiB decompressed output limit.
fn · Std.Compress.Gzip
Std.Compress.Gzip.decompressText&Bytes -> Result[Str, Std.Compress.Gzip.GzipError]
Decompresses an RFC 1952 GZIP stream and decodes the payload as UTF-8 text.
fn · Std.Compress.Gzip
Std.Compress.Gzip.decompressWithin&Bytes -> Int -> Result[Bytes, Std.Compress.Gzip.GzipError]
Enforce output admission during inflation, including highly compressible inputs.
fn · Std.Compress.Gzip
Std.Concurrent.forEachBounded&Array[T] -> Int -> fn(T) -> () -> Result[(), Std.Concurrent.ConcurrentError]
Apply an action to values with bounded concurrency, without implicit retries.
fn · Std.Concurrent
Std.Concurrent.join&Std.Concurrent.Task -> Result[(), Std.Concurrent.ConcurrentError]
Wait for a thread to finish, and report what it said if it failed.
fn · Std.Concurrent
Std.Concurrent.joinAll&Array[Std.Concurrent.Task] -> Result[(), Std.Concurrent.ConcurrentError]
Wait for every thread, in the order they were started.
fn · Std.Concurrent
Std.Concurrent.mapBounded&Array[T] -> Int -> fn(T) -> U -> Result[Array[U], Std.Concurrent.ConcurrentError]
Map values with bounded concurrency, preserving input order and typed failures.
fn · Std.Concurrent
Std.Concurrent.parallel&Array[fn() -> ()] -> Result[(), Std.Concurrent.ConcurrentError]
Run every action at once and wait for all of them.
fn · Std.Concurrent
Std.Concurrent.parallelBounded&Array[fn() -> ()] -> Int -> Result[(), Std.Concurrent.ConcurrentError]
Run a batch with bounded workers; each action is claimed at most once.
fn · Std.Concurrent
Std.Concurrent.sleepInt -> Result[(), Std.Concurrent.ConcurrentError]
Wait, without holding the machine while waiting.
fn · Std.Concurrent
Std.Concurrent.startfn() -> () -> Result[Std.Concurrent.Task, Std.Concurrent.ConcurrentError]
Start an action on a thread of its own.
fn · Std.Concurrent
Std.Crypto.newKeyResult[Bytes, Str]
A fresh key of the length `seal` needs, from the operating system's secure
fn · Std.Crypto
Std.Crypto.newNonceResult[Bytes, Str]
A fresh nonce of the length `seal` needs, from the same secure source.
fn · Std.Crypto
Std.Csv.foldRowsStr -> T -> fn(T, Array[Str]) -> T -> Result[T, Std.Csv.CsvReadError]
Combine every row of a comma-separated file into one value, holding one
fn · Std.Csv
Std.Csv.foldRowsWithStr -> Str -> T -> fn(T, Array[Str]) -> T -> Result[T, Std.Csv.CsvReadError]
The same, for a file whose fields are separated by something else.
fn · Std.Csv
Std.Csv.parseStr -> Result[Array[Array[Str]], Std.Csv.CsvError]
Every row of a comma-separated text, fields already unquoted.
fn · Std.Csv
Std.Csv.parseTableStr -> Result[Std.Csv.Table, Std.Csv.CsvError]
A table whose first row names its columns.
fn · Std.Csv
Std.Csv.parseWithStr -> Str -> Result[Array[Array[Str]], Std.Csv.CsvError]
The same, for a text whose fields are separated by something else.
fn · Std.Csv
Std.Db.ConnectionString.connectStr -> Result[Std.Db.Session.Connection, Std.Db.Session.DbError]
Open a real PostgreSQL session from a connection URI.
fn · Std.Db.ConnectionString
Std.Db.ConnectionString.parseStr -> Result[Std.Db.Session.Config, Std.Db.Session.DbError]
Parse connection settings without connecting or including secrets in errors.
fn · Std.Db.ConnectionString
Std.Db.ConnectionString.poolStr -> Int -> Result[Std.Db.Pool, Std.Db.Session.DbError]
Open a bounded pool from a connection URI.
fn · Std.Db.ConnectionString
Std.Db.Driver.ask&Std.Db.Driver.Tx -> Str -> &Array[Std.Db.Driver.Value] -> Result[Std.Db.Driver.Rows, Std.Db.Driver.Error]
Ask a transaction's own connection, rather than the pool.
fn · Std.Db.Driver
Std.Db.Driver.close&Std.Db.Driver.Client -> Result[(), Std.Db.Driver.Error]
Close a client and the connections it holds.
fn · Std.Db.Driver
Std.Db.Driver.connect&Array[Std.Db.Driver.Driver] -> Str -> Int -> Result[Std.Db.Driver.Client, Std.Db.Driver.Error]
Open a client for a connection string, using the first driver that knows the scheme.
fn · Std.Db.Driver
Std.Db.Driver.execute&Std.Db.Driver.Client -> Str -> Result[Std.Db.Driver.Rows, Std.Db.Driver.Error]
Run a statement that carries no values.
fn · Std.Db.Driver
Std.Db.Driver.query&Std.Db.Driver.Client -> Str -> &Array[Std.Db.Driver.Value] -> Result[Std.Db.Driver.Rows, Std.Db.Driver.Error]
Run a statement with values bound to its placeholders.
fn · Std.Db.Driver
Std.Db.Driver.run&Std.Db.Driver.Tx -> Str -> Result[Std.Db.Driver.Rows, Std.Db.Driver.Error]
Run a statement on the connection a transaction holds.
fn · Std.Db.Driver
Std.Db.Driver.select&Array[Std.Db.Driver.Driver] -> Str -> Result[Std.Db.Driver.Driver, Std.Db.Driver.Error]
Select exactly one driver without exposing connection-string contents in errors.
fn · Std.Db.Driver
Std.Db.Driver.transaction&Std.Db.Driver.Client -> fn(Std.Db.Driver.Tx) -> Result[Std.Db.Driver.Rows, Std.Db.Driver.Error] -> Result[Std.Db.Driver.Rows, Std.Db.Driver.Error]
Run an action inside a transaction, on one connection, whichever backend
fn · Std.Db.Driver
Std.Db.Migrate.apply&Std.Db.Driver.Client -> &Std.Db.Driver.Driver -> &Array[Std.Db.Migrate.Migration] -> Result[Int, Std.Db.Migrate.MigrationError]
Bring the schema to what the program expects, through any driver.
fn · Std.Db.Migrate
Std.Db.Migrate.migrateStd.Db.Session.Connection -> &Array[Std.Db.Migrate.Migration] -> Result[(Int, Std.Db.Session.Connection), Std.Db.Migrate.MigrationError]
Bring the schema to what the program expects, on one PostgreSQL session.
fn · Std.Db.Migrate
Std.Db.Migrate.plan&Array[Std.Db.Migrate.Migration] -> &Array[Std.Db.Migrate.Applied] -> Result[Std.Db.Migrate.Plan, Std.Db.Migrate.MigrationError]
What should happen next, decided without a database.
fn · Std.Db.Migrate
Std.Db.Migrate.recordOfStd.Db.Session.Connection -> Result[(Array[Std.Db.Migrate.Applied], Std.Db.Session.Connection), Std.Db.Session.DbError]
The record a database holds.
fn · Std.Db.Migrate
Std.Db.Postgres.connectStr -> Int -> Result[Std.Db.Driver.Client, Std.Db.Driver.Error]
Open a client on a PostgreSQL connection string.
fn · Std.Db.Postgres
Std.Db.Protocol.authenticationKind&Bytes -> Result[Int, Std.Db.Protocol.ProtocolError]
What kind of authentication the server asked for, read from the message
fn · Std.Db.Protocol
Std.Db.Protocol.messageSize&Bytes -> Result[Int, Std.Db.Protocol.ProtocolError]
Validate the length before a streaming reader allocates or requests a body.
fn · Std.Db.Protocol
Std.Db.Protocol.readCString&Bytes -> Result[(Str, Bytes), Std.Db.Protocol.ProtocolError]
The text at the front of a payload, and what follows it.
fn · Std.Db.Protocol
Std.Db.Protocol.readDataRow&Bytes -> Result[Array[Option[Str]], Std.Db.Protocol.ProtocolError]
SQL NULL has one explicit sentinel; invalid or truncated text is not absent.
fn · Std.Db.Protocol
Std.Db.Protocol.readMessage&Bytes -> Result[(Std.Db.Protocol.Message, Bytes), Std.Db.Protocol.ProtocolError]
Read one complete message, preserving any following frames.
fn · Std.Db.Protocol
Std.Db.Protocol.readRowDescription&Bytes -> Result[Array[Std.Db.Protocol.Column], Std.Db.Protocol.ProtocolError]
The columns a row description names.
fn · Std.Db.Protocol
Std.Db.Query.Shape.qualifiedNameStr -> Result[Str, Std.Db.Query.QueryError]
A name that may carry the table it belongs to.
fn · Std.Db.Query.Shape
Std.Db.Query.Shape.select&Std.Db.Query.Shape.Select -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
A whole query as a statement, or the first thing wrong with it.
fn · Std.Db.Query.Shape
Std.Db.Query.also&Std.Db.Query.Statement -> Str -> Str -> Std.Db.Driver.Value -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
A further condition that must also hold.
fn · Std.Db.Query
Std.Db.Query.countingStr -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
How many rows a table holds.
fn · Std.Db.Query
Std.Db.Query.deleteFromStr -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
Rows removed from a table.
fn · Std.Db.Query
Std.Db.Query.either&Std.Db.Query.Statement -> Str -> Str -> Std.Db.Driver.Value -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
A further condition where either may hold.
fn · Std.Db.Query
Std.Db.Query.fromStr -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
Everything from a table.
fn · Std.Db.Query
Std.Db.Query.insertStr -> &Array[Str] -> &Array[Std.Db.Driver.Value] -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
A row added to a table, from the columns and the values that fill them.
fn · Std.Db.Query
Std.Db.Query.matching&Std.Db.Query.Statement -> Str -> Str -> Std.Db.Driver.Value -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
A condition on a column, with the value travelling beside the statement.
fn · Std.Db.Query
Std.Db.Query.matchingMissing&Std.Db.Query.Statement -> Str -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
A condition that a column holds nothing.
fn · Std.Db.Query
Std.Db.Query.matchingOneOf&Std.Db.Query.Statement -> Str -> &Array[Std.Db.Driver.Value] -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
A condition that a column is one of several values.
fn · Std.Db.Query
Std.Db.Query.nameStr -> Result[Str, Std.Db.Query.QueryError]
A name, admitted only when it is one.
fn · Std.Db.Query
Std.Db.Query.oneOfStr -> &Array[Str] -> Result[Str, Std.Db.Query.QueryError]
A name chosen from a list the program wrote.
fn · Std.Db.Query
Std.Db.Query.operatorStr -> Result[Str, Std.Db.Query.QueryError]
An operator, admitted only when it is one.
fn · Std.Db.Query
Std.Db.Query.orderBy&Std.Db.Query.Statement -> Str -> Bool -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
The order rows come back in.
fn · Std.Db.Query
Std.Db.Query.qualifiedNameStr -> Result[Str, Std.Db.Query.QueryError]
A name that may carry the table it belongs to.
fn · Std.Db.Query
Std.Db.Query.returning&Std.Db.Query.Statement -> &Array[Str] -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
A statement that answers with the rows it changed.
fn · Std.Db.Query
Std.Db.Query.selecting&Array[Str] -> Str -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
Named columns from a table.
fn · Std.Db.Query
Std.Db.Query.updateStr -> &Array[Str] -> &Array[Std.Db.Driver.Value] -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
Columns of a table set to new values.
fn · Std.Db.Query
Std.Db.Query.withQueryStr -> &Std.Db.Query.Statement -> &Std.Db.Query.Statement -> Result[Std.Db.Query.Statement, Std.Db.Query.QueryError]
A named result the rest of a statement reads from.
fn · Std.Db.Query