g]a      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`None/79;a is the O type for all lists, so we need to make sure all the required instances exist.    None!"09;<=LOTCopied from haskell-src-metaNormally just b2, this can modify the types during the traversal.[This is passed every type that is encountered. The methods below are called from doApply. NWhen a ListT type is encountered this is passed the type and the element type!|When a TupleT type is encountered this is called once for each element, with the type, element type, and element position."bWhen a field is encountered this is called with all the field info - type name, constructor countpositionname, field countpositiontype/maybe name.#+Called when a type variable is encountered.3Input is a list of type variable bindings (such as those appearing in a Dec) and the current stack of type parameters applied by AppT. Builds a function that expands a type using those bindings and pass it to an action.4Pretty print a c value on a single line with each block of white space (newlines, tabs, etc.) converted to a single space, and all the module qualifiers removed from the names. (If the data type has no d2 values the friendlyNames function has no effect.)6/Pretty print with friendly names and wide linese#Helper function for pprint1 et. al.fJMake a template haskell value more human reader friendly. The result almost certainly won't be compilable. That's ok, though, because the input is usually uncompilable - it imports hidden modules, uses infix operators in invalid positions, puts module qualifiers in places where they are not allowed, and maybe other things.9JOutput a verbosity controlled error message with the current indentation.:Indent the lines of a message.- !"#$%&'()*+,-./01g2hi34567ef89:;<=% !"#$%&'()*+,-./0123456789:%1./03 !"#2$%&'()*+,-845679: !"#$ %&'()*+,-./01g2hi34567ef89:;<=None !"9;OTj.The reader monad type used while generating a  TypeGraph.k"Positional type parameters. When AppT a b is encountered, b is pushed onto the stack and a is processed. Then when a type name is reified and is found to have type variables, they are bound to the type parameters which are on the stack.lmnojpkqrstuvwx?@ABC?? lmnojpkqrstuvwx?@ABCNoneHNFIXME - Bogus reimplementation of the hidden Data.SafeCopy.unVersion functionIDerive an instance of y.When serializing, we put a Word8 describing the constructor (if the data type has more than one constructor). For each type used in the constructor, we call z (which immediately serializes the version of the type). Then, for each field in the constructor, we use one of the put functions obtained in the last step.:For example, given the data type and the declaration below 4data T0 b = T0 b Int deriveSafeCopy 1 'base ''T0  we generate &instance (SafeCopy a, SafeCopy b) => SafeCopy (T0 b) where putCopy (T0 arg1 arg2) = contain $ do put_b <- getSafePut put_Int <- getSafePut put_b arg1 put_Int arg2 return () getCopy = contain $ do get_b <- getSafeGet get_Int <- getSafeGet return T0 <*> get_b <*> get_Int version = 1 kind = base >And, should we create another data type as a newer version of T0 , such as data T a b = C a a | D b Int deriveSafeCopy 2 'extension ''T instance SafeCopy b => Migrate (T a b) where type MigrateFrom (T a b) = T0 b migrate (T0 b i) = D b i  we generate ~instance (SafeCopy a, SafeCopy b) => SafeCopy (T a b) where putCopy (C arg1 arg2) = contain $ do putWord8 0 put_a <- getSafePut put_a arg1 put_a arg2 return () putCopy (D arg1 arg2) = contain $ do putWord8 1 put_b <- getSafePut put_Int <- getSafePut put_b arg1 put_Int arg2 return () getCopy = contain $ do tag <- getWord8 case tag of 0 -> do get_a <- getSafeGet return C <*> get_a <*> get_a 1 -> do get_b <- getSafeGet get_Int <- getSafeGet return D <*> get_b <*> get_Int _ -> fail $ "Could not identify tag \"" ++ show tag ++ "\" for type Main.T " ++ "that has only 2 constructors. " ++ "Maybe your data is corrupted?" version = 2 kind = extension FNote that by using getSafePut, we saved 4 bytes in the case of the C constructor. For D and T0, we didn't save anything. The instance derived by this function always use at most the same space as those generated by K&, but never more (as we don't call 'getSafePut'/'getSafeGet' for types that aren't needed).Note that you may use K+ with one version of your data type and I, in another version without any problems.KDerive an instance of yR. The instance derived by this function is simpler than the one derived by I in that we always use { and | (instead of z and }).When serializing, we put a Word8 describing the constructor (if the data type has more than one constructor) and, for each field of the constructor, we use {.:For example, given the data type and the declaration below Adata T a b = C a a | D b Int deriveSafeCopySimple 1 'base ''T  we generate instance (SafeCopy a, SafeCopy b) => SafeCopy (T a b) where putCopy (C arg1 arg2) = contain $ do putWord8 0 safePut arg1 safePut arg2 return () putCopy (D arg1 arg2) = contain $ do putWord8 1 safePut arg1 safePut arg2 return () getCopy = contain $ do tag <- getWord8 case tag of 0 -> do return C <*> safeGet <*> safeGet 1 -> do return D <*> safeGet <*> safeGet _ -> fail $ "Could not identify tag \"" ++ show tag ++ "\" for type Main.T " ++ "that has only 2 constructors. " ++ "Maybe your data is corrupted?" version = 1 kind = base Using this simpler instance means that you may spend more bytes when serializing data. On the other hand, it is more straightforward and may match any other format you used in the past.Note that you may use I+ with one version of your data type and K, in another version without any problems.MDerive an instance of yl. The instance derived by this function should be compatible with the instance derived by the module Happstack.Data.SerializeTH of the happstack-data" package. The instances use only { and |$ (as do the instances created by K), but we also always write a Word80 tag, even if the data type isn't a sum type.:For example, given the data type and the declaration below 4data T0 b = T0 b Int deriveSafeCopy 1 'base ''T0  we generate instance (SafeCopy a, SafeCopy b) => SafeCopy (T0 b) where putCopy (T0 arg1 arg2) = contain $ do putWord8 0 safePut arg1 safePut arg2 return () getCopy = contain $ do tag <- getWord8 case tag of 0 -> do return T0 <*> safeGet <*> safeGet _ -> fail $ "Could not identify tag \"" ++ show tag ++ "\" for type Main.T0 " ++ "that has only 1 constructors. " ++ "Maybe your data is corrupted?" version = 1 kind = base <This instance always consumes at least the same space as I or K, but may use more because of the useless tag. So we recomend using it only if you really need to read a previous version in this format, and not for newer versions.Note that you may use I+ with one version of your data type and M, in another version without any problems.XAFollow type synonyms. This allows us to see, for example, that [Char] and String- are the same type and we just need to call z or } once for both.DEFGHIJKLMNOPQRSTUVWXYZ[\DFEGHIJKLMNOPQRSTUVWXYZ[\HIJKLMNDEFGOPQRSTUVWXYZ[\DEFGHIJKLMNOPQRSTUVWXYZ[\None]use Template Haskell to create ~ instances for a type. $(derivePathInfo ''SiteURL) Uses the _ formatter by default.^use Template Haskell to create ~ instances for a type.+This variant allows the user to supply a function that transforms the constructor name to a prettier rendering. It is important that the transformation function generates a unique output for each input. For example, simply converting the string to all lower case is not acceptable, because then FooBar and Foobar would be indistinguishable. %$(derivePathInfo' standard ''SiteURL) see also: __the standard formatter Converts  CamelCase to  camel-case. see also: ] and ^ return the  after the right-most ->. Or the original  if there are no ->. tests if a  contains an  somewhere ]^_`]^_`]^_` ]^_`      !"#$%&'()*+,,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopnqrstuvwxyzz{|x}~nqnq)th-typegraph-1.0.2-FshxfXiLnP73Pvw9OjD10Z%Language.Haskell.TH.TypeGraph.Orphans+Language.Haskell.TH.TypeGraph.TypeTraversal%Language.Haskell.TH.TypeGraph.Phantom,Language.Haskell.TH.TypeGraph.SafeCopyDerive)Language.Haskell.TH.TypeGraph.WebRoutesTHData.Path.Index ContainerKey$fSafeCopyProxy$fPprSet$fPpr(,)$fPprInt$fPpr()$fSafeCopyOccName$fSafeCopyNameSpace$fSafeCopyPkgName$fSafeCopyModName$fSafeCopyNameFlavour$fSafeCopyName$fToJSONKeyUserId$fFromJSONKeyUserId$fSerializeDiffTime$fSerializeDay$fSerializeUTCTime $fSafeCopyLoc$fSerializeLoc$fSerializeUserId $fLiftUserId$fLiftGr $fLiftNodeMapHasMessageInfo verbosity'prefix'ToNametoName HasVisitedMap unvisitedHasTypeTraversalprepTypedoTypeInternaldoListTdoTupleTdoFielddoVarT FieldInfo _typeName _constrCount _constrIndex _constrName _fieldCount _fieldIndex _fieldName _fieldTypeHasTypeParameters pushParam withParamsdoTypedoApply withBindingspprint1pprint1'pprintWpprintW' expandTypemessageindent $fToName(,,) $fToNameCon$fToNameTyVarBndr$fShowFieldInfo nonPhantom$fHasTypeTraversalRWST$fHasVisitedMapRWST$fHasMessageInfoR$fHasTypeParametersRWST DeriveTypeNormalSimple HappstackData unVersionderiveSafeCopyderiveSafeCopyIndexedTypederiveSafeCopySimplederiveSafeCopySimpleIndexedTypederiveSafeCopyHappstackData&deriveSafeCopyHappstackDataIndexedTypeforceTag tyVarNameinternalDeriveSafeCopyinternalDeriveSafeCopy'!internalDeriveSafeCopyIndexedType"internalDeriveSafeCopyIndexedType' mkPutCopy mkGetCopymkSafeFunctionsfollowSynonymsconSizeconNameconTypestypeNamederivePathInfoderivePathInfo'standardmkRouteghc-prim GHC.TypesIntbaseGHC.Basereturntemplate-haskellLanguage.Haskell.TH.PprPprLanguage.Haskell.TH.SyntaxName pprintStyle friendlyNames doTypeOncedoInfodoConR_paramsS_result_visited _verbosity_prefixparamsprefix verbosityPathTresultvisited'safecopy-0.9.3.3-AR6baoDc5HB7f6MWAYbHBgData.SafeCopy.SafeCopySafeCopy getSafePutsafePutsafeGet getSafeGet)web-routes-0.27.12-LFdbxy8CFPL27CsiyC8ZGHWeb.Routes.PathInfoPathInfolastTermType hasArrowTArrowTClassTaggedmkType parseInfo parseMethodsextractMethodsleafs