!,"      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW X Y 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 { | } ~        !Safe"#&'-.=>?@AHUVX_k"harg 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_gki 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 #"s that act as tags for each type.  544Safe"#&'.=>?@AHUVX_khargSingleton 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 = ...   4 4Safe"#&'-./=>?@AHSUVX_k/-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] 0hargSame as %. but for heterogeneous propositional equality4harg!Induction on the tail of the list-./0/-.0None"#&'.=>?@ACHUVX_gkCA7hargKGiven 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 'z 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 (s. 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 789:;<=>?@A :;<978A@?>=None"#&'-.1;=>?@AHMUVX_kMLhargNewtype wrapper around  .NhargSee documentation for   data User = User { name :: String, age :: Int } deriving Generic someNestedValue :: Nested User Maybe someNestedValue = nested @User (Just Joe ) (Just 30) OhargSee 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) PhargHelper for when f ~ IdentityLMNOPLMNOP None"#&'-.1;=>?@AHMUVX_kTWharg 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 ... ZhargWrap a value into a W.[hargHelper for when f ~ IdentityWXYZ[WXYZ[ Safe"#&'.4=>?@AHUVX_ke<bhargYContext to carry around, that contains environment variables and command line arguments.)harg.Command line arguments, can be retrieved with *.fharg2Environment variable pairs, can be retrieved with +.ghargExistential wrapper for 1, so that many options can be carried in a list.ihargAOption for arguments (no long/short specifiers). Corresponds to .qharg_Option for flags that act like switches between a default and an active value. Corresponds to .zharg0Option 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 type9bcdefghijklmnopqrstuvwxyz{|}~9z{|}~qrstuvwxyijklmnopghbcdef 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 ( long "json-config" . defaultVal (ConfigFile "~/config.json") ) And an optional JSON source:  srcOpt :: JSONSource Opt srcOpt = JSONSource jsonOpt where jsonOpt = optionWith strParser ( long "json-config" . defaultVal 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 optionhargSuccessful parsingharg Create a ( by existentially wrapping an option in g. None"#&'.79=>?@AHUVX_kZhargThrowaway type whose  instance returns no value.hargShorthand for writing . None"#&'.79=>?@AHUVX_kKharg 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_k/harg 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_kRharg[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 None"#&'.=>?@AHUVX_k@Safe"#&'-.=>?@AHUVX_k0harg 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.1harg<Wrap a symbol in quotes, for pretty printing in type errors.2harg2Class to convert an intermediate option type into (. Instances should set the appropriate .3harg%Convert an intermediate option to an 4hargLClass for options that can be optional. Cannot be used in conjunction with 5, 6 or 7). Note that this will turn a parser for a into a parser for Maybe a=, modifying the reader function appropriately. For example: y someOpt :: Opt (Maybe Int) someOpt = optionWith readParser ( long "someopt" . optional ) 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  requiredStr.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  q. The second argument is the modifiers to add to the option, and can be defined by using function composition (8).  someOption :: Opt Int someOption = option readParser ( long "someopt" . help "Some option" . defaultVal 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 second argument is the modifiers to add to the option, and can be defined by using function composition (8). o someFlag :: Opt Int someFlag = flag 0 1 ( long "someflag" . help "Some flag" ) hargA  parser, specialized to 9F. The parser (e.g. when parsing an environment variable) will accept true and false/, but case insensitive, rather than using the : instance for 9. The default value is ;, and the active value is <. v someSwitch :: Opt Bool someSwitch = switch ( long "someswitch" . help "Some switch" ) harg Similar to , but the default value is < and the active is ;.harg)Create an argument parser, equivalent to q. The second argument is the modifiers to add to the option, and can be defined by using function composition (8).  someArgument :: Opt Int someArgument = argument ( help "Some argument" . defaultVal "this is the default" ) hargConvert a parser that returns = to a parser that returns (, with the default > 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 9%. 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 valuehargOriginal parserharg SeparatorhargParser for each stringNone"#&'.=>?@AHUVX_k:harg Create a ?Z from a list of source results and an option parser. The source results are folded using @# and then used as a single result.Aharg Create a ?< for a single option, using the accumulated source results.Bharg Create a ? for an z, which results in an optparse-applicative C.Dharg Create a ? for a q, which results in an optparse-applicative E.Fharg Create a ? for a i, which results in an optparse-applicative G.hargSource resultshargTarget configuration optionsAhargAccumulated source resultsharg Target optionNone"#&'.=>?@AHUVX_k0HhargMore general version of .hargThis class can be used with an  AssocList&. It returns the appropriate list of I 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 = J (K 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 (. 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_k|harg Create a ?- for the configuration option parser, using  EnvSource 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_khargBConvert 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.harg8Convert an association list of options in to dummy ones.  None"#&'.79=>?@AHUVX_kLharg#The result of reading a YAML file. YAMLSourceNotRequired& is used when the user has specified defaultVal NoConfigFile/. It holds the contents of the YAML file as a M. harg>Source that enables a parser to read options from a YAML file.    None"#&'.79=>?@AHUVX_koNharg#The result of reading a JSON file. JSONSourceNotRequired& is used when the user has specified defaultVal NoConfigFile/. It holds the contents of the JSON file as a O.harg>Source that enables a parser to read options from a JSON file.None"#&',-./=>?@AHSUVX_kC hargjRun the option parser and combine with values from the specified sources, passing the context explicitly.hargHRun the option parser and combine with values from the specified sourceshargiRun the option parser only with default sources (environment variables), passing the context explicitly.hargGRun the option parser only with default sources (environment variables)hargnRun the subcommand parser and combine with values from the specified sources, passing the context explicitly.hargMRun the subcommand parser and combine with values from the specified sources hargmRun the subcommand parser only with default sources (environment variables), passing the context explicitly.!hargLRun the subcommand parser only with default sources (environment variables)PhargyRun the optparse-applicative parser, printing accumulated errors. Errors are printed as warnings if the parser succeeds.Qharg4Run the optparse-applicative parser and return the Rharg7Context containing the environment and the cmdline argshargSource optionshargTarget configuration optionshargSource optionshargTarget configuration optionsharg7Context containing the environment and the cmdline argshargTarget configuration optionshargTarget configuration optionsharg7Context containing the environment and the cmdline argshargSource optionsharg*Target options associated with subcommandshargSource optionsharg*Target options associated with subcommands harg7Context containing the environment and the cmdline argsharg*Target options associated with subcommands!harg*Target options associated with subcommands !! None"#&'.=>?@AHUVX_gkQT   9:;<=>?@ALMNOPWXYZ[   !TWXYZ[LMONP !   :;<9A@?>=  S&'(&)*&+,&-.&-/&-/0120130450460789:;<=>?@=ABCDEFGHIIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvvwxyz{|}~                                        !"#$      % !"#$%&'()*+,-./0123456789:;<=9>? @9AB9AC9DE9FG HIJKLMNOPQ9RS56T9UV56W56X9YZ9>[\]^9R_`a\b c\bd\be\fg\bh9Rijklmnopqrs\]tuharg-0.4.2.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-G6ZyDVU4icd6N5m271SW69Data.Barbie.Internal.ProductProductB Data.Barbie.Internal.Traversable TraversableBData.Barbie.Internal.FunctorFunctorBData.Generics.GenericNunRecRec'higgledy-0.3.0.0-5UzG0Ca5OnY4Fx9DqCOuAZData.Generic.HKD.BuildbuildBuildData.Generic.HKD.Construction construct ConstructData.Generic.HKD.TypesHKDAll MapAssocList mapAssocList:->:+ AssocListFANilACons$fMapAssocList:$fMapAssocList[]SNatSZSSNatZSTaggedunTagged $fFromJSON:* $fFromJSON:*0$fProductBTYPETagged$fTraversableBTYPETagged$fFunctorBTYPETagged $fGeneric:* $fFunctorB:*$fTraversableB:* $fProductB:*$fGenericTagged$fFromJSONTagged$fShow:*Proofproof++ hgcastWith $fProofNilk: $fProofNilk[] $fProofk[]y[] $fProofa:y: $fProofk[]yzs $fProofk:y[] InjectPosF injectPosF fromVariantFVariantFHereFThereFIn5In4In3In2In1$fTraversableBTYPEVariantF$fTraversableBTYPEVariantF0$fFunctorBTYPEVariantF$fFunctorBTYPEVariantF0$fFromVariantF:resultf$fIgnoreF:resultf$fIgnoreF[]resultf$fFromVariantF:resultf0$fInjectPosFSx:$fInjectPosFZx:Nestednested getNested fromNested $fFromJSONHKD$fTraversableBTYPENested$fProductBNested$fFunctorBNested$fFromJSONNested$fGenericNestedSingle getSinglesingle fromSingle$fProductBTYPESingle$fTraversableBTYPESingle$fFunctorBTYPESingle$fFromJSONSingle$fGenericSingle $fShowSingleHargCtx_hcEnv_hcArgs EnvironmentSomeOpt ArgumentOpt_aHelp _aMetavar_aEnvVar _aDefaultVal _aDefaultStr_aReaderFlagOpt_fLong_fShort_fHelp_fEnvVar _fDefaultVal_fReader_fActive OptionOpt_oLong_oShort_oHelp _oMetavar_oEnvVar _oDefaultVal _oDefaultStr_oReaderOptAttr OptDefault OptOptionalOptType OptionOptType FlagOptTypeArgumentOptTypeOpt_optLong _optShort_optHelp _optMetavar _optEnvVar_optDefaultVal_optDefaultStr _optReader_optType OptReadergetCtx ctxFromArgs ctxFromEnvpureCtx$fFunctorOptType $fFunctorOpt ConfigFile NoConfigFile RunSource runSource GetSource SourceVal getSourceSourceRunError_sreOpt_sreSourceName _sreErrorSourceRunResult OptNotFound OptParsedsourceRunError$fGetSource:*f$fRunSource()a$fRunSource(,)a$fIsStringConfigFile$fFunctorSourceRunResultNoSource noSources$fGetSourceNoSourcef$fGenericNoSource$fFunctorBNoSource$fTraversableBNoSource$fProductBNoSource EnvSourceVal EnvSource$fRunSourceEnvSourceVala$fGetSourceEnvSourcef$fGenericEnvSource$fFunctorBEnvSource$fTraversableBEnvSource$fProductBEnvSourceDefaultStrSource$fRunSourceDefaultStrSourceVala$fGetSourceDefaultStrSourcef$fGenericDefaultStrSource$fFunctorBDefaultStrSource$fTraversableBDefaultStrSource$fProductBDefaultStrSourceDefaultSources HiddenSourcesaccumSourceResults hiddenSourcesdefaultSourcesppHelpppSourceRunErrorsoptionalrequired defaultStr defaultValenvVarswitchswitch' 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$fHasDefaultValArgumentOpta$fHasDefaultValOptionOptamkOptparseParser Subcommands mapSubcommand$fExplSubcommandsn::as$fExplSubcommandsn[][]acc$fSubcommandstsxsmkConfigParser getConfigcomposeallToDummyOpts readFileLBS readFileBS YAMLSource$fRunSourceYAMLSourceVala$fGetSourceYAMLSourceIdentity$fGenericYAMLSource$fFunctorBYAMLSource$fTraversableBYAMLSource$fProductBYAMLSource$fRunSourceJSONSourceVala$fGetSourceJSONSourceIdentity$fGenericJSONSource$fFunctorBJSONSource$fTraversableBJSONSource$fProductBJSONSourceexecOptWithCtxexecOptexecOptWithCtxDef execOptDefexecCommandsWithCtx execCommandsexecCommandsWithCtxDefexecCommandsDefAllFghc-prim GHC.TypesSymbolProofNilbaseData.Type.Equality gcastWithFoldSignatureF FromVariantF Data.EitherEitherArgsSystem.EnvironmentgetArgsgetEnvironmentGHC.IOFilePath Data.StringIsString lookupEnvDefaultStrSourceVal NotInAttrsQuoteSymIsOpttoOpt HasOptional HasDefaultVal HasDefaultStr HasRequiredGHC.Base.BoolGHC.ReadReadFalseTrue GHC.MaybeMaybeLeft4optparse-applicative-0.14.3.0-KgUFYVq9ZZSIX6QVzTkb7AOptions.Applicative.TypesParser<|>mkParsertoOptionParserOptions.Applicative.Builder toFlagParsertoArgumentParserExplSubcommands$Options.Applicative.Builder.Internal CommandFields subparsermconcat YAMLSourceValbytestring-0.10.8.2Data.ByteString.Internal ByteString JSONSourceVal#aeson-1.4.4.0-mHKymN7k4k51cE7lc3PkqData.Aeson.Types.InternalValue execParserexecParserPure ParserResult