e]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownSafe+,DQRUChange a list of types into a list of functions that take the given type and return x.LRefl :: ReturnX Double '[String, Int] :~: '[String -> Double, Int -> Double]Refl%Don't do anything with an empty list:"Refl :: ReturnX Double '[] :~: '[]Refl A type-level snoc.Append to an empty list:%Refl :: Snoc '[] Double :~: '[Double]ReflAppend to a non-empty list:/Refl :: Snoc '[Char] String :~: '[Char, String]ReflDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone+,DQR Used by the  HasServer and  HasClient instances for  es  api  apis to detect  es followed immediately by  e.<This is used internally and should not be used by end-users.r is used to indicate that an API will not throw an error, but that it will still return a response wrapped in a  .ExamplesCreate an API using :$import Servant.API (Get, JSON, (:>))%type API = NoThrow :> Get '[JSON] IntEA servant-server handler for this type would look like the following:  apiHandler ::    (  '[] Int) apiHandler =   3 Z is used in Servant API definitions and signifies that an API will throw the given error.GHere is an example of how to create an API that potentially returns a  as an error, or an  on success:$import Servant.API (Get, JSON, (:>))+type API = Throws String :> Get '[JSON] IntDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownSafe%&*+,-9:;<=?DOQRTa) gives us a way to convert a tuple to an . See .  ) is used as a standard open product type. 6This type class provides a way to turn a tuple into a  . Convert a tuple into a  . See  for examples. 1An extensible product type. This is similar to /, except a product type instead of a sum type.Turn a tuple into a  .LtupleToProduct (Identity 1, Identity 2.0) :: Product Identity '[Int, Double]+Cons (Identity 1) (Cons (Identity 2.0) Nil)Turn a tuple into an .ExamplesTurn a triple into an :JtupleToOpenProduct (1, 2.0, "hello") :: OpenProduct '[Int, Double, String]ECons (Identity 1) (Cons (Identity 2.0) (Cons (Identity "hello") Nil))Turn a single value into an :-tupleToOpenProduct 'c' :: OpenProduct '[Char]Cons (Identity 'c') NilShow   values.Show   values.Convert a 4-tuple into an .Convert a 3-tuple into an .Convert a tuple into an .Convert a single value into an .Convert a 4-tuple into a  .Convert a 3-tuple into a  .Convert a tuple into a  .Convert a single value into a  .       BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNoneOT  !"  !"  !"  !""4Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone%&*+,-/9:;<=?DOQRT[a# We can use )  as a standard open sum type.$This is a helpful  Constraint synonym to assert that a is a member of as.%% a as i& provides a way to potentially get an f a out of a ) f as (((). It also provides a way to create a ) f as from an f a (').This is safe because of the / contraint. This /! constraint tells us that there  actually is an a in as at index i.]As an end-user, you should never need to implement an additional instance of this typeclass.&This is implemented as  ' (.'This is implemented as   &.(This is implemented as ! &.)A ) is parameterized by a universe u, an interpretation f and a list of labels as@. The labels of the union are given by inhabitants of the kind u"; the type of values at any label a :: u is given by its interpretation f a :: *.,KA mere approximation of the natural numbers. And their image as lifted by  -XDataKinds+ corresponds to the actual natural numbers./=A partial relation that gives the index of a value in a list.ExamplesFind the first item:'import Data.Type.Equality ((:~:)(Refl))+Refl :: RIndex String '[String, Int] :~: 'ZReflFind the third item:7Refl :: RIndex Char '[String, Int, Char] :~: 'S ('S 'Z)Refl0Case analysis for ).Examples$Here is an example of matching on a *:@let u = This (Identity "hello") :: Union Identity '[String, Int]7let runIdent = runIdentity :: Identity String -> String'union (const "not a String") runIdent u"hello"$Here is an example of matching on a +:Klet v = That (This (Identity 3.3)) :: Union Identity '[String, Double, Int]'union (const "not a String") runIdent v"not a String"1\Since a union with an empty list of labels is uninhabited, we can recover any type from it.2Map over the interpretation f in the ).Examples!Here is an example of changing a )  '[, ] to )  '[, ]:@let u = This (Identity "hello") :: Union Identity '[String, Int]9umap (Just . runIdentity) u :: Union Maybe '[String, Int] Just "hello"3!An alternate case anaylsis for a )Q. This method uses a tuple containing handlers for each potential value of the )$. This is somewhat similar to the  function.Examples!Here is an example of handling a )@ with two possible values. Notice that a normal tuple is used::let u = This $ Identity 3 :: Union Identity '[Int, String]Jlet intHandler = (Identity $ \int -> show int) :: Identity (Int -> String)Hlet strHandler = (Identity $ \str -> str) :: Identity (String -> String):catchesUnion (intHandler, strHandler) u :: Identity String Identity "3"Given a ) like )  '[, ], the type of 3 becomes the following:  3 :: ( ( -> ),  ( ->  )) -> )  '[,  ] ->    Checkout < for more examples.4Lens-compatible  for *.ExamplesUse 4 to construct a ):4review _This (Just "hello") :: Union Maybe '[String] Just "hello"Use 4 to try to destruct a ) into a f a:@let u = This (Identity "hello") :: Union Identity '[String, Int]*preview _This u :: Maybe (Identity String)Just (Identity "hello")Use 4 to try to destruct a ) into a f a (unsuccessfully):Klet v = That (This (Identity 3.3)) :: Union Identity '[String, Double, Int]*preview _This v :: Maybe (Identity String)Nothing5Lens-compatible  for +.ExamplesUse 5 to construct a ):4let u = This (Just "hello") :: Union Maybe '[String]/review _That u :: Union Maybe '[Double, String] Just "hello"Use 5 to try to peel off a + from a ):Glet v = That (This (Identity "hello")) :: Union Identity '[Int, String]3preview _That v :: Maybe (Union Identity '[String])Just (Identity "hello")Use 5 to try to peel off a + from a ) (unsuccessfully):?let w = This (Identity 3.5) :: Union Identity '[Double, String]3preview _That w :: Maybe (Union Identity '[String])Nothing6Case analysis for #.Examples,Here is an example of successfully matching:let string = "hello" :: String8let o = openUnionLift string :: OpenUnion '[String, Int]%openUnion (const "not a String") id o"hello".Here is an example of unsuccessfully matching:let double = 3.3 :: Double@let p = openUnionLift double :: OpenUnion '[String, Double, Int]%openUnion (const "not a String") id p"not a String"7This is similar to  fromMaybe for an #.Examples,Here is an example of successfully matching:let string = "hello" :: String8let o = openUnionLift string :: OpenUnion '[String, Int]&fromOpenUnion (const "not a String") o"hello".Here is an example of unsuccessfully matching:let double = 3.3 :: Double@let p = openUnionLift double :: OpenUnion '[String, Double, Int]&fromOpenUnion (const "not a String") p"not a String"8Flipped version of 7.9 Just like & but for #.: Just like ' but for #. Creating an #:let string = "hello" :: String8openUnionLift string :: OpenUnion '[Double, String, Int]Identity "hello"; Just like ( but for #.ExamplesSuccessful matching:let string = "hello" :: String@let o = openUnionLift string :: OpenUnion '[Double, String, Int] openUnionMatch o :: Maybe String Just "hello"Failure matching:let double = 3.3 :: Double;let p = openUnionLift double :: OpenUnion '[Double, String] openUnionMatch p :: Maybe StringNothing<"An alternate case anaylsis for an #Q. This method uses a tuple containing handlers for each potential value of the #$. This is somewhat similar to the  function.When working with large #s, it can be easier to use < than 6.Examples"Here is an example of handling an #? with two possible values. Notice that a normal tuple is used:<let u = openUnionLift (3 :: Int) :: OpenUnion '[Int, String]4let intHandler = (\int -> show int) :: Int -> String2let strHandler = (\str -> str) :: String -> String5catchesOpenUnion (intHandler, strHandler) u :: String"3" Given an # like # '[, ], the type of < becomes the following:  < :: ( -> x,  -> x) -> # '[,  ] -> x "Here is an example of handling an # with three possible values:Mlet u = openUnionLift ("hello" :: String) :: OpenUnion '[Int, String, Double]4let intHandler = (\int -> show int) :: Int -> String2let strHandler = (\str -> str) :: String -> String=let dblHandler = (\dbl -> "got a double") :: Double -> StringAcatchesOpenUnion (intHandler, strHandler, dblHandler) u :: String"hello""Here is an example of handling an #T with only one possible value. Notice how a tuple is not used, just a single value:<let u = openUnionLift (2.2 :: Double) :: OpenUnion '[Double]=let dblHandler = (\dbl -> "got a double") :: Double -> String'catchesOpenUnion dblHandler u :: String"got a double"='This is only a valid instance when the ( instances for the types don't overlap.This is similar to the  instance.>This will always fail, since ) f '[] is effectively Void.E'This is only a valid instance when the ( instances for the types don't overlap.,For instance, imagine we are working with a ) of a  and a . 3.5 can only be read as a  , not as a . Oppositely, "hello" can only be read as a  , not as a .Llet o = readMaybe "Identity 3.5" :: Maybe (Union Identity '[Double, String])oJust (Identity 3.5)$o >>= openUnionMatch :: Maybe DoubleJust 3.5$o >>= openUnionMatch :: Maybe StringNothingRlet p = readMaybe "Identity \"hello\"" :: Maybe (Union Identity '[Double, String])pJust (Identity "hello")$p >>= openUnionMatch :: Maybe DoubleNothing$p >>= openUnionMatch :: Maybe String Just "hello"'However, imagine are we working with a ) of a  and . "hello" can be  as both a  and @. However, in the following example, it can only be read as a :Plet q = readMaybe "Identity \"hello\"" :: Maybe (Union Identity '[String, Text])qJust (Identity "hello")$q >>= openUnionMatch :: Maybe String Just "hello""q >>= openUnionMatch :: Maybe TextNothingEIf the order of the types is flipped around, we are are able to read "hello" as a Text but not as a .Plet r = readMaybe "Identity \"hello\"" :: Maybe (Union Identity '[Text, String])rJust (Identity "hello")$r >>= openUnionMatch :: Maybe StringNothing"r >>= openUnionMatch :: Maybe Text Just "hello"FThis will always fail, since ) f '[] is effectively Void.+#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL#$%&'()*+,-./0123456789:;<)*+031245,-./%&'($#6789:;<$#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone%&,-/02345:OTMThis M. type is a used as a wrapper around either an #< with an error or a successful value. It is similar to an  e a, but where the e is specialized to # es'. The most important difference from  is the the  and  instances. Given an M '[, ] ()(, we know that the envelope could be a O and contain (). Or it could be a N that contains either a  or a 6. It might be simpler to think of it as a type like   (  ()).An M can be created with the P and Q functions. The s ], ^, and _% can be used to get values out of an M.P Create an N from a member of the #.'For instance, here is how to create an N that contains a :let double = 3.5 :: Double:toErrEnvelope double :: Envelope '[String, Double, Int] ()ErrEnvelope (Identity 3.5)QThis is a function to create a O.3toSuccEnvelope "hello" :: Envelope '[Double] StringSuccEnvelope "hello"RR is P lifted up to an .SS is Q lifted up to an .TCase analysis for Ms.Examples$Here is an example of matching on a O:Blet env = toSuccEnvelope "hello" :: Envelope '[Double, Int] String&envelope (const "not a String") id env"hello"$Here is an example of matching on a N:let double = 3.5 :: DoubleAlet env' = toErrEnvelope double :: Envelope '[Double, Int] String'envelope (const "not a String") id env'"not a String"U Unwrap an M that cannot contain an error.Examples7let env = toSuccEnvelope "hello" :: Envelope '[] StringemptyEnvelope env"hello"V Just like  but for M.Examples,Here is an example of successfully matching:Blet env = toSuccEnvelope "hello" :: Envelope '[Double, Int] String'fromEnvelope (const "not a String") env"hello".Here is an example of unsuccessfully matching:let double = 3.5 :: DoubleAlet env' = toErrEnvelope double :: Envelope '[Double, Int] String(fromEnvelope (const "not a String") env'"not a String"WLifted version of V.XFlipped version of V.YFlipped version of W.Z Convert an M to an .[ Convert an  to an M.\Lens-compatible  from M to .]Lens-compatible  to pull out an a from a O.ExamplesUse ] to construct an M:9review _SuccEnvelope "hello" :: Envelope '[Double] StringSuccEnvelope "hello"Use ] to try to destruct an M into an a:=let env = toSuccEnvelope "hello" :: Envelope '[Double] String)preview _SuccEnvelope env :: Maybe String Just "hello"Use ]( to try to destruct a 'Envelope into an a (unsuccessfully):let double = 3.5 :: Double<let env' = toErrEnvelope double :: Envelope '[Double] String*preview _SuccEnvelope env' :: Maybe StringNothing^Lens-compatible  to pull out an # es from a N.Most users will not use ^, but instead _.ExamplesUse ^ to construct an M:let string = "hello" :: StringGreview _ErrEnvelope (openUnionLift string) :: Envelope '[String] DoubleErrEnvelope (Identity "hello")Use ^ to try to destruct an M into an # es:let double = 3.5 :: Double7let env = toErrEnvelope double :: Envelope '[Double] ()7preview _ErrEnvelope env :: Maybe (OpenUnion '[Double])Just (Identity 3.5)Use ^) to try to destruct a 'Envelope into an # es (unsuccessfully):5let env' = toSuccEnvelope () :: Envelope '[Double] ()8preview _ErrEnvelope env' :: Maybe (OpenUnion '[Double])Nothing_Lens-compatible  to pull out a specific e from an N.Most users will use _ instead of ^.ExamplesUse _ to construct an M:let string = "hello" :: String:review _ErrEnvelopeErr string :: Envelope '[String] DoubleErrEnvelope (Identity "hello")Use _ to try to destruct an M into an e:let double = 3.5 :: Double7let env = toErrEnvelope double :: Envelope '[Double] ()+preview _ErrEnvelopeErr env :: Maybe DoubleJust 3.5Use _) to try to destruct a 'Envelope into an e (unsuccessfully):5let env' = toSuccEnvelope () :: Envelope '[Double] (),preview _ErrEnvelopeErr env' :: Maybe DoubleNothing<let env'' = toErrEnvelope 'c' :: Envelope '[Double, Char] ()-preview _ErrEnvelopeErr env'' :: Maybe DoubleNothing`Pull out a specific e from an N.ExamplesSuccessfully pull out an e:let double = 3.5 :: Double7let env = toErrEnvelope double :: Envelope '[Double] ()$errEnvelopeMatch env :: Maybe DoubleJust 3.5Unsuccessfully pull out an e:5let env' = toSuccEnvelope () :: Envelope '[Double] ()%errEnvelopeMatch env' :: Maybe DoubleNothing<let env'' = toErrEnvelope 'c' :: Envelope '[Double, Char] ()&errEnvelopeMatch env'' :: Maybe DoubleNothinga"An alternate case anaylsis for an MQ. This method uses a tuple containing handlers for each potential value of the M$. This is somewhat similar to the  function.When working with an MG with a large number of possible error types, it can be easier to use a than T.Examples"Here is an example of handling an OE with two possible error values. Notice that a normal tuple is used:>let env = toSuccEnvelope 2.0 :: Envelope '[Int, String] Double4let intHandler = (\int -> show int) :: Int -> String2let strHandler = (\str -> str) :: String -> String>let succHandler = (\dbl -> "got a double") :: Double -> StringBcatchesEnvelope (intHandler, strHandler) succHandler env :: String"got a double""Here is an example of handling an NZ with two possible error values. Notice that a normal tuple is used to hold the handlers:Dlet env = toErrEnvelope (3 :: Int) :: Envelope '[Int, String] Double4let intHandler = (\int -> show int) :: Int -> String2let strHandler = (\str -> str) :: String -> String>let succHandler = (\dbl -> "got a double") :: Double -> StringBcatchesEnvelope (intHandler, strHandler) succHandler env :: String"3" Given an M like M '[, ] , the type of a becomes the following:  a :: ( -> x,  -> x) -> ( -> x) -> M '[, ]  -> x "Here is an example of handling an NP with three possible values. Notice how a 3-tuple is used to hold the handlers:Plet env = toErrEnvelope ("hi" :: String) :: Envelope '[Int, String, Char] Double4let intHandler = (\int -> show int) :: Int -> String2let strHandler = (\str -> str) :: String -> String2let chrHandler = (\chr -> [chr]) :: Char -> String>let succHandler = (\dbl -> "got a double") :: Double -> StringNcatchesEnvelope (intHandler, strHandler, chrHandler) succHandler env :: String"hi" Given an M like M '[, , ] , the type of a becomes the following:  a :: ( -> x,  -> x,  -> x) -> ( -> x) -> M '[, , ]  -> x "Here is an example of handling an NY with only one possible error value. Notice that a normal handler is used (not a tuple):<let env = toErrEnvelope (3 :: Int) :: Envelope '[Int] Double4let intHandler = (\int -> show int) :: Int -> String>let succHandler = (\dbl -> "got a double") :: Double -> String4catchesEnvelope intHandler succHandler env :: String"3" Given an M like M '[] , the type of a becomes the following:  a :: ( -> x) -> ( -> x) -> M '[]  -> x f'This is only a valid instance when the  instances for the es don't overlap.1For an explanation, see the documentation on the  instance for .gThis  instance encodes an MA as an object with one of two keys depending on whether it is a O or an N.Here is an example of a O:let string = "hello" :: String<let env = toSuccEnvelope string :: Envelope '[Double] StringputByteStrLn $ encode env{"data":"hello"}Here is an example of a N:let double = 3.5 :: Double<let env' = toErrEnvelope double :: Envelope '[Double] StringputByteStrLn $ encode env' {"err":3.5}MNOPQRSTUVWXYZ[\]^_`abcdefgMNOPQRSTUVWXYZ[\]^_`aMNOQPSRTUVXWY`a]^_Z[\MNOPQRSTUVWXYZ[\]^_`abcdefgDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone+,-9:;<=DOQRTqWhen I comes before any other combinator, push it down so it is closer to the .rWhen a  e comes immediately after a  es, Snoc the e onto the es. Otherwise, if  eI comes before any other combinator, push it down so it is closer to the .sWhen  comes before , push  into each branch of the API.tWhen  es comes before , push  es into each branch of the API.uWhen  comes before a , change it into the same  but returning an M '[].vWhen  es comes before a , change it into the same  but returning an M es.w Change a  into .qrstuvwwvutsrqqrstuvwDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone+,-9:;<=DLOQRT xCreate samples for a given list of types, under given ctypes.AAdditional instances of this class should not need to be created.zCreate a sample for a given e under given ctypes.{We can generate a sample of an M es a8 as long as there is a way to generate a sample of the a.8This doesn't need to worry about generating a sample of es(, because that is taken care of in the  instance for  es.|When a  e comes immediately after a  es,  the e onto the es.}3Create a response body for each of the error types.~&An empty list of types has no samples.When  comes before a +, generate the documentation for the same , but returning an M '[].When  es comes before a +, generate the documentation for the same , but returning an M es-. Also add documentation for the potential es. Change a  into . xyz{|}~xyz xy~}z|{ xyz{|}~ Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone+,-9:;<=DOQRTWhen C comes before any combinator, push it down so it is closer to the .When a  e comes immediately after a  es, Snoc the e onto the es. Otherwise, if  eI comes before any other combinator, push it down so it is closer to the .When  comes before , push  into each branch of the API.When  es comes before , push  es into each branch of the API.When  comes before a , change it into the same  but returning an M '[].When  es comes before a , change it into the same  but returning an M es. Change a  into .Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNoneDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone? #$%&'()*+,.-/0123456789:;<MNOPQRSTUVWXYZ[\]^_`aDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone: #$%&'()*+,-./0123456789:;<MNOPQRSTUVWXYZ[\]^_`a:MNOQPSRTUVXWY`a]^_Z[\#6789:;<)*+012345,-./%&'($   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc defgh ijklmnopqrstuvwxyz{|}~ 9servant-checked-exceptions-0.4.1.0-1Onm1vJvXV11bghSrs57Eo(Servant.Checked.Exceptions.Internal.Util/Servant.Checked.Exceptions.Internal.Servant.API+Servant.Checked.Exceptions.Internal.Product)Servant.Checked.Exceptions.Internal.Prism)Servant.Checked.Exceptions.Internal.Union,Servant.Checked.Exceptions.Internal.Envelope2Servant.Checked.Exceptions.Internal.Servant.Client0Servant.Checked.Exceptions.Internal.Servant.Docs2Servant.Checked.Exceptions.Internal.Servant.ServerEnvelopeServantHandlerpureSuccEnvelopeUnionControl.Exceptioncatches Data.TextText Data.Either fromEither+Servant.Checked.Exceptions.Internal.Servant#Servant.Checked.Exceptions.InternalServant.Checked.ExceptionsReturnXSnocThrowingNonterminalThrowingNoThrowThrows ToOpenProduct toOpenProduct OpenProduct ToProduct toProductProductNilConstupleToProducttupleToOpenProduct $fShowProduct$fShowProduct0$fToOpenProduct(,,,):$fToOpenProduct(,,):$fToOpenProduct(,):$fToOpenProducta:$fToProductu(,,,)f:$fToProductu(,,)f:$fToProductu(,)f:$fToProductuff:Prism'PrismIsoisoprismprism'reviewpreview<>~ OpenUnionIsMemberUElem unionPrism unionLift unionMatchThisThatNatZSRIndexunion absurdUnionumap catchesUnion_This_That openUnion fromOpenUnionfromOpenUnionOropenUnionPrism openUnionLiftopenUnionMatchcatchesOpenUnion$fFromJSONUnion$fFromJSONUnion0 $fToJSONUnion$fToJSONUnion0 $fOrdUnion $fOrdUnion0 $fEqUnion $fEqUnion0 $fReadUnion $fReadUnion0 $fShowUnion $fShowUnion0 $fNFDataUnion$fNFDataUnion0 $fUElemaa:S $fUElemaa:Z ErrEnvelope SuccEnvelope toErrEnvelopetoSuccEnvelopepureErrEnvelopeenvelope emptyEnvelope fromEnvelope fromEnvelopeMfromEnvelopeOrfromEnvelopeOrMenvelopeToEithereitherToEnvelopeisoEnvelopeEither _SuccEnvelope _ErrEnvelope_ErrEnvelopeErrerrEnvelopeMatchcatchesEnvelope$fSemigroupEnvelope$fMonadFixEnvelope$fMonadEnvelope$fApplicativeEnvelope$fFromJSONEnvelope$fToJSONEnvelope$fFoldableEnvelope$fFunctorEnvelope$fGenericEnvelope$fTraversableEnvelope$fShowEnvelope$fReadEnvelope $fOrdEnvelope $fEqEnvelope$fDataEnvelope$fHasClientTYPE:>$fHasClientTYPE:>0$fHasClientTYPE:>1$fHasClientTYPE:>2$fHasClientTYPE:>3$fHasClientTYPE:>4$fHasClientTYPE:>5CreateRespBodiesForcreateRespBodiesForcreateRespBodyFor$fToSampleEnvelope$fHasDocsTYPE:> $fCreateRespBodiesFor[][]:ctypes $fCreateRespBodiesFork[][]ctypes$fHasDocsTYPE:>0$fHasDocsTYPE:>1$fHasDocsTYPE:>2$fHasServerTYPE:>context$fHasServerTYPE:>context0$fHasServerTYPE:>context1$fHasServerTYPE:>context2$fHasServerTYPE:>context3$fHasServerTYPE:>context4$fHasServerTYPE:>context5#servant-0.11-GzPz0t8nhHYHHB4BMcfKnlServant.API.Sub:>baseGHC.BaseStringghc-prim GHC.TypesIntData.Functor.IdentityIdentityASetteroverMaybe$aeson-1.2.1.0-4jZ3qWGrKsFICNu5rBmefyData.Aeson.Types.FromJSONFromJSONGHC.ReadReadDouble Text.ReadreadcatchesUnionProductEitherData.Aeson.Types.ToJSONToJSON ApplicativeCharServant.API.VerbsVerbServant.API.Alternative:<|>(servant-docs-0.11-5iee4T9pmIPIq4HcJ3O1z3Servant.Docs.InternalHasDocs