h$25/      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkltextual type classes'Copyright (c) 2019-2021 Travis CardwellMITNone >.ttcThe 8 type class parses a data type from a textual data type.'There are no default instances for the  type class, so that all instances can be customized per project when desired. Instances for some basic data types are available in Data.TTC.Instances.See the uname and prompt example programs in the examples directory.ttcThe 7 type class renders a data type as a textual data type.'There are no default instances for the  type class, so that all instances can be customized per project when desired. Instances for some basic data types are available in Data.TTC.Instances.See the uname and prompt example programs in the examples directory.ttcThe  type class is used to convert between the following textual data types:m (S)Strict n (T)Lazy o (TL)Strict p (BS)Lazy q (BSL) ByteString values are assumed to be UTF-8 encoded text. Invalid bytes are replaced with the Unicode replacement character U+FFFD;. In cases where different behavior is required, process  ByteString values before using this class.The key feature of this type class is that it has a single type variable, making it easy to write functions that accepts arguments and/or returns values that may be any of the supported textual data types.Note that support for additional data types cannot be implemented by writing instances. Adding support for additional data types would require changing the class definition itself. This is the price paid for having only one type variable instead of two.ttc Convert to a mttcConvert to strict nttcConvert to lazy ottcConvert to a strict p ttcConvert to a lazy p ttc0Convert between any supported textual data types ttcConvert from a m ttcConvert from strict n ttcConvert from lazy ottcConvert from a strict pttcConvert from a lazy qttcConvert an argument to a mttcConvert an argument to strict nttcConvert an argument to lazy ottc Convert an argument to a strict pttcConvert an argument to a lazy qttc Convert to a Text rttcConvert from a Text rttc Convert to a  ByteString sttcConvert from a  ByteString sttc Convert to a tttcConvert from a tttc Render to a mttcRender to strict nttcRender to lazy ottcRender to a strict pttcRender to a lazy q ttc Render to a Text r!ttc Render to a  ByteString s"ttc Render to a t#ttc0Render a value to a textual data type using the u instance$ttc Parse from a m%ttcParse from strict n&ttcParse from lazy o'ttcParse from a strict p(ttcParse from a lazy q)ttc Parse to a v type*ttc Parse from a m to a v type+ttcParse from strict n to a v type,ttcParse from lazy o to a v type-ttcParse from a strict p to a v type.ttcParse from a lazy q to a v type/ttcUnsafely parse0ttcUnsafely parse to a m1ttcUnsafely parse to strict n2ttcUnsafely parse to lazy o3ttcUnsafely parse to a strict p4ttcUnsafely parse to a lazy q5ttcParse a value in an enumerationThis function is intended to be used with types that have few choices, as the implementation uses a linear algorithm.See the enum example program in the examples directory.6ttc&Parse a value in an enumeration, with  error messages2The following English error messages are returned:*"invalid {name}" when there are no matches4"ambiguous {name}" when there is more than one match7ttcParse a value using the w instance8ttcParse a value using the w instance, with  error messages0The following English error message is returned:%"invalid {name}" when the parse fails9ttcParse a value to a v type using the w instance:ttc Implement x using 5 String -> THS.Code m a The type of this function in previous versions of GHC is as follows: valid :: (Parse a, THS.Lift a) => String -> TH.Q (TH.TExp a) This function is used the same way in all GHC versions. See the valid, invalid, and lift example programs in the examples6 directory. The following is example usage from the valid example: 2sample :: Username sample = $$(TTC.valid "tcard") =ttc,Validate a constant at compile-time using a  instanceThis function requires a z of the result type. Use > to avoid having to pass a z during constant definition.This function parses the m at compile-time and fails compilation on error. When valid, the m is compiled in, to be parsed again at run-time. Since the result is not compiled in, no y instance is required.This function uses a Template Haskell typed expression. Typed expressions were not supported in haskell-src-exts <1.22.0., which causes problems with old versions of hlint". If the issue affects you, use hlint -i "Parse error" to ignore parse errors or use ? instead.Note that the typed Template Haskell API changed in GHC 9. The type displayed in this documentation is determined by the version of GHC used to build the documentation.:The type of this function in GHC 9 or later is as follows: validOf :: (MonadFail m, THS.Quote m, Parse a) => Proxy a -> String -> THS.Code m a The type of this function in previous versions of GHC is as follows: validOf :: Parse a => Proxy a -> String -> TH.Q (TH.TExp a) This function is used the same way in all GHC versions. See the validof example program in the examples6 directory. The following is example usage from the validof example: sample :: Username sample = $$(TTC.validOf (Proxy :: Proxy Username) "tcard") >ttcMake a valid function using = for the given type Create a valid: function for a type in order to avoid having to write a z when defining constants.This function uses a Template Haskell typed expression. Typed expressions were not supported in haskell-src-exts <1.22.0., which causes problems with old versions of hlint". If the issue affects you, use hlint -i "Parse error" to ignore parse errors or use @ instead.Note that the typed Template Haskell API changed in GHC 9. The type displayed in this documentation is determined by the version of GHC used to build the documentation.The type of the created valid* function in GHC 9 or later is as follows: $funName :: forall m. (MonadFail m, THS.Quote m) => String -> THS.Code m $resultType The type of the created valid5 function in previous versions of GHC is as follows: 5$funName :: String -> TH.Q (TH.TExp $resultType) This function is used the same way in all GHC versions. See the mkvalid example program in the examples6 directory. The following is example usage from the mkvalid example: "$(TTC.mkValid "valid" ''Username)  The created valid& function can then be used as follows: 7sample :: Username sample = $$(Username.valid "tcard") ?ttc,Validate a constant at compile-time using a  instanceThis function requires a z of the result type. Use @ to avoid having to pass a z during constant definition.This function parses the m at compile-time and fails compilation on error. When valid, the m is compiled in, to be parsed again at run-time. Since the result is not compiled in, no y instance is required.See the uvalidof example program in the examples6 directory. The following is example usage from the uvalidof example: sample :: Username sample = $(TTC.untypedValidOf (Proxy :: Proxy Username) "tcard") @ttcMake a valid function using ? for the given type Create a valid: function for a type in order to avoid having to write a z when defining constants.See the mkuvalid example program in the examples6 directory. The following is example usage from the mkuvalid example: )$(TTC.mkUntypedValid "valid" ''Username)  The created valid& function can then be used as follows: 6sample :: Username sample = $(Username.valid "tcard") AttcMake a valid quasi-quoter using ? for the given typeSee the uvalidqq example program in the examples6 directory. The following is example usage from the uvalidqq example: +$(TTC.mkUntypedValidQQ "valid" ''Username)  The created valid& function can then be used as follows: 4sample :: Username sample = [Username.valid|tcard|] 5ttccase-insensitive when {ttcaccept unique prefixes when {ttcinvalid input errorttcambiguous input errorttctextual input to parsettcerror or parsed value6ttc!name to include in error messagesttccase-insensitive when {ttcaccept unique prefixes when {ttctextual input to parsettcerror or parsed value7ttcinvalid input errorttctextual input to parsettcerror or parsed value8ttc!name to include in error messagesttctextual input to parsettcerror or parsed value9ttctextual input to parsettcerror or parsed value:ttccase-insensitive when {ttcaccept unique prefixes when {    !"#$%&'()*+,-./0123456789:;<=>?@A   !"#$%&'()*+,-./0123456789:;<=>?@Ainstances for basic data types'Copyright (c) 2019-2021 Travis CardwellMITNone >/      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstusvuwxywzys{|w}|w~ppppp"ttc-0.4.0.0-EihRgDnmyIa5dltLUHZUoJData.TTCData.TTC.InstancesParseparseRenderrenderTextualtoStoTtoTLtoBStoBSLconvertfromSfromTfromTLfromBSfromBSLasSasTasTLasBSasBSLtoTLBfromTLBtoBSBfromBSBtoSBSfromSBSrenderSrenderTrenderTLrenderBS renderBSL renderTLB renderBSB renderSBSrenderWithShowparseSparseTparseTLparseBSparseBSL parseMaybe parseMaybeS parseMaybeT parseMaybeTL parseMaybeBS parseMaybeBSL parseUnsafe parseUnsafeS parseUnsafeT parseUnsafeTL parseUnsafeBSparseUnsafeBSL parseEnum parseEnum' parseWithReadparseWithRead'maybeParseWithRead readsEnumreadsWithParsevalidvalidOfmkValiduntypedValidOfmkUntypedValidmkUntypedValidQQ$fTextualByteString$fTextualByteString0 $fTextualText$fTextualText0 $fTextual[] $fRenderText $fParseText $fRenderText0 $fParseText0$fRenderByteString$fParseByteString$fRenderByteString0$fParseByteString0 $fRender[] $fParse[]$fRenderWord64 $fParseWord64$fRenderWord32 $fParseWord32$fRenderWord16 $fParseWord16 $fRenderWord8 $fParseWord8 $fRenderWord $fParseWord$fRenderInteger$fParseInteger $fRenderInt64 $fParseInt64 $fRenderInt32 $fParseInt32 $fRenderInt16 $fParseInt16 $fRenderInt8 $fParseInt8 $fRenderInt $fParseInt $fRenderFloat $fParseFloat$fRenderDouble $fParseDouble $fRenderChar $fParseCharbaseGHC.BaseString text-1.2.3.2Data.Text.InternalTextData.Text.Internal.Lazybytestring-0.10.10.0Data.ByteString.Internal ByteStringData.ByteString.Lazy.InternalData.Text.Internal.BuilderBuilder Data.ByteString.Builder.InternalData.ByteString.Short.InternalShortByteStringGHC.ShowShow GHC.MaybeMaybeGHC.ReadReadText.ParserCombinators.ReadPReadStemplate-haskellLanguage.Haskell.TH.SyntaxLift Data.ProxyProxyghc-prim GHC.TypesTrue