servant-client-core

Core functionality and class for client function generation for servant APIs

http://haskell-servant.readthedocs.org/

Version on this page:	0.14.1@rev:1
LTS Haskell 20.23:	0.19@rev:5
Stackage Nightly 2023-06-04:	0.19@rev:5
Latest on Hackage:	0.19@rev:5

See all snapshots servant-client-core appears in

BSD-3-Clause licensed by Servant Contributors

Maintained by haskell-servant-maintainers@googlegroups.com

This version can be pinned in stack with:servant-client-core-0.14.1@sha256:1104e2a0c28a8b102db7f4bea2db1decabc4c5440d0b71fbf7f770aaef37b913,3540

Module documentation for 0.14.1

Servant
- Servant.Client

Depends on 15 packages(full list with versions):

base, base64-bytestring, base-compat, bytestring, containers, exceptions, free, generics-sop, http-api-data, http-media, http-types, network-uri, safe, servant, text

Used by 6 packages in lts-12.14(full list with versions):

cachix, servant-auth-client, servant-checked-exceptions, servant-client, servant-streaming-client, slack-web

servant-client-core

servant

HTTP-client-agnostic client functions for servant APIs.

This library should mainly be of interest to backend- and combinator-writers.

For backend-writers

If you are creating a new backend, you’ll need to:

Define a RunClient instance for your datatype (call it MyMonad)
Define a ClientLike instance. This will look like:

instance ClientLike (MyMonad a) (MyMonad a) where
  mkClient = id

Re-export the module Servant.Client.Core.Reexport so that your end-users can be blissfully unaware of ‘servant-client-core’, and so each backend-package comes closer to the warm hearth of the drop-in-replacement equivalence class.

For combinator-writers

You’ll need to define a new HasClient instance for your combinator. There are plenty of examples to guide you in the HasClient module.

Changes

The latest version of this document is on GitHub. Changelog for servant package contains significant entries for all core packages.

0.14.1

Merge in servant-generic (by Patrick Chilton) into servant (Servant.API.Generic), servant-client-code (Servant.Client.Generic) and servant-server (Servant.Server.Generic).

0.14

Stream takes a status code argument

-Stream method        framing ctype a
+Stream method status framing ctype a

(#966 #972)

ToStreamGenerator definition changed, so it’s possible to write an instance for conduits.

-class ToStreamGenerator f a where
-   toStreamGenerator :: f a -> StreamGenerator a
+class ToStreamGenerator a b | a -> b where
+   toStreamGenerator :: a -> StreamGenerator b

(#959)

Added NoFraming streaming strategy (#959)
servant-client-core Free Client implementation. Useful for testing HasClient instances. (#920)
servant-client-core Add hoistClient to HasClient. Just like hoistServer allows us to change the monad in which request handlers of a web application live in, we also have hoistClient for changing the monad in which client functions live. Read tutorial section for more information. (#936)

iF you have own combinators, you’ll need to define a new method of HasClient class, for example:
```
type Client m (MyCombinator :> api) = MyValue :> Client m api
hoistClientMonad pm _ nt cl = hoistClientMonad pm (Proxy :: Proxy api) nt . cl
```

0.13.0.1

Support base-compat-0.10

0.13

Streaming endpoint support. (#836)
servant Add Servant.API.Modifiers (#873)

0.12

First version. Factored out of servant-client all the functionality that was independent of the http-client backend.