Index

Modules: taskutils/cmdline, taskutils/dirs, taskutils/envtypes, taskutils/envvars, taskutils/fileiters, taskutils/files, taskutils/filetypes, taskutils/nimcmdline, taskutils/optional, taskutils/parseenv, taskutils/result, taskutils/unit.

API symbols

`==`:

• result: `==`[S; F](self, other: Result[S, F]): bool

AbsoluteDir:

• filetypes: AbsoluteDir

AbsoluteFile:

• filetypes: AbsoluteFile

absoluteFiles:

• fileiters: absoluteFiles(dir: DirPath; ext: string): AbsoluteFile

absoluteFilesRec:

• fileiters: absoluteFilesRec(dir: DirPath; ext: string): AbsoluteFile

absoluteNimModules:

• fileiters: absoluteNimModules(dir: DirPath): AbsoluteFile

absoluteNimModulesRec:

• fileiters: absoluteNimModulesRec(dir: DirPath): AbsoluteDir

absoluteNimsModules:

• fileiters: absoluteNimsModules(dir: DirPath): AbsoluteFile

absoluteNimsModulesRec:

• fileiters: absoluteNimsModulesRec(dir: DirPath): AbsoluteDir

boxedType:

• optional: boxedType[T; ](self: Optional[T]): typedesc[T]
• optional: boxedType[T; ](X: typedesc[Optional[T]]): typedesc[T]

cmdLine:

• cmdline: cmdLine(parts: varargs[string]): string

compilerCache:

• dirs: compilerCache(baseOutputDir: AbsoluteDir): AbsoluteDir

crossCompilerCache:

• dirs: crossCompilerCache(baseOutputDir: AbsoluteDir): AbsoluteDir

DirPath:

• filetypes: DirPath

envNim:

• envvars: envNim(): EnvVarName

envNimFlags:

• envvars: envNimFlags(): EnvVarName

EnvVarName:

• envtypes: EnvVarName

EnvVarValue:

• envtypes: EnvVarValue

exeExists:

• files: exeExists(exe: FilePath): bool

failure:

• result: failure[F](value: F; S: typedesc): Result[S, F]

failureType:

• result: failureType[S; F; ](self: Result[S, F]): typedesc[F]
• result: failureType[S; F; ](X: typedesc[Result[S, F]]): typedesc[F]

FilePath:

• filetypes: FilePath

files:

• fileiters: files(dir: DirPath; ext: string; relative: bool): FilePath

filesRec:

• fileiters: filesRec(dir: DirPath; ext: string; relative: bool): FilePath

findExec:

• files: findExec(exe: FilePath): Optional[FilePath]

findValue:

• parseenv: findValue(name: EnvVarName; exists: EnvVarName -> bool; read: EnvVarName -> EnvVarValue): Optional[EnvVarValue]

flatMap:

• result: flatMap[A; B; F](self: Result[A, F]; f: A -> Result[B, F]): Result[B, F]

getOr:

• optional: getOr[T](self: Optional[T]; else: () -> T): T

ifFailure:

• result: ifFailure[S; F; T](self: Result[S, F]; then: F -> T; else: S -> T): T

ifNone:

• optional: ifNone[A; B](self: Optional[A]; then: () -> B; else: A -> B): B

ifSome:

• optional: ifSome[A; B](self: Optional[A]; then: A -> B; else: () -> B): B

ifSuccess:

• result: ifSuccess[S; F; T](self: Result[S, F]; then: S -> T; else: F -> T): T

ignore:

• unit: ignore[T](_: T)

isFailure:

• result: isFailure[S; F](self: Result[S, F]): bool

isSuccess:

• result: isSuccess[S; F](self: Result[S, F]): bool

longOption:

• nimcmdline: longOption(name: OptionName): string
• nimcmdline: longOption(name: OptionName; value: OptionValue): string

longOptionPrefix:

• nimcmdline: longOptionPrefix(): string

map:

• result: map[A; B; F](self: Result[A, F]; f: A -> B): Result[B, F]

nimbleCache:

• dirs: nimbleCache(): string

nimExt:

• fileiters: nimExt(): string

nimLongOption:

• nimcmdline: nimLongOption(name: OptionName): string
• nimcmdline: nimLongOption(name: OptionName; value: OptionValue): string

nimLongOptionPrefix:

• nimcmdline: nimLongOptionPrefix(): string

nimsExt:

• fileiters: nimsExt(): string

Optional:

• optional: Optional

OptionName:

• nimcmdline: OptionName

OptionValue:

• nimcmdline: OptionValue

outputDir:

• dirs: outputDir(taskName: string; baseOutputDir: AbsoluteDir): AbsoluteDir

outputIn:

• dirs: outputIn(taskName: string; baseOutputDir: AbsoluteDir): AbsoluteDir

ParseEnvError:

• parseenv: ParseEnvError

parseEnvError:

• parseenv: parseEnvError(name: EnvVarName; reason: string): ref ParseEnvError
• parseenv: parseEnvError(msg: string): ref ParseEnvError

parseEnvFailure:

• parseenv: parseEnvFailure(fail: () -> ref ParseEnvError; T: typedesc): ParseEnvResult[T]

ParseEnvResult:

• parseenv: ParseEnvResult

parseEnvSuccess:

• parseenv: parseEnvSuccess[T](value: T): ParseEnvResult[T]

parseNim:

• envvars: parseNim(value: EnvVarValue): ParseEnvResult[FilePath]

parseNimFlags:

• envvars: parseNimFlags(value: EnvVarValue): ParseEnvResult[string]

RelativeDir:

• filetypes: RelativeDir

RelativeFile:

• filetypes: RelativeFile

relativeFiles:

• fileiters: relativeFiles(dir: DirPath; ext: string): RelativeFile

relativeFilesRec:

• fileiters: relativeFilesRec(dir: DirPath; ext: string): RelativeFile

relativeNimModules:

• fileiters: relativeNimModules(dir: DirPath): RelativeFile

relativeNimModulesRec:

• fileiters: relativeNimModulesRec(dir: DirPath): RelativeFile

relativeNimsModules:

• fileiters: relativeNimsModules(dir: DirPath): RelativeFile

relativeNimsModulesRec:

• fileiters: relativeNimsModulesRec(dir: DirPath): RelativeFile

Result:

• result: Result

success:

• result: success[S](value: S; F: typedesc): Result[S, F]

successType:

• result: successType[S; F; ](self: Result[S, F]): typedesc[S]
• result: successType[S; F; ](X: typedesc[Result[S, F]]): typedesc[S]

toNimLongOptions:

• nimcmdline: toNimLongOptions(options: varargs[OptionName]): seq[string]
• nimcmdline: toNimLongOptions(options: varargs[tuple[name: OptionName, value: OptionValue]]): seq[ string]

tryParse:

• parseenv: tryParse[T; E](name: EnvVarName; find: EnvVarName -> Optional[EnvVarValue]; parse: EnvVarValue -> Result[T, E]): Optional[Result[T, E]]

tryParseNim:

• envvars: tryParseNim(tryRead: EnvVarName -> Optional[EnvVarValue]): Optional[ ParseEnvResult[FilePath]]

tryParseNimFlags:

• envvars: tryParseNimFlags(tryRead: EnvVarName -> Optional[EnvVarValue]): Optional[ ParseEnvResult[string]]

UnboxError:

• result: UnboxError

unboxFailure:

• result: unboxFailure[S; F](self: Result[S, F]): F

unboxSuccess:

• result: unboxSuccess[S; F](self: Result[S, F]): S

unboxSuccessOrRaise:

• result: unboxSuccessOrRaise[S; E: CatchableError](self: Result[S, proc (): ref E]): S
• result: unboxSuccessOrRaise[S; E: CatchableError](self: Result[S, ref E]): S

Unit:

• unit: Unit

unit:

• unit: unit(): Unit