h&>q8      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred""%&()*01589:;?7tportrayA newtype wrapper providing a  instance via o.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 .Discouraged for new uses: use  instead if possible.portrayA newtype wrapper providing a  instance via . portray&A newtype wrapper providing a generic  instance sans records. portrayGenerics-based deriving of .;Exported mostly to give Haddock something to link to; use +deriving Portray via Wrapped Generic MyType. portray portray)A "lens"-compatible zero-dependency lens.This is only exported to appease Haddock, and the name doesn't have any particular meaning other than a best-effort attempt to avoid creating name clashes when the module is imported unqualified; this is just Lens'.portrayConfiguration for w / v.To facilitate backwards compatibility, the constructor and fields are unexported; instead, start from s6 and adjust using the provided lens(es) or setter(s).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.portrayportrayAn identifier or operator name.@portray$The kind of identifier a particular > represents.Eportray:Associativity and binding precedence of an infix operator.Gportray#Associativity of an infix operator.Kportray6Indent a sub-expression by the given number of spaces.This is meant for use inside M2, where it makes sense to use non-Haskell syntax.Lportray4A series of lines arranged vertically, if supported.This is meant for use inside M2, where it makes sense to use non-Haskell syntax.MportrayA quasiquoter expression.Given: Quot (Opaque "expr") (Binop (Opaque "+") _ [Opaque "x", Opaque "!y"]) We render something like [expr| x + !y |]NportrayAn explicit type signature.Given 8TySig (Name "Proxy") [Apply (Name "Proxy") [Name "Int"]] , we render Proxy :: Proxy IntOportrayA type application.Given !TyApp (Name "Proxy") (Name "Int") , we render  Proxy @IntPportrayA record literal.Given: Record (Name "Identity") [FactorPortrayal (Name "runIdentity") (LitInt 2)] We render something like: !Identity { runIdentity = 2 } QportrayA lambda-case.Given LambdaCase [(LitInt 0, LitStr "hi"), (LitInt 1, LitStr "hello")], we render something like \case 0 -> "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.RportrayA tuple.Given Tuple [LitInt 2, LitInt 4], we render something like (2, 4)SportrayA 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 ] TportrayA 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 + 6Uportray9A 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 VportrayAn opaque chunk of text included directly in the pretty-printed output.This is used by things like p that don't understand their contents, and will miss out on any syntax-aware features provided by backends.WportrayA character literal.XportrayA 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.Yportray1A special (infinite or NaN) floating-point value.Zportray$A rational / floating-point literal.[portray$A rational / floating-point literal.Discouraged for new uses; use Z instead if possible.\portray&An integral literal in the given base.]portrayAn integral literal.This pattern does not round-trip, as it ignores the base when matching and provides base 10 when constructing. Prefer \ when matching if the base is relevant, but it should be fine to construct by this pattern if base 10 is desired.^portrayAn 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._portrayBackwards compat: rational values including NaNs and infinities.When matching, this ignores the format; when constructing, it chooses according to the same criteria as .`portrayBackwards compat:  without the base.When matching, this ignores the base; when constructing, it chooses decimal.aportrayConstruct the E corresponding to e.g.  infix 6 +&&+*bportrayConstruct the E corresponding to e.g. infixl 6 +&&+*cportrayConstruct the E corresponding to e.g. infixr 6 +&&+*dportray.Convert the given base to its numerical value.eportrayShow  non-negative ( numbers in the given conventional base.fportray-Format an integral literal in the given base.gportrayThe syntactic marker prefix for the given base, e.g. "0x" for hex.hportray Extract a  value representation of the 4.iportrayConvert a finite  value to a 4.jportrayNormalize a float literal to have no leading zero digits, if nonzero.kportray'Trim trailing zeros of a float literal.These trailing zeros are presumed to mean that the value is given to a particular level of precision, so trimming them before output means the output no longer includes this implied precision information.lportrayA default heuristic for whether a literal should use scientific notation. This returns  when using scientific notation would let us avoid padding the digits with more than one extra zero.mportray Format a 4 to  in the conventional way.nportray Format a 0 to  in the conventional way.oportrayConvenience for using  and wrapping the result in V.Note this will be excluded from syntax highlighting and layout; see the cautionary text on .pportrayConvenience for building an V from a .Note this will be excluded from syntax highlighting for lack of semantic information; consider using ^ instead.qportrayConvenience for building a M from a .rportrayConvenience for building a T with a  operator name.portray#Turn a field selector name into an >.sportrayDefault .Uses record syntax when the constructor was defined with record syntax.tportray8Enable or disable record syntax for record constructors.uportray.Disable record syntax for record constructors.This is primarily provided as a convenience for users with no dependency on a lens library, since it'd otherwise be clumsy to use the lens.vportray  True, for backwards compatibility.wportrayAn implementation of  derived from a type's  instance."This is also made available as an instance Portray ( Generic a) for use with  DerivingVia, but this standalone-function form might be useful for e.g. deriving only some constructors' portrayals from ! while writing others' manually.xportray Convert a  to a 4! representing its full precision.yportray(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 .zportray Construct a  of a  without the "callStack" prefix.{portrayFold a Fix f to a) given a function to collapse each layer.}portray-Portray a list-like type as "fromList [...]". ^]\[ZYXWVUTRSQPONMLK`_ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJabcdefghijklmnopqrstuvwxyz{^]\[ZYXWVUTRSQPONMLK^]\[ZYXWVUTRSQPONMLK@ABCD>?9:;<=dgf45678ixhljkm0123nGHIJEFabc`_ !"#$%&'()*+,-./`_ w vstu opqr{zye       !"#$%&'()*+,-./001234567899:;<=>??@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~$portray-0.3.0-A85oeHMPvLbKU0clB9shcy Data.PortrayNumeric showGFloatShowAtom unShowAtomPortrayFloatLit PortrayRatLit PortrayIntLitPortrayDataConsGPortray gportrayCfgAnLensGPortrayConfigGPortrayProductgportrayProductPortrayportray portrayList Portrayal unPortrayalFixFactorPortrayal _fpFieldName _fpPortrayal PortrayalFNameF LitIntBaseF LitFloatF SpecialFloatFLitStrFLitCharFOpaqueFApplyFBinopFTupleFListF LambdaCaseFRecordFTyAppFTySigFQuotFUnlinesFNestFSpecialFloatValNaNInfinity infNegate FloatLiteralflNegateflDigits flExponentBaseBinaryOctalDecimalHexIdent IdentKindVarIdentConIdentOpIdent OpConIdentInfixityAssocAssocLAssocR AssocNopeNestUnlinesQuotTySigTyAppRecord LambdaCaseTupleListBinopApplyOpaqueLitCharLitStr SpecialFloatLitFloatLitRat LitIntBaseLitIntNameLitRatFLitIntFinfix_infixl_infixr_ baseToInt showIntInBase formatIntLit basePrefixfloatLiteralToRationalfloatToLiteralnormalizeFloatLit trimFloatLitshouldUseScientificformatFloatLitformatSpecialFloatshowAtomstrAtomstrQuotstrBinopdefaultGPortrayConfiguseRecordSyntaxsuppressRecordSyntaxgportraygenericPortrayfixedToLiteral portrayTypeportrayCallStackcata$fPortrayCallStack$fPortrayWrapped$fPortrayCoercion $fPortray:~:$fPortraySomeTypeRep$fPortrayTypeRep$fPortrayTyCon$fPortrayProduct $fPortraySum $fPortray[]$fPortrayConst$fPortrayIdentity$fPortrayRatio$fPortrayShortByteString$fPortrayByteString$fPortrayByteString0 $fPortrayText $fPortray() $fPortrayChar$fPortrayFixed$fIsStringIdent$fGPortrayProductk:*:$fGPortrayProductkM1$fGPortrayProductkU1$fPortrayWrapped0 $fGPortraykM1$fGPortrayk:+: $fGPortraykV1$fGPortraykM10$fPortrayPortrayDataCons$fPortrayPortrayIntLit$fPortrayPortrayRatLit$fPortrayPortrayFloatLit$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$fEqSpecialFloatVal$fOrdSpecialFloatVal$fReadSpecialFloatVal$fShowSpecialFloatVal$fGenericSpecialFloatVal$fPortraySpecialFloatVal$fEqFloatLiteral$fOrdFloatLiteral$fReadFloatLiteral$fShowFloatLiteral$fGenericFloatLiteral$fPortrayFloatLiteral$fEqBase $fOrdBase $fReadBase $fShowBase $fGenericBase $fPortrayBase$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 $fPortrayFix&wrapped-0.1.0.1-9FyQg8hXIXV2Wkan5qVZOr Data.WrappedWrappedbase GHC.GenericsGeneric GHC.Float RealFloatGHC.RealRealIntegralGHC.BaseStringRationalghc-prim GHC.TypesTrue text-1.2.5.0Data.Text.InternalTextGHC.ShowshowselIdent Data.FixedFixedData.Typeable.InternalTypeRepGHC.Stack.Types CallStack