úÎSÇLH€      !"#$%&'()*+,-./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.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)Refl/Case 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"0\Since a union with an empty list of labels is uninhabited, we can recover any type from it.1Map 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"2!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 2 becomes the following:  2 :: (ƒ (‚ -> ), ƒ ( ->  )) -> ( ƒ '[‚,  ] -> ƒ   Checkout ; for more examples.3Lens-compatible  for ).ExamplesUse 3 to construct a (:4review _This (Just "hello") :: Union Maybe '[String] Just "hello"Use 3 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 3 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)Nothing4Lens-compatible  for *.ExamplesUse 4 to construct a (:4let u = This (Just "hello") :: Union Maybe '[String]/review _That u :: Union Maybe '[Double, String] Just "hello"Use 4 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 4 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])Nothing5Case 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"6This 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"7Flipped version of 6.8 Just like % but for ".9 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 5.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.D'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"EThis will always fail, since ( f '[] is effectively Void.+"#$%&'()*+,-./01‹23456789:;<=>?@ABCDEFGHIJK"#$%&'()*+,-./0123456789:;()*/20134+,-.$%&'#"56789:;$"#$%&'()*+,-./01‹23456789:;<=>?@ABCDEFGHIJKDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone%&-/02345:OTLThis L. 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 L '[, ‰] ()(, we know that the envelope could be a N and contain (). Or it could be a M that contains either a  or a ‰6. It might be simpler to think of it as a type like Œ  (Œ ‰ ()).An L can be created with the O and P functions. The s [, \, and ]% can be used to get values out of an L.O Create an M from a member of the ".'For instance, here is how to create an M that contains a ‰:let double = 3.5 :: Double:toErrEnvelope double :: Envelope '[String, Double, Int] ()ErrEnvelope (Identity 3.5)PThis is a function to create a N.3toSuccEnvelope "hello" :: Envelope '[Double] StringSuccEnvelope "hello"QQ is O lifted up to an Ž.RR is P lifted up to an Ž.SCase analysis for Ls.Examples$Here is an example of matching on a N:Blet env = toSuccEnvelope "hello" :: Envelope '[Double, Int] String&envelope (const "not a String") id env"hello"$Here is an example of matching on a M:let double = 3.5 :: DoubleAlet env' = toErrEnvelope double :: Envelope '[Double, Int] String'envelope (const "not a String") id env'"not a String"T Just like  but for L.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"ULifted version of T.VFlipped version of T.WFlipped version of U.X Convert an L to an Œ.Y Convert an Œ to an L.ZLens-compatible  from L to Œ.[Lens-compatible  to pull out an a from a N.ExamplesUse [ to construct an L:9review _SuccEnvelope "hello" :: Envelope '[Double] StringSuccEnvelope "hello"Use [ to try to destruct an L 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 M.Most users will not use \, but instead ].ExamplesUse \ to construct an L:let string = "hello" :: StringGreview _ErrEnvelope (openUnionLift string) :: Envelope '[String] DoubleErrEnvelope (Identity "hello")Use \ to try to destruct an L 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 M.Most users will use ] instead of \.ExamplesUse ] to construct an L:let string = "hello" :: String:review _ErrEnvelopeErr string :: Envelope '[String] DoubleErrEnvelope (Identity "hello")Use ] to try to destruct an L 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 M.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 DoubleNothing_"An alternate case anaylsis for an LQ. This method uses a tuple containing handlers for each potential value of the L$. This is somewhat similar to the   function.When working with an LG with a large number of possible error types, it can be easier to use _ than S.Examples"Here is an example of handling an NE 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 MZ 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 L like L '[‚, ] ‰, the type of _ becomes the following:  _ :: (‚ -> x,  -> x) -> (‰ -> x) -> L '[‚, ] ‰ -> x "Here is an example of handling an MP 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 L like L '[‚, , ] ‰, the type of _ becomes the following:  _ :: (‚ -> x,  -> x,  -> x) -> (‰ -> x) -> L '[‚, , ] ‰ -> x "Here is an example of handling an MY 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 L like L '[‚] ‰, the type of _ becomes the following:  _ :: (‚ -> x) -> (‰ -> x) -> L '[‚] ‰ -> x d'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  .eThis  instance encodes an LA as an object with one of two keys depending on whether it is a N or an M.Here is an example of a N:let string = "hello" :: String<let env = toSuccEnvelope string :: Envelope '[Double] StringputByteStrLn $ encode env{"data":"hello"}Here is an example of a M:let double = 3.5 :: Double<let env' = toErrEnvelope double :: Envelope '[Double] StringputByteStrLn $ encode env' {"err":3.5}LMNOPQRSTUVWXYZ[\]^_`abcdeLMNOPQRSTUVWXYZ[\]^_LMNPORQSTVUW^_[\]XYZLMNOPQRSTUVWXYZ[\]^_`abcdeDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone+,-9:;<=DOQRToWhen 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 .pWhen  es comes before ‘, push  es into each branch of the API.qWhen  es comes before a , change it into the same  but returning an L es.r Change a  into .opqrrqpoopqrDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone+,-9:;<=DLOQRTsCreate samples for a given list of types, under given ctypes.AAdditional instances of this class should not need to be created.uCreate a sample for a given e under given ctypes.vWe can generate a sample of an L 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.wWhen a  e comes immediately after a  es,  the e onto the es.x3Create a response body for each of the error types.y&An empty list of types has no samples.zWhen  es comes before a +, generate the documentation for the same , but returning an L es-. Also add documentation for the potential es.{ Change a  into . stuvwxyz{stu {zstyxuwvstuvwxyz{ Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone+,-9:;<=DOQRT|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  es comes before ‘, push  es into each branch of the API.~When  es comes before a , change it into the same  but returning an L es. Change a  into .|}~~}||}~Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNoneDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone= "#$%&'()*+-,./0123456789:;LMNOPQRSTUVWXYZ[\]^_Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone8 "#$%&'()*+,-./0123456789:;LMNOPQRSTUVWXYZ[\]^_8LMNPORQSTVUW^_[\]XYZ"56789:;()*/01234+,-.$%&'#  “ !"#$%&'()*+,-./0123456789:; <=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ   ‘ ’“”•–—˜™š›–œžŸ–— Ą˘Ł–¤Ľ™šŚ–§¨Š–ŞĄŤŹ–—­™šŽ“Ż°“ą˛ł´ľś9servant-checked-exceptions-0.4.0.0-IRzW804UdFu621XTGvOHnb(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.ServerUnionControl.Exceptioncatches Data.TextText Data.Either fromEither+Servant.Checked.Exceptions.Internal.Servant#Servant.Checked.Exceptions.InternalServant.Checked.ExceptionsReturnXSnocThrowingNonterminalThrowingThrows 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:ZEnvelope ErrEnvelope SuccEnvelope toErrEnvelopetoSuccEnvelopepureErrEnvelopepureSuccEnvelopeenvelope 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:>2CreateRespBodiesForcreateRespBodiesForcreateRespBodyFor$fToSampleEnvelope$fHasDocsTYPE:> $fCreateRespBodiesFor[][]:ctypes $fCreateRespBodiesFork[][]ctypes$fHasDocsTYPE:>0$fHasDocsTYPE:>1$fHasServerTYPE:>context$fHasServerTYPE:>context0$fHasServerTYPE:>context1$fHasServerTYPE:>context2#servant-0.10-KCcrDEDykYhDOzA5ypdMuuServant.API.Sub:>baseGHC.BaseStringghc-prim GHC.TypesIntData.Functor.IdentityIdentityASetteroverMaybe$aeson-1.2.0.0-EbPrqFF8uEn6JTr1dCEeDTData.Aeson.Types.FromJSONFromJSONGHC.ReadReadDouble Text.ReadreadcatchesUnionProductEitherData.Aeson.Types.ToJSONToJSON ApplicativeCharServant.API.VerbsVerbServant.API.Alternative:<|>(servant-docs-0.10-3cVUByG110ABWnlNH4WhiaServant.Docs.InternalHasDocs