pure/typetraits

  Source   Edit

This module defines compile-time reflection procs for working with types.

Unstable API.

Example:

import pure/typetraits
type A = enum a0 = 2, a1 = 4, a2
type B = enum b0 = 2, b1, b2
assert A is enum
assert A is HoleyEnum
assert A isnot OrdinalEnum
assert B isnot HoleyEnum
assert B is OrdinalEnum
assert int isnot HoleyEnum
type C[T] = enum h0 = 2, h1 = 4
assert C[float] is HoleyEnum

Types

HoleyEnum = (not Ordinal) and enum
Enum with holes.   Source   Edit
OrdinalEnum = Ordinal and enum
Enum without holes.   Source   Edit
StaticParam[value] = object
  
Used to wrap a static value in genericParams.   Source   Edit

Procs

proc hasClosure(fn: NimNode): bool {....raises: [], tags: [].}
Return true if the func/proc/etc fn has closure. fn has to be a resolved symbol of kind nnkSym. This implies that the macro that calls this proc should accept typed arguments and not untyped arguments.   Source   Edit

Macros

macro enumLen(T: typedesc[enum]): int
Returns the number of items in the enum T.

Example:

type Foo = enum
  fooItem1
  fooItem2

doAssert Foo.enumLen == 2
  Source   Edit
macro genericParams(T: typedesc): untyped

Returns the tuple of generic parameters for the generic type T.

Note: For the builtin array type, the index generic parameter will always become a range type.

Example:

type Foo[T1, T2] = object

doAssert genericParams(Foo[float, string]) is (float, string)

type Bar[N: static float, T] = object

doAssert genericParams(Bar[1.0, string]) is (StaticParam[1.0], string)
doAssert genericParams(Bar[1.0, string]).get(0).value == 1.0
doAssert genericParams(seq[Bar[2.0, string]]).get(0) is Bar[2.0, string]
var s: seq[Bar[3.0, string]]
doAssert genericParams(typeof(s)) is (Bar[3.0, string],)

doAssert genericParams(array[10, int]) is (range[0..9], int)
var a: array[10, int]
doAssert genericParams(typeof(a)) is (range[0..9], int)
  Source   Edit

Templates

template distinctBase[T](a: T; recursive: static bool = true): untyped
Overload of distinctBase for values.

Example:

type MyInt = distinct int
type MyOtherInt = distinct MyInt
doAssert 12.MyInt.distinctBase == 12
doAssert 12.MyOtherInt.distinctBase == 12
doAssert 12.MyOtherInt.distinctBase(false) is MyInt
doAssert 12.distinctBase == 12
  Source   Edit
template elementType(a: untyped): typedesc
Returns the element type of a, which can be any iterable (over which you can iterate).

Example:

iterator myiter(n: int): auto =
  for i in 0 ..< n:
    yield i

doAssert elementType(@[1,2]) is int
doAssert elementType("asdf") is char
doAssert elementType(myiter(3)) is int
  Source   Edit
template get(T: typedesc[tuple]; i: static int): untyped
Returns the i-th element of T.

Example:

doAssert get((int, int, float, string), 2) is float
  Source   Edit
template pointerBase[T](_: typedesc[ptr T | ref T]): typedesc
Returns T for ref T | ptr T.

Example:

assert (ref int).pointerBase is int
type A = ptr seq[float]
assert A.pointerBase is seq[float]
assert (ref A).pointerBase is A # not seq[float]
assert (var s = "abc"; s[0].addr).typeof.pointerBase is char
  Source   Edit
template tupleLen(t: tuple): int

Returns the number of elements of the tuple t.

See also:

Example:

doAssert tupleLen((1, 2)) == 2
  Source   Edit