Index

Modules: subdir/subdir_b/utils, testproject.

API symbols

`$`:

• utils: proc `$`[T](a: G[T]): string
• utils: proc `$`[T](a: ref SomeType): string

`'big`:

• utils: proc `'big`(a: string): SomeType

`[]=`:

• utils: proc `[]=`[T](a: var G[T]; index: int; value: T)

`[]`:

• utils: proc `[]`[T](x: G[T]): T

A:

• testproject: enum A

addfBug14485:

• testproject: proc addfBug14485()

aEnum:

• utils: template aEnum(): untyped

anything:

• testproject: proc anything()

asyncFun1:

• testproject: proc asyncFun1(): Future[int]

asyncFun2:

• testproject: proc asyncFun2(): owned(Future[void])

asyncFun3:

• testproject: proc asyncFun3(): owned(Future[void])

aVariable:

• testproject: var aVariable

B:

• testproject: enum B

bar:

• testproject: proc bar(f: FooBuzz)
• testproject: proc bar[T](a, b: T): T
• testproject: macro bar(): untyped

baz:

• testproject: proc baz()
• testproject: proc baz[T](a, b: T): T

bEnum:

• utils: template bEnum(): untyped

binarySearch:

• utils: proc binarySearch[T, K](a: openArray[T]; key: K; cmp: proc (x: T; y: K): int {.closure.}): int

buzz:

• testproject: proc buzz[T](a, b: T): T

C_A:

• testproject: const C_A

C_B:

• testproject: const C_B

C_C:

• testproject: const C_C

C_D:

• testproject: const C_D

Circle:

• testproject: Shapes.Circle

c_nonexistent:

• testproject: proc c_nonexistent(frmt: cstring): cint

c_printf:

• testproject: proc c_printf(frmt: cstring): cint

enumValueA:

• utils: SomeType.enumValueA

enumValueA2:

• testproject: Foo.enumValueA2

enumValueB:

• utils: SomeType.enumValueB

enumValueC:

• utils: SomeType.enumValueC

f:

• utils: proc f(x: G[int])
• utils: proc f(x: G[string])

fn:

• utils: proc fn[T; U, V: SomeFloat]()

fn10:

• utils: proc fn10(a: int): int

fN11:

• utils: proc fN11()
• utils: proc fN11(x: int)

fn2:

• utils: proc fn2()
• utils: proc fn2(x: int)
• utils: proc fn2(x: int; y: float)
• utils: proc fn2(x: int; y: float; z: float)

fn3:

• utils: proc fn3(): auto

fn4:

• utils: proc fn4(): auto

fn5:

• utils: proc fn5()

fn6:

• utils: proc fn6()

fn7:

• utils: proc fn7()

fn8:

• utils: proc fn8(): auto

fn9:

• utils: proc fn9(a: int): int

Foo:

• testproject: enum Foo

foo:

• testproject: template foo(a, b: SomeType)

fooBar:

• utils: iterator fooBar(a: seq[SomeType]): int

FooBuzz:

• testproject: type FooBuzz

fromUtils1:

• testproject: iterator fromUtils1(): int

fromUtils2:

• testproject: template fromUtils2()

fromUtils3:

• testproject: proc fromUtils3()

fromUtilsGen:

• utils: template fromUtilsGen(): untyped

funWithGenerics:

• utils: proc funWithGenerics[T, U: SomeFloat](a: T; b: U)

G:

• utils: object G

isValid:

• testproject: proc isValid[T](x: T): bool

iter1:

• testproject: iterator iter1(n: int): int

iter2:

• testproject: iterator iter2(n: int): int

low:

• testproject: proc low[T: Ordinal | enum | range](x: T): T

low2:

• testproject: proc low2[T: Ordinal | enum | range](x: T): T

method1:

• testproject: method method1(self: Moo)

method2:

• testproject: method method2(self: Moo): int

method3:

• testproject: method method3(self: Moo): int

myfn:

• testproject: template myfn()

p1:

• testproject: proc p1()

Rectangle:

• testproject: Shapes.Rectangle

Shapes:

• testproject: enum Shapes

someFunc:

• testproject: proc someFunc()

SomeType:

• utils: enum SomeType

someType:

• utils: proc someType(): SomeType

someVariable:

• testproject: var someVariable

T19396:

• testproject: object T19396

testNimDocTrailingExample:

• testproject: template testNimDocTrailingExample()

Triangle:

• testproject: Shapes.Triangle

tripleStrLitTest:

• testproject: proc tripleStrLitTest()

z1:

• testproject: proc z1(): Foo

z10:

• testproject: proc z10()

z11:

• testproject: proc z11()

z12:

• testproject: proc z12(): int

z13:

• testproject: proc z13()

z14:

• testproject: template z14()

z15:

• testproject: template z15()

z16:

• testproject: macro z16()

z17:

• testproject: proc z17()

z18:

• testproject: macro z18(): int

z2:

• testproject: proc z2()

z3:

• testproject: proc z3()

z4:

• testproject: proc z4()

z5:

• testproject: proc z5(): int

z6:

• testproject: proc z6(): int

z6t:

• testproject: template z6t(): int

z7:

• testproject: proc z7(): int

z8:

• testproject: proc z8(): int

z9:

• testproject: proc z9()