h&($      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None &'(./25678<=>?#<portrayA newtype wrapper providing a   instance via J.Beware that instances made this way will not be subject to syntax highlighting or layout, and will be shown as plain text all on one line. It's recommended to derive instances via  0 or hand-write more detailed instances instead.portrayA newtype wrapper providing a   instance via .portrayA newtype wrapper providing a   instance via .portrayGenerics-based deriving of  .;Exported mostly to give Haddock something to link to; use +deriving Portray via Wrapped Generic MyType. portrayGenerics-based deriving of   for product types.;Exported mostly to give Haddock something to link to; use +deriving Portray via Wrapped Generic MyType. portray5A class providing rendering to pseudo-Haskell syntax.Instances should guarantee that they produce output that could, in principle, be parsed as Haskell source that evaluates to a value equal to the one being printed, provided the right functions, quasiquoters, plugins, extensions, etc. are available. Note this doesn't require you to /actually implement/ these functions, quasiquoters, etc; just that it would be feasible to do so.Most of the time, this requirement is dispatched simply by portraying the datum as its actual tree of data constructors. However, since this can sometimes be unwieldy, you might wish to have more stylized portrayals.The most basic form of stylized portrayal is to retract the datum through a function, e.g. portraying 4 :| [2] :: NonEmpty a as fromList [4, 2].For cases where you actually want to escape the Haskell syntax, you can use (or pretend to use) quasiquoter syntax, e.g. portray EAdd (ELit 2) (EVar a) as [expr| 2 + a |]. portray(Portray a list of the given element type9This is part of a Haskell98 mechanism for special-casing  to print differently from other lists; clients of the library can largely ignore it.portrayThe portrayal of a Haskell runtime value as a pseudo-Haskell syntax tree.This can be rendered to various pretty-printing libraries' document types relatively easily; as such, it provides a  lingua franca for integrating with pretty-printers, without incurring heavyweight dependencies.portrayFixed-point of a functor.There are many packages that provide equivalent things, but we need almost nothing but the type itself, so we may as well just define one locally.portrayA 8 along with a field name; one piece of a record literal.portray "hi"; 1 -> "hello".This can be useful in cases where meaningful values effectively appear in negative position in a type, like in a total map or table with non-integral indices.=portrayA tuple.Given Tuple [LitInt 2, LitInt 4], we render something like (2, 4)>portrayA list literal.Given: List [ Apply (Name "These") [LitInt 2, LitInt 4] , Apply (Name "That") [LitInt 6] ] We render something like: [ These 2 4 , That 6 ] ?portrayA binary operator application.The fixity is used to avoid unnecessary parentheses, even in chains of operators of the same precedence.Given: Binop (Name "+") (infixl_ 6) [ Binop (Name "+") (infixl_ 6) [LitInt 2, LitInt 4] , "6" ] We render something like:  2 + 4 + 6@portray9A function or constructor application of arbitrary arity.Although we could have just unary function application, this gives backends a hint about how to format the result: for example, the "pretty" backend prints the function (parenthesized if non-atomic) followed by the arguments indented by two spaces; a chain of unary applications would be needlessly parenthesized.Given: *Apply (Name "These") [LitInt 2, LitInt 4] We render something like  These 2 4, or if line-wrapped: These 2 4 AportrayAn opaque chunk of text included directly in the pretty-printed output.This is used by things like K that don't understand their contents, and will miss out on any syntax-aware features provided by backends.BportrayA character literal.CportrayA string literal.Some backends may be capable of flowing these onto multiple lines automatically, which they wouldn't be able to do with opaque text.Dportray$A rational / floating-point literal.EportrayAn integral literal.FportrayAn identifier, including variable, constructor, and operator names.The + distinguishes constructors, operators, etc. to enable backends to do things like syntax highlighting, without needing to engage in text manipulation to figure out syntax classes.GportrayConstruct the 0 corresponding to e.g.  infix 6 +&&+*HportrayConstruct the 0 corresponding to e.g. infixl 6 +&&+*IportrayConstruct the 0 corresponding to e.g. infixr 6 +&&+*JportrayConvenience for using  and wrapping the result in A.Note this will be excluded from syntax highlighting and layout; see the cautionary text on .KportrayConvenience for building an A from a .Note this will be excluded from syntax highlighting for lack of semantic information; consider using F instead.LportrayConvenience for building a 8 from a .MportrayConvenience for building a ? with a  operator name.Nportray(Portray the type described by the given .This gives the type-level syntax for the type, as opposed to value-level syntax that would construct the .Oportray Construct a  of a  without the "callStack" prefix.PportrayFold a Fix f to a) given a function to collapse each layer.Rportray-Portray a list-like type as "fromList [...]". FEDCBA@?=><;:9876 !"#$%&'()*+,-./012345GHIJKLMNOPFEDCBA@?=><;:9876FEDCBA@?=><;:9876+,-./)*234501GHI !"#$%&'(  JKLMPON Safe-Inferred$      !"#$%&&'()*+,,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~portray-0.2.0-inplace Data.Portray Paths_portrayShowAtom unShowAtom PortrayRatLit PortrayIntLitGPortraygportrayGPortrayProductgportrayProductPortrayportray portrayList Portrayal unPortrayalFixFactorPortrayal _fpFieldName _fpPortrayal PortrayalFNameFLitIntFLitRatFLitStrFLitCharFOpaqueFApplyFBinopFTupleFListF LambdaCaseFRecordFTyAppFTySigFQuotFUnlinesFNestFIdent IdentKindVarIdentConIdentOpIdent OpConIdentInfixityAssocAssocLAssocR AssocNopeNestUnlinesQuotTySigTyAppRecord LambdaCaseTupleListBinopApplyOpaqueLitCharLitStrLitRatLitIntNameinfix_infixl_infixr_showAtomstrAtomstrQuotstrBinop portrayTypeportrayCallStackcata$fPortrayCallStack$fPortrayWrapped$fPortrayCoercion $fPortray:~:$fPortraySomeTypeRep$fPortrayTypeRep$fPortrayTyCon $fPortray[]$fPortrayConst$fPortrayIdentity$fPortrayRatio $fPortrayText $fPortray() $fPortrayChar$fIsStringIdent$fGPortrayProductk:*:$fGPortrayProductkM1$fGPortrayProductkU1$fPortrayWrapped0 $fGPortraykM1$fGPortraykM10$fGPortrayk:+: $fGPortraykV1$fGPortraykM11$fPortrayPortrayIntLit$fPortrayPortrayRatLit$fPortrayShowAtom $fEqPortrayal$fGenericPortrayal$fPortrayPortrayal$fShowPortrayal$fReadPortrayal$fEqPortrayalF$fOrdPortrayalF$fReadPortrayalF$fShowPortrayalF$fFunctorPortrayalF$fFoldablePortrayalF$fTraversablePortrayalF$fGenericPortrayalF$fPortrayPortrayalF$fEqFactorPortrayal$fOrdFactorPortrayal$fReadFactorPortrayal$fShowFactorPortrayal$fFunctorFactorPortrayal$fFoldableFactorPortrayal$fTraversableFactorPortrayal$fGenericFactorPortrayal$fPortrayFactorPortrayal $fEqIdent $fOrdIdent $fReadIdent $fShowIdent$fGenericIdent$fPortrayIdent $fEqIdentKind$fOrdIdentKind$fReadIdentKind$fShowIdentKind$fGenericIdentKind$fPortrayIdentKind$fReadInfixity$fShowInfixity $fEqInfixity $fOrdInfixity$fGenericInfixity$fPortrayInfixity $fReadAssoc $fShowAssoc $fEqAssoc $fOrdAssoc$fGenericAssoc$fPortrayAssoc $fGenericFix$fPortrayNonEmpty $fPortraySeq $fPortraySet $fPortrayMap$fPortrayIntMap$fPortrayProxy $fPortrayBool $fPortrayVoid$fPortrayEither$fPortrayMaybe$fPortray(,,,,)$fPortray(,,,) $fPortray(,,) $fPortray(,)$fPortrayDouble$fPortrayFloat$fPortrayNatural$fPortrayWord64$fPortrayWord32$fPortrayWord16$fPortrayWord8 $fPortrayWord$fPortrayInteger$fPortrayInt64$fPortrayInt32$fPortrayInt16 $fPortrayInt8 $fPortrayInt$fEqFix $fShowFix $fReadFix $fPortrayFixwrapped-0.1.0.0-821e01c561d87627aa60ad688e016aa74366f97d822dafcbf1249d7ebd5813f9 Data.WrappedWrappedbase GHC.GenericsGenericGHC.RealRealIntegralGHC.BaseStringGHC.ShowshowData.Typeable.InternalTypeRepGHC.Stack.Types CallStackversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName