Source   Edit

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

Unstable API.


import std/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


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


proc name(t: typedesc): string {.magic: "TypeTrait".}

Returns the name of the given type.

Alias for system.`$`(t) since Nim v0.20.


doAssert name(int) == "int"
doAssert name(seq[string]) == "seq[string]"
  Source   Edit
proc arity(t: typedesc): int {.magic: "TypeTrait".}
Returns the arity of the given type. This is the number of "type" components or the number of generic parameters a given type t has.


doAssert arity(int) == 0
doAssert arity(seq[string]) == 1
doAssert arity(array[3, int]) == 2
doAssert arity((int, int, float, string)) == 4
  Source   Edit
proc genericHead(t: typedesc): typedesc {.magic: "TypeTrait".}

Accepts an instantiated generic type and returns its uninstantiated form. A compile-time error will be produced if the supplied type is not generic.

See also:


  Foo[T] = object
  FooInst = Foo[int]
  Foo2 = genericHead(FooInst)

doAssert Foo2 is Foo and Foo is Foo2
doAssert genericHead(Foo[seq[string]]) is Foo
doAssert not compiles(genericHead(int))

type Generic = concept f
  type _ = genericHead(typeof(f))

proc bar(a: Generic): typeof(a) = a

doAssert bar(Foo[string].default) == Foo[string]()
doAssert not compiles bar(string.default)

when false: # these don't work yet
  doAssert genericHead(Foo[int])[float] is Foo[float]
  doAssert seq[int].genericHead is seq
  Source   Edit
proc stripGenericParams(t: typedesc): typedesc {.magic: "TypeTrait".}
This trait is similar to genericHead, but instead of producing an error for non-generic types, it will just return them unmodified.


type Foo[T] = object

doAssert stripGenericParams(Foo[string]) is Foo
doAssert stripGenericParams(int) is int
  Source   Edit
proc supportsCopyMem(t: typedesc): bool {.magic: "TypeTrait".}

This trait returns true if the type t is safe to use for copyMem.

Other languages name a type like these blob.

  Source   Edit
proc isNamedTuple(T: typedesc): bool {.magic: "TypeTrait".}
Returns true for named tuples, false for any other type.


doAssert not isNamedTuple(int)
doAssert not isNamedTuple((string, int))
doAssert isNamedTuple(tuple[name: string, age: int])
  Source   Edit
proc distinctBase(T: typedesc): typedesc {.magic: "TypeTrait".}

Returns the base type for distinct types, or the type itself otherwise.

See also:


type MyInt = distinct int
doAssert distinctBase(MyInt) is int
doAssert distinctBase(int) is int
  Source   Edit
proc tupleLen(T: typedesc[tuple]): int {.magic: "TypeTrait".}

Returns the number of elements of the tuple type T.

See also:


doAssert tupleLen((int, int, float, string)) == 4
doAssert tupleLen(tuple[name: string, age: int]) == 2
  Source   Edit
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


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


type Foo = enum

doAssert Foo.enumLen == 2
  Source   Edit


template distinctBase[T](a: T): untyped
Overload of distinctBase for values.


type MyInt = distinct int
doAssert 12.MyInt.distinctBase == 12
doAssert 12.distinctBase == 12
  Source   Edit
template tupleLen(t: tuple): int

Returns the number of elements of the tuple t.

See also:


doAssert tupleLen((1, 2)) == 2
  Source   Edit
template get(T: typedesc[tuple]; i: static int): untyped
Returns the i-th element of T.


doAssert get((int, int, float, string), 2) is float
  Source   Edit
template elementType(a: untyped): typedesc
Returns the element type of a, which can be any iterable (over which you can iterate).


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 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 after it's bound to a variable.


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 (StaticParam[10], int)
var a: array[10, int]
doAssert genericParams(typeof(a)) is (range[0..9], int)
  Source   Edit


$, $, $, $, $, $, $, $, $, $, $, $, $, $, $, $, $, $