Servant.Client.Core.Internal.Generic

Documentation

class ClientLike client custom where

This class allows us to match client structure with client functions produced with client without explicit pattern-matching.

The client structure needs a Generic instance.

Example:

type API
    = "foo" :> Capture "x" Int :> Get '[JSON] Int
 :<|> "bar" :> QueryParam "a" Char :> QueryParam "b" String :> Post '[JSON] [Int]
 :<|> Capture "nested" Int :> NestedAPI

type NestedAPI
    = Get '[JSON] String
 :<|> "baz" :> QueryParam "c" Char :> Post '[JSON] ()

data APIClient = APIClient
  { getFoo         :: Int -> ClientM Int
  , postBar        :: Maybe Char -> Maybe String -> ClientM [Int]
  , mkNestedClient :: Int -> NestedClient
  } deriving GHC.Generic

instance Generics.SOP.Generic APIClient
instance (Client API ~ client) => ClientLike client APIClient

data NestedClient = NestedClient
 { getString :: ClientM String
 , postBaz   :: Maybe Char -> ClientM ()
 } deriving GHC.Generic

instance Generics.SOP.Generic NestedClient
instance (Client NestedAPI ~ client) => ClientLike client NestedClient

mkAPIClient :: APIClient
mkAPIClient = mkClient (client (Proxy :: Proxy API))

By default, left-nested alternatives are expanded:

type API1
    = "foo" :> Capture "x" Int :> Get '[JSON] Int
 :<|> "bar" :> QueryParam "a" Char :> Post '[JSON] String

type API2
    = "baz" :> QueryParam "c" Char :> Post '[JSON] ()

type API = API1 :<|> API2

data APIClient = APIClient
  { getFoo  :: Int -> ClientM Int
  , postBar :: Maybe Char -> ClientM String
  , postBaz :: Maybe Char -> ClientM ()
  } deriving GHC.Generic

instance Generics.SOP.Generic APIClient
instance (Client API ~ client) => ClientLike client APIClient

mkAPIClient :: APIClient
mkAPIClient = mkClient (client (Proxy :: Proxy API))

If you want to define client for API1 as a separate data structure, you can use genericMkClientP:

data APIClient1 = APIClient1
  { getFoo  :: Int -> ClientM Int
  , postBar :: Maybe Char -> ClientM String
  } deriving GHC.Generic

instance Generics.SOP.Generic APIClient1
instance (Client API1 ~ client) => ClientLike client APIClient1

data APIClient = APIClient
  { mkAPIClient1 :: APIClient1
  , postBaz      :: Maybe Char -> ClientM ()
  } deriving GHC.Generic

instance Generics.SOP.Generic APIClient
instance (Client API ~ client) => ClientLike client APIClient where
  mkClient = genericMkClientP

mkAPIClient :: APIClient
mkAPIClient = mkClient (client (Proxy :: Proxy API))

Methods

mkClient :: client -> custom

mkClient :: (Generic custom, Code custom ~ '[xs], GClientList client '[], GClientLikeL (ClientList client '[]) xs) => client -> custom

Instances

ClientLike client custom => ClientLike (a -> client) (a -> custom)

Defined in Servant.Client.Core.Internal.Generic

Methods

mkClient :: (a -> client) -> a -> custom

class GClientLikeP client xs where

Match client structure with client functions, regarding left-nested API clients as separate data structures.

Minimal complete definition

gMkClientP

Methods

gMkClientP :: client -> NP I xs

Instances

ClientLike a x => GClientLikeP a (x ': ([] :: [*]))

Defined in Servant.Client.Core.Internal.Generic

Methods

gMkClientP :: a -> NP I (x ': [])

(GClientLikeP b (y ': xs), ClientLike a x) => GClientLikeP (a :<|> b) (x ': (y ': xs))

Defined in Servant.Client.Core.Internal.Generic

Methods

gMkClientP :: (a :<|> b) -> NP I (x ': (y ': xs))

class GClientLikeL (xs :: [*]) (ys :: [*]) where

Match client structure with client functions, expanding left-nested API clients in the same structure.

Minimal complete definition

gMkClientL

Methods

gMkClientL :: NP I xs -> NP I ys

Instances

GClientLikeL ([] :: [*]) ([] :: [*])

Defined in Servant.Client.Core.Internal.Generic

Methods

gMkClientL :: NP I [] -> NP I []

(ClientLike x y, GClientLikeL xs ys) => GClientLikeL (x ': xs) (y ': ys)

Defined in Servant.Client.Core.Internal.Generic

Methods

gMkClientL :: NP I (x ': xs) -> NP I (y ': ys)

type family ClientList (client :: *) (acc :: [*]) :: [*] where ...

Equations

ClientList (a :<|> b) acc = ClientList a (ClientList b acc)

ClientList a acc = a ': acc

class GClientList client (acc :: [*]) where

Minimal complete definition

gClientList

Methods

gClientList :: client -> NP I acc -> NP I (ClientList client acc)

Instances

ClientList client acc ~ (client ': acc) => GClientList client acc

Defined in Servant.Client.Core.Internal.Generic

Methods

gClientList :: client -> NP I acc -> NP I (ClientList client acc)

(GClientList b acc, GClientList a (ClientList b acc)) => GClientList (a :<|> b) acc

Defined in Servant.Client.Core.Internal.Generic

Methods

gClientList :: (a :<|> b) -> NP I acc -> NP I (ClientList (a :<|> b) acc)

genericMkClientL :: (Generic custom, Code custom ~ '[xs], GClientList client '[], GClientLikeL (ClientList client '[]) xs) => client -> custom

Generate client structure from client type, expanding left-nested API (done by default).

genericMkClientP :: (Generic custom, Code custom ~ '[xs], GClientLikeP client xs) => client -> custom

Generate client structure from client type, regarding left-nested API clients as separate data structures.