úÎj _i²      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ­ ® ¯ ° ± BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNoneQV \    4Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownSafe&'+,-.;<=>?AFQSTVcv  ) 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 a .Convert a 3-tuple into a .Convert a tuple into a .Convert a single value into a .Convert a 4-tuple into an  .Convert a 3-tuple into an  .Convert a tuple into an  .Convert a single value into an  .     Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownSafe,-FST&XUChange 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&'+,-.0;<=>?AFQSTV]c§p  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".\Since a union with an empty list of labels is uninhabited, we can recover any type from it./Map 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"0!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 0 becomes the following:  0 :: (² (´ -> ³), ² (³ -> ³ )) -> & ² '[´, ³ ] -> ² ³  Checkout 9 for more examples.1Lens-compatible  for '.ExamplesUse 1 to construct a &:4review _This (Just "hello") :: Union Maybe '[String] Just "hello"Use 1 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 1 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)Nothing2Lens-compatible  for (.ExamplesUse 2 to construct a &:4let u = This (Just "hello") :: Union Maybe '[String]/review _That u :: Union Maybe '[Double, String] Just "hello"Use 2 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 2 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])Nothing3Case 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"4This 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"5Flipped version of 4.6 Just like # but for  .7 Just like $ but for  . Creating an  :let string = "hello" :: String8openUnionLift string :: OpenUnion '[Double, String, Int]Identity "hello"8 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 StringNothing9"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 9 than 3.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 9 becomes the following:  9 :: (´ -> 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.B'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"CThis will always fail, since & f '[] is effectively Void. !"#$%&'()*+,-./0123456789&'(-0./12)*+,"#$%! 3456789"#$%&'()*+Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone ,-16FST·9i Used by the  HasServer and  HasClient instances for j es º api º apis to detect j es followed immediately by l e.j<This is used internally and should not be used by end-users.kkr 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 k:$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 llZ 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] Int#JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl#lkjihgfedcba`_^]\[ZYXWVUTSRQPONMKLJKLDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone&'-.013456<QV.²nThis n. 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 n '[³, ¸] ()(, we know that the envelope could be a p and contain (). Or it could be a o that contains either a ³ or a ¸6. It might be simpler to think of it as a type like » ³ (» ¸ ()).An n can be created with the q and r functions. The s ~, , and €% can be used to get values out of an n.q Create an o from a member of the  .'For instance, here is how to create an o that contains a ¸:let double = 3.5 :: Double:toErrEnvelope double :: Envelope '[String, Double, Int] ()ErrEnvelope (Identity 3.5)rThis is a function to create a p.3toSuccEnvelope "hello" :: Envelope '[Double] StringSuccEnvelope "hello"ss is q lifted up to an ½.tt is r lifted up to an ½.uCase analysis for ns.Examples$Here is an example of matching on a p:Blet env = toSuccEnvelope "hello" :: Envelope '[Double, Int] String&envelope (const "not a String") id env"hello"$Here is an example of matching on a o:let double = 3.5 :: DoubleAlet env' = toErrEnvelope double :: Envelope '[Double, Int] String'envelope (const "not a String") id env'"not a String"v Unwrap an n that cannot contain an error.Examples7let env = toSuccEnvelope "hello" :: Envelope '[] StringemptyEnvelope env"hello"w Just like  but for n.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"xLifted version of w.yFlipped version of w.zFlipped version of x.{ Convert an n to an ».| Convert an » to an n.}Lens-compatible  from n to ».~Lens-compatible  to pull out an a from a p.ExamplesUse ~ to construct an n:9review _SuccEnvelope "hello" :: Envelope '[Double] StringSuccEnvelope "hello"Use ~ to try to destruct an n 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 StringNothingLens-compatible  to pull out an   es from a o.Most users will not use , but instead €.ExamplesUse  to construct an n:let string = "hello" :: StringGreview _ErrEnvelope (openUnionLift string) :: Envelope '[String] DoubleErrEnvelope (Identity "hello")Use  to try to destruct an n 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 o.Most users will use € instead of .ExamplesUse € to construct an n:let string = "hello" :: String:review _ErrEnvelopeErr string :: Envelope '[String] DoubleErrEnvelope (Identity "hello")Use € to try to destruct an n 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 DoubleNothingPull out a specific e from an o.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 nQ. This method uses a tuple containing handlers for each potential value of the n$. This is somewhat similar to the   function.When working with an nG with a large number of possible error types, it can be easier to use ‚ than u.Examples"Here is an example of handling an pE 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 oZ 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 n like n '[´, ³] ¸, the type of ‚ becomes the following:  ‚ :: (´ -> x, ³ -> x) -> (¸ -> x) -> n '[´, ³] ¸ -> x "Here is an example of handling an oP 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 n like n '[´, ³, ¾] ¸, the type of ‚ becomes the following:  ‚ :: (´ -> x, ³ -> x, ¾ -> x) -> (¸ -> x) -> n '[´, ³, ¾] ¸ -> x "Here is an example of handling an oY 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 n like n '[´] ¸, the type of ‚ becomes the following:  ‚ :: (´ -> x) -> (¸ -> x) -> n '[´] ¸ -> x ‡'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  .ˆThis ¼ instance encodes an nA as an object with one of two keys depending on whether it is a p or an o.Here is an example of a p:let string = "hello" :: String<let env = toSuccEnvelope string :: Envelope '[Double] StringputByteStrLn $ encode env{"data":"hello"}Here is an example of a o:let double = 3.5 :: Double<let env' = toErrEnvelope double :: Envelope '[Double] StringputByteStrLn $ encode env' {"err":3.5}nopqrstuvwxyz{|}~€‚noprqtsuvwyxz‚~€{|}nopDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone,-.;<=>?FQSTV:›šWhen kC comes before any combinator, push it down so it is closer to the ¿.›When a l e comes immediately after a j es, Snoc the e onto the es. Otherwise, if l eI comes before any other combinator, push it down so it is closer to the ¿.œWhen k comes before À, push k into each branch of the API.When j es comes before À, push j es into each branch of the API.žWhen k comes before a ¿, change it into the same ¿ but returning an n '[].ŸWhen j es comes before a ¿, change it into the same ¿ but returning an n es.  Change a l into j.’“”•–—˜ Ÿžœ›š™’“”•–—˜ Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone,-.;<=>?FNQSTVJk ¡Create samples for a given list of types, under given ctypes.AAdditional instances of this class should not need to be created.£Create a sample for a given e under given ctypes.¤We can generate a sample of an n 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 j es.¥When a l e comes immediately after a j es,  the e onto the es.¦When k comes before a ¿+, generate the documentation for the same ¿, but returning an n '[].§ Change a l into j.¨3Create a response body for each of the error types.©&An empty list of types has no samples.ªWhen j es comes before a ¿+, generate the documentation for the same ¿, but returning an n es-. Also add documentation for the potential es.¡¢£ §ª¦¡¢©¨£¥¤¡¢ Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone,-.;<=>?FQSTVUì«When kI comes before any other combinator, push it down so it is closer to the ¿.¬When a l e comes immediately after a j es, Snoc the e onto the es. Otherwise, if l eI comes before any other combinator, push it down so it is closer to the ¿.­When k comes before À, push k into each branch of the API.®When j es comes before À, push j es into each branch of the API.¯When k comes before a ¿, change it into the same ¿ but returning an n '[].°When j es comes before a ¿, change it into the same ¿ but returning an n es.± Change a l into j.±°¯®­¬«Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNoneW#JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklDennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNoneYž^  !"#$%&'()+*,-./0123456789JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklnopqrstuvwxyz{|}~€‚Dennis Gosnell 2017BSD3(Dennis Gosnell (cdep.illabout@gmail.com) experimentalunknownNone\›Y  !"#$%&'()*+,-./0123456789KLMNOPQRSTUVWXYZ[\]^_`abcdefghklnopqrstuvwxyz{|}~€‚YlkKLhgfedcba`_^]\[ZYXWVUTSRQPONMnoprqtsuvwyxz‚~€{|} 3456789&'(-./012)*+,"#$%!    !"#$%&'()*+,-./0123456789:;<=>? @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶· ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æ Ç ÈÉÊËÉÌÍÎÏÐÉÌÑÒÓÔÉÕÖÎÏ×ÉØÙÚÛÜÉÝÒÞßÉÌàÎÏáÚâãÚäåæçèé9servant-checked-exceptions-1.1.0.0-IByHlf9lS1N9CgOD09jp5hServant.Checked.Exceptions)Servant.Checked.Exceptions.Internal.Prism+Servant.Checked.Exceptions.Internal.Product(Servant.Checked.Exceptions.Internal.Util)Servant.Checked.Exceptions.Internal.Union/Servant.Checked.Exceptions.Internal.Servant.API,Servant.Checked.Exceptions.Internal.Envelope2Servant.Checked.Exceptions.Internal.Servant.Server0Servant.Checked.Exceptions.Internal.Servant.Docs2Servant.Checked.Exceptions.Internal.Servant.ClientUnionControl.Exceptioncatches Data.TextTextEnvelopeServantHandlerpureSuccEnvelope Data.Either fromEither+Servant.Checked.Exceptions.Internal.Servant#Servant.Checked.Exceptions.Internal&http-types-0.11-2S6BQkKLMX49qmdMBIfo0RNetwork.HTTP.Types.StatusStatusPrism'PrismIsoisoprismprism'reviewpreview<>~ ToOpenProduct toOpenProduct OpenProduct ToProduct toProductProductNilConstupleToProducttupleToOpenProduct $fShowProduct$fShowProduct0$fToProductu(,,,)f:$fToProductu(,,)f:$fToProductu(,)f:$fToProductuff:$fToOpenProduct(,,,):$fToOpenProduct(,,):$fToOpenProduct(,):$fToOpenProducta:ReturnXSnoc 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 AllErrStatus ErrStatus toErrStatusGetPartialContentWithErrPutResetContentWithErrPatchResetContentWithErrDeleteResetContentWithErrPostResetContentWithErrGetResetContentWithErrPutNoContentWithErrPatchNoContentWithErrDeleteNoContentWithErrPostNoContentWithErrGetNoContentWithErrPutNonAuthoritativeWithErrPatchNonAuthoritativeWithErrDeleteNonAuthoritativeWithErrPostNonAuthoritativeWithErrGetNonAuthoritativeWithErrPutAcceptedWithErrPatchAcceptedWithErrDeleteAcceptedWithErrPostAcceptedWithErrGetAcceptedWithErrPostCreatedWithErr PatchWithErr DeleteWithErr PutWithErr PostWithErr GetWithErr VerbWithErrThrowingNonterminalThrowingNoThrowThrows$fGenericVerbWithErr ErrEnvelope SuccEnvelope toErrEnvelopetoSuccEnvelopepureErrEnvelopeenvelope emptyEnvelope fromEnvelope fromEnvelopeMfromEnvelopeOrfromEnvelopeOrMenvelopeToEithereitherToEnvelopeisoEnvelopeEither _SuccEnvelope _ErrEnvelope_ErrEnvelopeErrerrEnvelopeMatchcatchesEnvelope$fSemigroupEnvelope$fMonadFixEnvelope$fMonadEnvelope$fApplicativeEnvelope$fFromJSONEnvelope$fToJSONEnvelope$fFoldableEnvelope$fFunctorEnvelope$fGenericEnvelope$fTraversableEnvelope$fShowEnvelope$fReadEnvelope $fOrdEnvelope $fEqEnvelope$fDataEnvelope methodRouter allowedMethodallowedMethodHead methodCheck acceptCheck getErrStatusprocessMethodRouter!$fHasServerTYPEVerbWithErrcontext$fHasServerTYPE:>context$fHasServerTYPE:>context0$fHasServerTYPE:>context1$fHasServerTYPE:>context2$fHasServerTYPE:>context3$fHasServerTYPE:>context4$fHasServerTYPE:>context5CreateRespBodiesForcreateRespBodiesForcreateRespBodyFor$fToSampleEnvelope$fHasDocsTYPE:>$fHasDocsTYPE:>0$fHasDocsTYPE:>1 $fCreateRespBodiesFor[][]:ctypes $fCreateRespBodiesFor[]k[]ctypes$fHasDocsTYPE:>2$fHasClientm:>$fHasClientm:>0$fHasClientm:>1$fHasClientm:>2$fHasClientm:>3$fHasClientm:>4$fHasClientm:>5baseData.Functor.IdentityIdentityGHC.BaseStringghc-prim GHC.TypesIntMaybe$aeson-1.2.4.0-BCbjHKPmbhgK9ldqys4mc6Data.Aeson.Types.FromJSONFromJSONGHC.ReadReadDouble Text.Readread%servant-0.12.1-BoAxAcptvA8CiY7ha2syxAServant.API.Sub:>EitherData.Aeson.Types.ToJSONToJSON ApplicativeCharServant.API.VerbsVerbServant.API.Alternative:<|>*servant-docs-0.11.1-7T4v3MQ3b5Z9druukoCW2EServant.Docs.InternalHasDocs