Constraint for monads that can be used as servers

Defines a mapping between outcome of a service, and its representation as Haskell type.

To declare that the function doesn't use its context.

Defines a server for a package with a single service. Intended to be used with a tuple of methods:

singleService (method @"m1" h1, method @"m2" h2)

Declares the handler for a method in the service. Intended to be used with TypeApplications:

method @"myMethod" myHandler

Declares the handler for a method in the service, which is passed additional information about the call. Intended to be used with TypeApplications:

methodWithInfo @"myMethod" myHandler

Combines the implementation of several GraphQL objects, which means a whole Mu service for a GraphQL server. Intented to be used with a tuple of objects:

resolver (object @"o1" ..., object @"o2" ...)

Defines the implementation of a single GraphQL object, which translates as a single Mu service. Intended to be used with TypeApplications and a tuple of fields:

object @"myObject" (field @"f1" h1, fielf @"f2" h2)

Note: for the root objects in GraphQL (query, mutation, subscription) use method instead of object.

Declares the handler for a field in an object. Intended to be used with TypeApplications:

field @"myField" myHandler

Declares the handler for a field in an object, which is passed additional information about the call. Intended to be used with TypeApplications:

fieldWithInfo @"myField" myHandler

Heterogeneous list in which each element is tagged with a type-level name.

A server for a single service, like most RPC ones.

Definition of a complete server for a set of services, with possible references between them.

Definition of a complete server for a service.

Definition of different kinds of services.

HandlersT is a sequence of handlers. Note that the handlers for your service must appear in the same order as they are defined.

In general you can choose any type you want for your handlers, due to the following restrictions:

• Haskell types must be convertible to the corresponding schema type. In other words, they must implement FromSchema if they are inputs, and ToSchema if they are outputs.
• Normal returns are represented by returning the corresponding Haskell type.
• Input streams turn into Conduit () t m (), where t is the Haskell type for that schema type.
• Output streams turn into an additional argument of type Conduit t Void m (). This stream should be connected to a source to get the elements.

Simplest monad which satisfies MonadServer.

Simple ServerT which uses only IO and errors, and whose service has no back-references.

Stop the current handler, returning an error to the client.

Errors raised in a handler.

Possible types of errors. Some of these are handled in a special way by different transpoprt layers.

Wrapper for handlers which do not use errors. Remember that any exception raised in IO is propagated to the client.

Defines a relation for handling.

Defines whether a given type t can be obtained from the TypeRef ref.

Defines whether a given type t can be turned into the TypeRef ref.