Specifies how to launch a temporary process using Docker.

Starts a Proc.

It uses ping to determine if the Proc started up ok, and will fail by throwing an exception if it did not.

Returns the ProcHandle used to access and control the Proc once a ping has succeeded.

Name of a process.

Simplifies use of uriOf.

Simplifies use of runArgs.

Indicates the result of pinging a Proc.

If the ping succeeds, ping should return OK.

ping should catch any exceptions that are expected when the Procs service is not available and return NotOK.

startupAll uses PingFailed to report any unexpected exceptions that escape ping.

Use an action that might throw an exception as a ping.

Declares a proof that a list of types only contains Procs.

Allow customization of the docker command that launches a Proc

The docker launch command is `docker run -d optional-args --name $(name a) $(imageText a)`

A Proc datatype should declare an instance of ToRunCmd to control optional-args

This module provides an Overlappable fallback instance with default behaviour that matches all Proc, so this typeclass is only needed when a Proc datatypes actually needs additional arguments

Prepare resources for use by a Proc

Preparation occurs before the docker container is a launched; once the resources are set up, they are located using the prepared datatype.

Usually, this means it will be used by toRunCmd to provide additional arguments to the docker run command

This module provides an Overlappable fallback instance that matches all Proc, so this typeclass is only needed when a Proc datatype actually requires preparatory setup.

The first argument to prepare is a [SlimHandle] that gives access to other tmp-procs previously launched in the same test, to allow prepare to setup links to them when necessary

A Constraint that combines Proc and its supporting typeclasses

Start up processes for each Proc type

the processes' are able to communicate via a docker network with a unique generated name

Terminate all processes owned by some ProcHandles.

Set up some Procs, run an action that uses them, then terminate them.

Start up processes for each Proc type.

Like terminateAll, but also removes the docker network connecting the processes.

Like startupAll, but reveals the generated network name via the deprecated NetworkHandlesOf

Provides access to a Proc that has been started.

Obtain the handle matching the given type from a HList of ProcHandle.

Provides an untyped view of the data in a ProcHandle

Obtain the SlimHandle.

Converts list of types to the corresponding ProcHandle types.

Constraint alias used to constrain types where proxy of a Proc type looks up a value in an HList of ProcHandle.

Constraint alias used to constrain types where a Name looks up a type in an HList of ProcHandle.

A list of ProcHandle values.

Resets the handle whose index is specified by the proxy type.

Pings the handle whose index is specified by the proxy type.

Obtains the service URI of the handle whose index is specified by the proxy type.

Select the named ProcHandles from an HList of ProcHandle.

Obtain the SlimHandle of several Procs

Constraint alias when several Names are used to find matching types in an HList of ProcHandle.

A list of ProcHandle values of different types with the name of the docker network connecting their processes

Specifies how to construct a connection datatype for accessing the launched service specified by a Proc.

Run an action on a Connectable handle as a callback on its Conn

Open all the Connectable types to corresponding Conn types.

Close some Connectable types.

Open some connections, use them in an action; close them.

Builds on handleOf; gives the Conn of the ProcHandle to a callback.

Open all known connections; use them in an action; close them.

Open the named connections; use them in an action; close them.

Declares a proof that a list of types only contains Connectables.

Determine if the docker daemon is accessible.

generate a random network name

The IP address of the docker host.

A connection string used to access the service once its running.

Sort a list of type-level symbols using merge sort.

Examples

>>> :kind! SortSymbols '["xyz", "def", "abc"]
SortSymbols '["xyz", "def", "abc"] :: [Symbol]
= '["abc", "def", "xyz"]

Computes the midpoint of a number.

N.B: maximum value that this works for depends on the reduction limit of the type-checker.

Examples

>>> :kind! CmpNat 49 (HalfOf 99)
CmpNat 49 (HalfOf 99) :: Ordering
= 'EQ

>>> :kind! CmpNat 50 (HalfOf 100)
CmpNat 50 (HalfOf 100) :: Ordering
= 'EQ

Counts a list, 1 element at a time.

Examples

>>> :kind! CmpNat 4 (LengthOf '[1, 2, 3, 4])
CmpNat 4 (LengthOf '[1, 2, 3, 4]) :: Ordering
= 'EQ

Drops 1 element at a time until the the dropped target is reached.

Examples

>>> :kind! Drop '["a", "b", "c", "d"] 2
Drop '["a", "b", "c", "d"] 2 :: [Symbol]
= '["c", "d"]

>>> :kind! Drop '["a"] 2
Drop '["a"] 2 :: [Symbol]
= '[]

Takes 1 element at a time from a list until the desired length is reached.

Examples

>>> :kind! Take '["a", "b", "c", "d"] 2
Take '["a", "b", "c", "d"] 2 :: [Symbol]
= '["a", "b"]

Generate proof instances of IsIn.

Allows reordering of similar HLists.

Examples

>>> hReorder @_ @'[Bool, Int] ('c' &: (3 :: Int) &: True &: (3.1 :: Double) &: HNil)
True &: 3 &: HNil

>>> hReorder @_ @'[Double, Bool, Int] ('c' &: (3 :: Int) &: True &: (3.1 :: Double) &: HNil)
3.1 &: True &: 3 &: HNil

Generate proof instances of LookupMany.

Generate proof instances of LookupKV.

A constraint that confirms that a type is not present in a type-level list.

Use a type-level symbol as key type that indexes a value type.

Defines a Heterogenous list.

Obtain the first element of a HList.

Get an item in an HList given its type.

An infix alias for HCons.

Construct a two-item HList.

An infix alias for both.

Construct a singleton HList

Select an item from an HList of KVs by key.

N.B Returns the first item. It assumes the keys in the KV HList are unique. TODO: enforce this rule using a constraint.

Examples

>>> select @"d" @Double  @'[KV "b" Bool, KV "d" Double] (V True &:  V (3.1 :: Double) &: HNil)
3.1

Select items with specified keys from an HList of KVs by key.

N.B. this this is an internal function.

The keys must be provided in the same order as they occur in the HList, any other order will likely result in an compiler error.

Examples

>>> selectMany @'["b"] @'[Bool] @'[KV "b" Bool, KV "d" Double] (V True &:  V (3.1 :: Double) &: HNil)
True &: HNil