!F1X      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWSafe"#&'-.=>?@AHUVX_kharg AllF c xs f is similar to , but types in xs have the kind (Type -> Type) -> Type so they require an extra f :: Type -> Type$ in order to be of fully saturated.hargAll c xs8 returns a constraint which is constructed by applying c to all the types in xs.None"#&'.=>?@AHSUVX_gk / harg2Apply a function to all higher-kinded types in an  AssocList. harg+Helper type-level function to construct an  AssocListR which is not yet applied to the type constructor that needs to be fully applied. F type Config = "run" :-> RunConfig :+ "test" :-> TestConfig Config above has type (Type -> Type) -> Type, and requires a type like Opt to be fully applied. hargzA heterogeneous list that holds higher-kinded types and the associated type constructor, along with a type level list of X"s that act as tags for each type.       5 44Safe"#&'.=>?@AHUVX_k"{hargSingleton type for .harg Type-level Peano natural number.None"#&'-.179;=>?@AHMUVX_k)hargaThis type adds a type-level phantom tag to a higher-kinded type. Its JSON instance allows using  with .hargInfix version of W. Allows to combine higher-kinded types, and keep them partially applied until needed:  data User = User { name :: String, age :: Int } deriving Generic type Config = Nested User :* Single Int configOpt :: Config Opt configOpt = ... 44Safe"#&'-./=>?@AHSUVX_k1)hargProof that appending two lists is the same as appending the first element of the second list to the first one, and then appending the rest.+hargKProof that appending an empty list to any list has no effect on the latter.-hargAppend two type-level lists J> :kind! '[Int, Bool] ++ '[Char, Maybe Int] '[Int, Bool, Char, Maybe Int] .hargSame as Y. but for heterogeneous propositional equality2harg!Induction on the tail of the list)*+,-..-+,)*None"#&'.=>?@ACHUVX_gkF5hargKGiven a type-level natural that designates a position of injection into a <@, return a function that performs this injection. For example, S Zq which corresponds to 1 or the second position in the type-level list the variant holds, can give the injection b f -> VariantF [a, b, c] fb. The injection can as well be constructed without providing the position, but it helps in case x is not unique in xs.;harg Create the signature needed for 9z to work. This constructs a function that takes as arguments functions that can act upon each item in the list that the < holds. For example, VariantF [a, b, c] f will result to the signature: F VariantF [a, b, c] f -> (a f -> r) -> (b f -> r) -> (c f -> r) -> r <hargA Variant is similar to nested Zs. For example, Variant '[Int, Bool, Char] is isomorphic to Either Int (Either Bool Char). <b is a variant for higher-kinded types, which means that the type-level list holds types of kind (Type -> Type) -> Type4, and the second parameter is the type constructor f :: Type -> Type". To pattern match on a variant, HereF and ThereF can be used: a getFromVariant :: Variant '[Int, Bool, String] -> Bool getFromVariant (ThereF (HereF b)) = b 56789:;<>=?@ABC<>=CBA@?;9:7856None"#&'-.1;=>?@AHMUVX_kOOhargNewtype wrapper around .QhargSee documentation for   data User = User { name :: String, age :: Int } deriving Generic someNestedValue :: Nested User Maybe someNestedValue = nested @User (Just Joe ) (Just 30) RhargSee documentation for   data User = User { name :: String, age :: Int } deriving Generic getUserBack :: Maybe User getUserBack = getNested hkdUser where hkdUser :: Nested User Maybe hkdUser = nested @User (Just Joe ) (Just 30) NOPQROPNQR None"#&'-.1;=>?@AHMUVX_kVYharg Single a f is a newtype around f aa, which allows mixing non-nested with nested values when creating configuration parsers, using .  data User = User { name :: String, age :: Int } deriving Generic myConfig :: (Nested User :* Single Int) Opt myConfig = nested @User nameOpt ageOpt :* single intOpt where ... \hargWrap a value into a Y.YZ[\YZ[\ Safe"#&'.4=>?@AHUVX_kkchargYContext to carry around, that contains environment variables and command line arguments.gharg.Command line arguments, can be retrieved with [.hharg2Environment variable pairs, can be retrieved with \.ihargExistential wrapper for 1, so that many options can be carried in a list.khargDatatype that holds errors that arise when running the sources. The reason why this is the only place where errors occur is that, if something goes wrong when running the parser, it will be handled by optparse-applicative.mhargExistentially quantified nharg Source nameohargError descriptionphargAOption for arguments (no long/short specifiers). Corresponds to .xharg_Option for flags that act like switches between a default and an active value. Corresponds to .harg0Option for flags with arguments. Corresponds to  .harg Option typesharga( is the active value for the flag parserhargThe basic option typeharg Modifier for long options (e.g. --user)harg!Modifier for short options (e.g. -u)harg-Option help to be shown when invoked with  --help/-h or in case of errorharg+Metavar to be shown in the help descriptionharg"Environment variable for use with  EnvSourceharg Default valueharg"Default value as string (unparsed)harg Option parserharg Option type@cdfeghijklonmpqwvutsrxy~}|{z@xy~}|{zpqwvutsrklonmijhgcdfe None"#&'.4=>?@AHUVX_k?hargcThis type describes configuration files, for use with e.g. the JSON source. The reason to not use ] directly is that the user might prefer to do nothing if the option for the config file has not been not provided, and there's no default. Because this type has an ^k instance, it's very easy to define an option. For example, to define a json source with a default value:  srcOpt :: JSONSource Opt srcOpt = JSONSource jsonOpt where jsonOpt = optionWith strParser ( optLong "json-config" . optDefault (ConfigFile "~/config.json") ) And an optional JSON source:  srcOpt :: JSONSource Opt srcOpt = JSONSource jsonOpt where jsonOpt = optionWith strParser ( optLong "json-config" . optDefault NoConfigFile ) harg0This class is used to run the result of running t on the configuration options. In order for it to work, all types used in the source configuration need to have a ! instance, and their associated  types need to have a  instance.hargThis class enables a type that describes a source to fetch the source contents, potentially producing side effects (e.g. reading a file).harg7The type that will be returned when the source is read.harg.Holds errors that occur when running a source.harg!Source doesn't include the optionharg#Option cannot be parsed from sourcehargSuccessful parsing None"#&'.79=>?@AHUVX_khargThrowaway type whose  instance returns no value.hargShorthand for writing . None"#&'.79=>?@AHUVX_kharg Value of X, which is an association list between environment variable names and values (strings).hargHSource that enables a parser to read options from environment variables.hargBTry to get a value from the environment variable association list.None"#&'.79=>?@AHUVX_kharg Value of I is a dummy value, as the default string option can be found inside the  ().hargdSource that enables a parser to read options from defaults that are provided as strings (unparsed).None"#&'-.=>?@AHUVX_k'harg[Accumulate all the successful source results and return them, along with a list of errors.harg0Sources hidden from user that are always enabledhargDefault sources, equivalent to Safe"#&'.=>?@AHUVX_kSafe"#&'-.=>?@AHUVX_kharg Check if x* is not an element of the type-level list xs6. If it is print the appropriate error message using l and r for clarity.harg<Wrap a symbol in quotes, for pretty printing in type errors.harg2Class to convert an intermediate option type into (. Instances should set the appropriate .harg%Convert an intermediate option to an hargLClass for options that can be optional. Cannot be used in conjunction with ,  or ). Note that this will turn a parser for a into a parser for Maybe a=, modifying the reader function appropriately. For example:  someOpt :: Opt (Maybe Int) someOpt = optionWith readParser ( optLong "someopt" . optOptional ) harg9Specify that an option is optional. This will convert an Opt a to an  Opt (Maybe a)%. Cannot be used in conjunction with ,  or .harg@Mark an option as required. Cannot be used in conjunction with ,  or optRequiredStr.hargNAdd a default unparsed value to an option. Cannot be used in conjuction with ,  or .hargJAdd a default value to an option. Cannot be used in conjuction with with ,  or .harg7Specify an environment variable to lookup for an optionhargAdd a !Z metavar to an option, to be displayed as the meta-parameter next to long/short modifiershargAdd " to an optionhargAdd a # modifier to an optionhargAdd a $ modifier to an optionharg'Create an option parser, equivalent to  $. The result can then be used with  to convert into the global  type.  someOption :: Opt Int someOption = toOpt ( option readParser & optLong "someopt" & optHelp "Some option" & optDefault 256 ) harg Similar to 1, but accepts a modifier function and returns an  directly.  someOption :: Opt Int someOption = optionWith readParser ( optLong "someopt" . optHelp "Some option" . optDefault 256 ) harg$Create a flag parser, equivalent to  . The first argument is the default value (returned when the flag modifier is absent), and the second is the active value (returned when the flag modifier is present). The result can then be used with  to convert into the global  type.  someFlag :: Opt Int someFlag = toOpt ( flag 0 1 & optLong "someflag" & optHelp "Some flag" ) harg Similar to 1, but accepts a modifier function and returns an  directly. y someFlag :: Opt Int someFlag = flagWith 0 1 ( optLong "someflag" . optHelp "Some flag" ) hargA  parser, specialized to _F. The parser (e.g. when parsing an environment variable) will accept true and false/, but case insensitive, rather than using the ` instance for _. The default value is a, and the active value is b.  someSwitch :: Opt Bool someSwitch = toOpt ( switch & optLong "someswitch" & optHelp "Some switch" ) harg Similar to 1, but accepts a modifier function and returns an  directly.  someSwitch :: Opt Bool someSwitch = switchWith ( optLong "someswitch" . optHelp "Some switch" ) harg Similar to , but the default value is b and the active is a.harg Similar to 1, but accepts a modifier function and returns an  directly.harg)Create an argument parser, equivalent to $. The result can then be used with  to convert into the global  type.  someArgument :: Opt String someArgument = toOpt ( argument strParser & optHelp "Some argument" & optDefault "this is the default" ) harg Similar to 2, but accepts a modifier function and returns an  directly.  someArgument :: Opt Int someArgument = argumentWith ( optHelp "Some argument" . optDefault "this is the default" ) hargConvert a parser that returns c to a parser that returns Z, with the default d value unable to parse: <input>.hargA parser that uses the ` instance to parse into a type.hargBA parser that returns a string. Any type that has an instance of ^, will work, and this parser always succeeds.hargA parser that returns a _%. This will succeed for the strings true and false in a case-insensitive manner. harg5A parser that can parse many items, returning a list.harg Default valueharg Active valueharg Default valueharg Active valuehargOriginal parserhargInput harg SeparatorhargParser for each string* * None"#&'.=>?@AHUVX_k!harg Create a eZ from a list of source results and an option parser. The source results are folded using f# and then used as a single result."harg Create a e< for a single option, using the accumulated source results.#harg Create a e for an , which results in an optparse-applicative g.$harg Create a e for a x, which results in an optparse-applicative h.%harg Create a e for a p, which results in an optparse-applicative i.!hargSource resultshargTarget configuration options"hargAccumulated source resultsharg Target option!"#$%!"#$%None"#&'.=>?@AHUVX_k&hargMore general version of (.(hargThis class can be used with an  AssocList&. It returns the appropriate list of j in order to create a subcommand parser. Given the sources to use and the association list between the command string and the command type, it returns the list of command field modifiers and a list of errors."The result can be used as follows:  ... (errs, commands) = ) sources opts parser = k (l commands) ... In order to be able to create a subcommand parser for a heterogeneous list of options (rather than a sum with different constructors), the return type should also be heterogeneous. Here, we return a Variant, which is a more generic version of Z. In order to do that, )v traverses the association list and creates an injection into the Variant, according to the current position. So an  AssocList like this: O opts :: AssocList '["run", "test"] '[RunConfig, TestConfig] Opt opts = ... Should return *VariantF '[RunConfig, TestConfig] Identity'. In order to do that, it will inject  RunConfig! based on its position (0) using HereF, and  TestConfig using ThereF . HereF because its position is 1.&'()()&'None"#&'.=>?@AHUVX_k5-harg Create a e- for the configuration option parser, using  as the only source..hargRun two option parsers in parallel and return the result of the first one. This is used with the configuration parser being the first argument, and the target option parser that has been converted to the dummy parser using % as the second one.-.-.None"#&'.=>?@AHSUVX_k v0hargBConvert an option parser into a dummy parser. A dummy option parser always succeeds because options always have a default value (a monoid is used here). This is useful because we want to run the parser together with the configuration parser once in order to gather JSON file paths etc., which means that we still need --help to work.1harg8Convert an association list of options in to dummy ones./012345/012345None"#&'.79=>?@AHUVX_kk6harg#The result of reading a YAML file. YAMLSourceNotRequired& is used when the user has specified optDefault NoConfigFile/. It holds the contents of the YAML file as a m.9harg>Source that enables a parser to read options from a YAML file.6879:;9:687;None"#&'.79=>?@AHUVX_kXBharg#The result of reading a JSON file. JSONSourceNotRequired& is used when the user has specified optDefault NoConfigFile/. It holds the contents of the JSON file as a n.Eharg>Source that enables a parser to read options from a JSON file.BDCEFGEFBDCGNone"#&',-./=>?@AHSUVX_k.L NhargjRun the option parser and combine with values from the specified sources, passing the context explicitly.OhargHRun the option parser and combine with values from the specified sourcesPhargiRun the option parser only with default sources (environment variables), passing the context explicitly.QhargGRun the option parser only with default sources (environment variables)RhargnRun the subcommand parser and combine with values from the specified sources, passing the context explicitly.ShargMRun the subcommand parser and combine with values from the specified sourcesThargmRun the subcommand parser only with default sources (environment variables), passing the context explicitly.UhargLRun the subcommand parser only with default sources (environment variables)VhargyRun the optparse-applicative parser, printing accumulated errors. Errors are printed as warnings if the parser succeeds.Wharg4Run the optparse-applicative parser and return the oNharg7Context containing the environment and the cmdline argshargSource optionshargTarget configuration optionsOhargSource optionshargTarget configuration optionsPharg7Context containing the environment and the cmdline argshargTarget configuration optionsQhargTarget configuration optionsRharg7Context containing the environment and the cmdline argshargSource optionsharg*Target options associated with subcommandsShargSource optionsharg*Target options associated with subcommandsTharg7Context containing the environment and the cmdline argsharg*Target options associated with subcommandsUharg*Target options associated with subcommands NOPQRSTUVW NOPQRSTUVWNone"#&'.=>?@AHUVX_gk/jO :<=>?@ABCOPQRYZ[\ 9:EFOQSUOYZ[\OPQR    OQSUEF9:<=>:CBA@?p&'(&)*&+,-./-01-23456789:;<9=>?@ABCDEEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyyz{|}~                                                  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG%HIJKLMMNOOPQRSTUVWWXYZ[\]^_`abcdefghijklmnompqmrsmrtmuvmwxjkymz{jk|jk}m~mpm mharg-0.1.3.0-inplace Options.HargOptions.Harg.Het.AllOptions.Harg.Het.HListOptions.Harg.Het.NatOptions.Harg.Het.ProdOptions.Harg.Het.ProofsOptions.Harg.Het.VariantOptions.Harg.NestedOptions.Harg.SingleOptions.Harg.TypesOptions.Harg.Sources.TypesOptions.Harg.Sources.NoSourceOptions.Harg.Sources.EnvOptions.Harg.Sources.DefaultStrOptions.Harg.SourcesOptions.Harg.PrettyOptions.Harg.ConstructOptions.Harg.CmdlineOptions.Harg.SubcommandsOptions.Harg.ConfigOptions.Harg.UtilOptions.Harg.Sources.YAMLOptions.Harg.Sources.JSONOptions.Harg.Operations JSONSource Data.FunctorProduct:*Options.Applicativeargumentflagoptionmetavarhelpshortlong toDummyOpts%barbies-1.1.3.0-KGcWYPZPVr2QiQys2hGQ9Data.Barbie.Internal.ProductProductB Data.Barbie.Internal.Traversable TraversableBData.Barbie.Internal.FunctorFunctorB'higgledy-0.3.0.0-7qZLcJe8q7fLNkTvXj6lB1Data.Generic.HKD.BuildbuildData.Generic.HKD.Construction constructData.Generic.HKD.TypesHKDAllFAll MapAssocList mapAssocList:->:+ AssocListFANilACons$fMapAssocList:$fMapAssocList[]SNatSZSSNatZSTaggedunTagged $fFromJSON:* $fFromJSON:*0$fProductBTYPETagged$fTraversableBTYPETagged$fFunctorBTYPETagged $fGeneric:* $fFunctorB:*$fTraversableB:* $fProductB:*$fGenericTagged$fFromJSONTagged$fShow:*ProofproofProofNilproofNil++ hgcastWith $fProofNilk: $fProofNilk[] $fProofk[]y[] $fProofa:y: $fProofk[]yzs $fProofk:y[] InjectPosF injectPosFIgnoreFignoreF FromVariantF fromVariantFFoldSignatureFVariantFHereFThereFIn5In4In3In2In1$fTraversableBTYPEVariantF$fTraversableBTYPEVariantF0$fFunctorBTYPEVariantF$fFunctorBTYPEVariantF0$fFromVariantF:resultf$fIgnoreF:resultf$fIgnoreF[]resultf$fFromVariantF:resultf0$fInjectPosFSx:$fInjectPosFZx:NestNestednested getNested $fFromJSONHKD$fTraversableBTYPENested$fProductBNested$fFunctorBNested$fFromJSONNested$fGenericNestedSingle getSinglesingle$fProductBTYPESingle$fTraversableBTYPESingle$fFunctorBTYPESingle$fFromJSONSingle$fGenericSingle $fShowSingleHargCtx_hcEnv_hcArgsArgs EnvironmentSomeOptOptError_oeOpt _oeSource_oeDesc ArgumentOpt_aHelp _aMetavar_aEnvVar _aDefault _aDefaultStr_aReaderFlagOpt_fLong_fShort_fHelp_fEnvVar _fDefault_fReader_fActive OptionOpt_oLong_oShort_oHelp _oMetavar_oEnvVar _oDefault _oDefaultStr_oReaderOptAttr OptDefault OptOptionalOptType OptionOptType FlagOptTypeArgumentOptTypeOpt_optLong _optShort_optHelp _optMetavar _optEnvVar _optDefault_optDefaultStr _optReader_optType OptReadergetCtx ctxFromArgs ctxFromEnvpureCtx toOptError$fFunctorOptType $fFunctorOpt ConfigFile NoConfigFile RunSource runSource GetSource SourceVal getSourceSourceRunResult OptNotFoundOptFoundNoParse OptParsed$fGetSource:*f$fRunSource()a$fRunSource(,)a$fIsStringConfigFile$fFunctorSourceRunResultNoSource noSources$fGetSourceNoSourcef$fGenericNoSource$fFunctorBNoSource$fTraversableBNoSource$fProductBNoSource EnvSourceVal EnvSource lookupEnvrunEnvVarSource$fRunSourceEnvSourceVala$fGetSourceEnvSourcef$fGenericEnvSource$fFunctorBEnvSource$fTraversableBEnvSource$fProductBEnvSourceDefaultStrSourceValDefaultStrSourcerunDefaultStrSource$fRunSourceDefaultStrSourceVala$fGetSourceDefaultStrSourcef$fGenericDefaultStrSource$fFunctorBDefaultStrSource$fTraversableBDefaultStrSource$fProductBDefaultStrSourceDefaultSources HiddenSourcesaccumSourceResults hiddenSourcesdefaultSourcesppHelp ppWarningppError ppOptErrorsppSourceppEnvVarIncompatibleAttrsErrDuplicateAttrMultipleErrDuplicateAttrErr CommaSep'CommaSep NotInAttrsQuoteSymIsOpttoOpt HasOptional optOptional HasRequired optRequired HasDefaultStr optDefaultStr HasDefault optDefault HasEnvVar optEnvVar HasMetavar optMetavarHasHelpoptHelpHasShortoptShortHasLongoptLong optionWithflagWithswitch switchWithswitch' switchWith' argumentWith parseWith readParser strParser boolParser manyParser$fHasLongTYPEFlagOpta$fHasLongTYPEOptionOpta$fHasShortTYPEFlagOpta$fHasShortTYPEOptionOpta$fHasHelpTYPEArgumentOpta$fHasHelpTYPEFlagOpta$fHasHelpTYPEOptionOpta$fHasMetavarTYPEArgumentOpta$fHasMetavarTYPEOptionOpta$fHasEnvVarTYPEArgumentOpta$fHasEnvVarTYPEFlagOpta$fHasEnvVarTYPEOptionOpta$fIsOptArgumentOptattr$fIsOptFlagOptattr$fIsOptOptionOptattr$fHasOptionalArgumentOpta$fHasOptionalOptionOpta$fHasRequiredTYPEArgumentOpta$fHasRequiredTYPEOptionOpta$fHasDefaultStrTYPEArgumentOpta$fHasDefaultStrTYPEOptionOpta$fHasDefaultArgumentOpta$fHasDefaultOptionOptamkOptparseParsermkParsertoOptionParser toFlagParsertoArgumentParserExplSubcommandsexplMapSubcommand Subcommands mapSubcommand$fExplSubcommandsn::as$fExplSubcommandsn[][]acc$fSubcommandstsxsmkConfigParser getConfigcomposeallToDummyOptsprintErrAndExit readFileWith readFileLBS readFileBS YAMLSourceValYAMLSourceNotRequired YAMLSource runYAMLSource$fRunSourceYAMLSourceVala$fGetSourceYAMLSourceIdentity$fGenericYAMLSource$fFunctorBYAMLSource$fTraversableBYAMLSource$fProductBYAMLSource JSONSourceValJSONSourceNotRequired runJSONSource$fRunSourceJSONSourceVala$fGetSourceJSONSourceIdentity$fGenericJSONSource$fFunctorBJSONSource$fTraversableBJSONSource$fProductBJSONSourceexecOptWithCtxexecOptexecOptWithCtxDef execOptDefexecCommandsWithCtx execCommandsexecCommandsWithCtxDefexecCommandsDef execParserexecParserPureghc-prim GHC.TypesSymbolbaseData.Type.Equality gcastWith Data.EitherEitherSystem.EnvironmentgetArgsgetEnvironmentGHC.IOFilePath Data.StringIsStringBoolGHC.ReadReadFalseTrue GHC.MaybeMaybeLeft4optparse-applicative-0.14.3.0-KgUFYVq9ZZSIX6QVzTkb7AOptions.Applicative.TypesParserGHC.Base<|>Options.Applicative.Builder$Options.Applicative.Builder.Internal CommandFields subparsermconcatbytestring-0.10.8.2Data.ByteString.Internal ByteString$aeson-1.4.4.0-DcKgUdHX2MwAwHZNqIDMx0Data.Aeson.Types.InternalValue ParserResult