Index

Modules: stones, stones/cases, stones/collections, stones/deque, stones/genlib, stones/log, stones/rand, stones/sq, stones/strlib.

API symbols

`$`:

• strlib: proc `$`(input: seq[char]): string

`??`:

• genlib: template `??`[T](x: T; y: T): T

`?`:

• genlib: template `?`[T](cond: bool; p: Conditions[T]): T

`|`:

• genlib: proc `|`[T](a, b: T): Conditions[T]

add:

• sq: proc add[T](queue: var Queue[T]; node: SinglyLinkedNode[T]): void
• sq: proc add[T](queue: var Queue[T]; value: T): void
• sq: proc add[T](stack: var Stack[T]; node: SinglyLinkedNode[T]): void
• sq: proc add[T](stack: var Stack[T]; value: T): void

addFront:

• deque: proc addFront[T](deque: var Deque[T]; node: DoublyLinkedNode[T])
• deque: proc addFront[T](deque: var Deque[T]; value: T)

addRear:

• deque: proc addRear[T](deque: var Deque[T]; node: DoublyLinkedNode[T])
• deque: proc addRear[T](deque: var Deque[T]; value: T)

AlertLevel:

• log: enum AlertLevel

allCases:

• cases: proc allCases(s: string; c: Case = Default; acronyms: HashSet[string] = acronyms): Table[ Case, string]

Camel:

• cases: Case.Camel

camelCase:

• cases: proc camelCase(s: string; acronyms: HashSet[string] = acronyms): string

Case:

• cases: enum Case

Collection:

• collections: type Collection

ConflictingValueError:

• genlib: object ConflictingValueError

count:

• strlib: proc count(word: string; chars: HashSet[char]): Table[char, int]

currentCase:

• cases: proc currentCase(s: string): Case

DEBUG:

• log: AlertLevel.DEBUG

Default:

• cases: Case.Default

DEPRECATED:

• log: AlertLevel.DEPRECATED

Deque:

• deque: type Deque

DuplicateKeyError:

• genlib: object DuplicateKeyError

ERROR:

• log: AlertLevel.ERROR

FATAL:

• log: AlertLevel.FATAL

fillCollection:

• collections: proc fillCollection[T](collection: var Collection[T]; toAdd: Collection[T]): void

find:

• strlib: proc find(str: string; open: char; close: char; toFind: string): seq[int]

format:

• cases: proc format(c: Case; s: string; acronyms: HashSet[string] = acronyms): string

fromCamelCase:

• cases: proc fromCamelCase(s: string; acronyms: HashSet[string] = acronyms): string

fromKebabCase:

• cases: proc fromKebabCase(s: string): string

fromPascalCase:

• cases: proc fromPascalCase(s: string; acronyms: HashSet[string] = acronyms): string

fromUpperCase:

• cases: proc fromUpperCase(s: string): string

GenericError:

• log: object GenericError

getResult:

• genlib: proc getResult[A, B](input: A; arg: B; p: proc (x: var A; y: B)): A
• genlib: proc getResult[A, B](input: A; p: proc (x: var A; y: varargs[B]); args: varargs[B]): A
• genlib: proc getResult[T](input: T; p: proc (x: var T)): T
• genlib: proc getResult[T](input: T; p: proc (x: var T; y: varargs[T]); args: varargs[T]): T
• genlib: proc getResult[T](input: T; arg: T; p: proc (x: var T; y: T)): T

INFO:

• log: AlertLevel.INFO

initDeque:

• deque: proc initDeque[T](): Deque[T]
• deque: proc initDeque[T](collection: Collection[T]): Deque[T]

initQueue:

• sq: proc initQueue[T](): Queue[T]
• sq: proc initQueue[T](collection: Collection[T]): Queue[T]

initStack:

• sq: proc initStack[T](): Stack[T]
• sq: proc initStack[T](collection: Collection[T]): Stack[T]

InvalidIndexError:

• strlib: object InvalidIndexError

Kebab:

• cases: Case.Kebab

kebabCase:

• cases: proc kebabCase(s: string): string

len:

• deque: proc len[T](deque: var Deque[T]): int
• sq: proc len[T](list: var SomeList[T]): int

LOG:

• log: proc LOG(level: AlertLevel; message: string; exception: typedesc = GenericError): void

Lower:

• cases: Case.Lower

lowerCase:

• cases: proc lowerCase(s: string): string

merge:

• genlib: proc merge[T](first: var HashSet[T]; second: HashSet[T]): void
• genlib: proc merge[A, B](first: var Table[A, B]; second: Table[A, B]; ignoreDup: bool = true): void

NotADigitError:

• strlib: object NotADigitError

OutOfRangeError:

• collections: object OutOfRangeError

parseInt:

• strlib: proc parseInt(num: char): int
• strlib: proc parseInt(num: string): int

Pascal:

• cases: Case.Pascal

pascalCase:

• cases: proc pascalCase(s: string; acronyms: HashSet[string] = acronyms): string

peek:

• sq: proc peek[T](list: var SomeList[T]): SinglyLinkedNode[T]

peekFront:

• deque: proc peekFront[T](deque: var Deque[T]): DoublyLinkedNode[T]

peekRear:

• deque: proc peekRear[T](deque: var Deque[T]): DoublyLinkedNode[T]

pop:

• sq: proc pop[T](list: var SomeList[T]): SinglyLinkedNode[T]

popFront:

• deque: proc popFront[T](deque: var Deque[T]): DoublyLinkedNode[T]

popRear:

• deque: proc popRear[T](deque: var Deque[T]): DoublyLinkedNode[T]

Queue:

• sq: type Queue

randString:

• rand: proc randString(length: int): string

replace:

• strlib: proc replace(input: var seq[char]; replacements: Table[string, string]): void
• strlib: proc replace(s: string; replacements: Table[string, string]): string

seqCharToString:

• strlib: proc seqCharToString(input: seq[char]): string

setAcronyms:

• cases: proc setAcronyms(configAcronyms: HashSet[string]): void

setLevel:

• log: proc setLevel(level: AlertLevel): void

Snake:

• cases: Case.Snake

sort:

• collections: proc sort[int](collection: Collection[int]): seq[int]

split:

• strlib: proc split(str: string; open: char; close: char; separator: string): seq[string]

Stack:

• sq: type Stack

substr:

• strlib: proc substr(s: var string; first, last: int): void

SUCCESS:

• log: AlertLevel.SUCCESS

sum:

• collections: proc sum[int](collection: Collection[int]): int

toCamelCase:

• cases: proc toCamelCase(s: string; acronyms: HashSet[string] = acronyms): string

toKebabCase:

• cases: proc toKebabCase(s: string): string

toLowerCase:

• cases: proc toLowerCase(s: string): string

toPascalCase:

• cases: proc toPascalCase(s: string; acronyms: HashSet[string] = acronyms): string

toUpperCase:

• cases: proc toUpperCase(s: string): string

trim:

• strlib: proc trim(s: var string): void

UnsupportedCharacterError:

• cases: object UnsupportedCharacterError

Upper:

• cases: Case.Upper

upperCase:

• cases: proc upperCase(s: string): string

WARNING:

• log: AlertLevel.WARNING

width:

• strlib: proc width(strs: seq[string]): seq[int]