proc `+`[T, U](a: Option[T]; b: Option[U]): Option[T]

proc `-`[T, U](a: Option[T]; b: Option[U]): Option[T]

proc `??`[T: ref object](self: T; els: T): T

proc align[T](address, alignment: T): T

proc del[T](x: var seq[T]; val: T) {.noSideEffect.}

proc first=[S, T](x: var S; value: T)

proc last=[S, T](x: var S; value: T)

func myNormalizedPath(path: string): string {....raises: [], tags: [], forbids: [].}

proc neww[T](value: T): ref T

proc `or`[T, U](a: Option[T]; b: Option[U]): Option[T]

proc resetOption[T](self: var Option[T])

func roundPositive[T: float64 | float32](x: T): T

proc safeIntCast[T: SomeSignedInt](x: T; Target: typedesc[SomeUnsignedInt]): Target:type {.
    inline.}

proc someOption[T: not Option](self: T): Option[T]

proc someOption[T: Option](self: T): T

macro `.?`(self: untyped; value: untyped): untyped

template catch(exp: untyped; error: untyped; then: untyped): untyped

template catch(exp: untyped; then: untyped): untyped

template first(x: untyped): untyped

template getOr[T](opt: Option[T]; body: untyped): T

template getSome[T](opt: Option[T]; injected: untyped): bool

template hasPrefix(exp: untyped; prefix: string; v: untyped): untyped

template isNotNil(v: untyped): untyped

template isNotNil(v: untyped; injected: untyped): bool

template last(x: untyped): untyped

template mapIt[T](self: Option[T]; op: untyped): untyped

template maybeFlatten[T](self: Option[Option[T]]): Option[T]

template maybeFlatten[T](self: Option[T]): Option[T]

template softAssert(condition: bool; message: string): untyped

template toOpenArray(s: string): auto

template with(exp, val, body: untyped): untyped

template yieldAll(iter: untyped): untyped