Packages.

Prelude

Primitive types and the common vocabulary shared by the standard libraries.

Data.Option

Values that may be absent, without sentinel values or null.

Data.List

Finite, ordered collections with structural recursion and total projections.

Data.Result

Recoverable errors carried in the result type.

Data.Map

Ordered, persistent key-value maps.

Data.Set

Persistent collections of distinct values.

Data.NonEmpty

Collections whose type guarantees at least one element.

Text.Utf8

Decode, encode, and inspect UTF-8 text.

Text.Parser

Small parsers that compose into larger parsers.

Data.Json

A JSON value tree and its textual representation.

Data.Json.Decode

Convert a JSON value to a specific application type.

Net.Http

Shared HTTP message types.

Net.Http.Client

An HTTP client whose network operations appear in its effect signature.

Control.Task

Tasks whose lifetime is bounded by a surrounding scope.

Control.Channel

Bounded communication with backpressure.

Data.Time

Time values with distinct wall-clock and duration types.

Test.Check

Describe properties and generate input values.

Test.Runner

Group tests and report their results.

NatPrelude

data Nat

An unbounded natural number. Arithmetic on Nat does not overflow.

BoolPrelude

data Bool

A truth value.

IntPrelude

opaque Int

An unbounded signed integer.

StringPrelude

opaque String

An immutable string of Unicode text.

RefPrelude

opaque Ref region a

A reference that borrows a value for the lifetime of region.

UnitPrelude

data Unit

The type with a single value, ().

BytesPrelude

opaque Bytes

An immutable sequence of bytes.

IoPrelude

effect Io region

An effect for interaction with an external environment.

OrdPrelude

signature Ord a

A total ordering on values of a type.

idPrelude

id :: forall a. a -> a

Return the supplied value unchanged.

constPrelude

const :: forall a b. a -> b -> a

Return the first argument and ignore the second.

OptionData.Option

data Option a

Either a present value or its absence.

mapData.Option

map :: forall a b. (a -> b) -> Option a -> Option b

Apply a function to a present value. None remains None.

with-defaultData.Option

with-default :: forall a. a -> Option a -> a

Extract a present value, or return the supplied default.

is-someData.Option

is-some :: forall a. Option a -> Bool

Report whether a value is present.

ListData.List

data List a

A finite sequence of values of the same type.

mapData.List

map :: forall a b. (a -> b) -> List a -> List b

Transform each element, retaining the order of the input.

foldrData.List

foldr :: forall a b. (a -> b -> b) -> b -> List a -> b

Fold a list from the right using a combining function and an initial value.

lengthData.List

length :: forall a. List a -> Nat

Count the elements in a finite list.

headData.List

head :: forall a. List a -> Option a

Return the first element when present. An empty list produces None.

filterData.List

filter :: forall a. (a -> Bool) -> List a -> List a

Retain elements that satisfy the predicate, in their original order.

ResultData.Result

data Result e a

A successful value or a recoverable error.

mapData.Result

map :: forall e a b. (a -> b) -> Result e a -> Result e b

Transform a successful result, preserving an error.

map-errorData.Result

map-error :: forall e f a. (e -> f) -> Result e a -> Result f a

Transform the error while leaving successful values alone.

MapData.Map

opaque Map k v

A persistent mapping from ordered keys to values.

emptyData.Map

empty :: forall k v. Map k v

Construct an empty map.

insertData.Map

insert :: forall k v. using (ord :: Ord k) => k -> v -> Map k v -> Map k v

Insert a value. An existing value at the same key is replaced.

lookupData.Map

lookup :: forall k v. using (ord :: Ord k) => k -> Map k v -> Option v

Find the value associated with a key.

keysData.Map

keys :: forall k v. Map k v -> List k

Return keys in ascending order.

SetData.Set

opaque Set a

A collection containing each value at most once.

emptyData.Set

empty :: forall a. Set a

Construct an empty set.

memberData.Set

member :: forall a. using (ord :: Ord a) => a -> Set a -> Bool

Test whether the set contains a value.

unionData.Set

union :: forall a. using (ord :: Ord a) => Set a -> Set a -> Set a

Combine two sets, retaining each value once.

NonEmptyData.NonEmpty

data NonEmpty a

One head element followed by a possibly empty tail.

headData.NonEmpty

head :: forall a. NonEmpty a -> a

Read the first element. No empty case is possible.

to-listData.NonEmpty

to-list :: forall a. NonEmpty a -> List a

Forget the nonempty guarantee and retain the values.

Utf8ErrorText.Utf8

data Utf8Error

An invalid byte sequence and the offset at which decoding failed.

decodeText.Utf8

decode :: Bytes -> Result Utf8Error String

Decode UTF-8 bytes. Invalid sequences produce a structured error.

encodeText.Utf8

encode :: String -> Bytes

Encode a string as UTF-8 bytes.

linesText.Utf8

lines :: String -> List String

Split text at line boundaries.

ParserText.Parser

opaque Parser a

A parser that either produces a value or reports a position and expectation.

ParseErrorText.Parser

data ParseError

A source position and the expectations that were not met.

parseText.Parser

parse :: forall a. Parser a -> String -> Result ParseError a

Run a parser and require it to consume the full input.

integerText.Parser

integer :: Parser Int

Parse a signed decimal integer.

JsonData.Json

data Json

A null, boolean, number, string, array, or object value.

JsonErrorData.Json

data JsonError

A byte offset and description of a malformed JSON document.

parseData.Json

parse :: String -> Result JsonError Json

Parse a complete JSON document.

renderData.Json

render :: Json -> String

Render a compact JSON representation.

DecoderData.Json.Decode

opaque Decoder a

A typed decoder with a path-aware failure report.

DecodeErrorData.Json.Decode

data DecodeError

The path, expected type, and actual value at a failed decoding step.

decodeData.Json.Decode

decode :: forall a. Decoder a -> Json -> Result DecodeError a

Apply a decoder to a JSON value.

fieldData.Json.Decode

field :: forall a. String -> Decoder a -> Decoder a

Decode a named field in an object.

stringData.Json.Decode

string :: Decoder String

Accept a JSON string.

RequestNet.Http

record Request

A request method, URL, headers, and optional body.

ResponseNet.Http

record Response

A status code, response headers, and body bytes.

HttpErrorNet.Http

data HttpError

A connection, protocol, or timeout failure.

status-codeNet.Http

status-code :: Response -> Nat

Read the numerical HTTP status code.

getNet.Http.Client

get :: String ->{Io r} Result HttpError Response

Send a GET request. Connection failures remain explicit in Result.

sendNet.Http.Client

send :: Request ->{Io r} Result HttpError Response

Send a request with an explicit method, headers, and body.

with-timeoutNet.Http.Client

with-timeout :: Nat -> Request ->{Io r} Result HttpError Response

Send a request with a timeout expressed in milliseconds.

TaskControl.Task

opaque Task scope a

A handle to a scoped computation. Its result can be joined once.

spawnControl.Task

spawn :: forall a. (Unit ->{Io r} a) ->{Io r} Task scope a

Start a child computation in the current scope.

joinControl.Task

join :: forall a. Task scope a ->{Io r} a

Wait for a task and consume its result handle.

ChannelControl.Channel

opaque Channel a

A bounded channel used to transfer values between tasks.

sendControl.Channel

send :: forall a. Channel a -> a ->{Io r} Unit

Send a value, waiting when the channel is full.

receiveControl.Channel

receive :: forall a. Channel a ->{Io r} Option a

Receive the next value. A closed channel produces None.

DurationData.Time

opaque Duration

A nonnegative span of time.

InstantData.Time

opaque Instant

A point on the monotonic clock.

millisecondsData.Time

milliseconds :: Nat -> Duration

Construct a duration from milliseconds.

nowData.Time

now :: Unit ->{Io r} Instant

Read the monotonic clock.

elapsedData.Time

elapsed :: Instant -> Instant -> Duration

Measure the duration between two instants.

GenTest.Check

opaque Gen a

A deterministic generator that produces values from a seed.

PropertyTest.Check

opaque Property

A testable proposition with a failure report and counterexample.

for-allTest.Check

for-all :: forall a. Gen a -> (a -> Bool) -> Property

Test a property over generated values.

checkTest.Check

check :: Nat -> Property ->{Io r} Result String Unit

Run a property for the requested number of examples.

TestTest.Runner

opaque Test

A named test or group of tests.

groupTest.Runner

group :: String -> List Test -> Test

Name a collection of tests.

runTest.Runner

run :: List Test ->{Io r} Nat

Run a test collection and return the number of failures.