This module defines compile-time reflection procs for working with types.
Unstable API.
Example:
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
Types
OrdinalEnum = Ordinal and enum
- Enum without holes. Source Edit
StaticParam[value] = object
- Used to wrap a static value in genericParams. Source Edit
Procs
proc distinctBase(T: typedesc; recursive: static bool = true): typedesc {. magic: "TypeTrait", ...raises: [], tags: [], forbids: [].}
-
Returns the base type for distinct types, or the type itself otherwise. If recursive is false, only the immediate distinct base will be returned.
See also:
Example:
Source Edittype MyInt = distinct int type MyOtherInt = distinct MyInt doAssert distinctBase(MyInt) is int doAssert distinctBase(MyOtherInt) is int doAssert distinctBase(MyOtherInt, false) is MyInt doAssert distinctBase(int) is int
proc genericHead(t: typedesc): typedesc {.magic: "TypeTrait", ...raises: [], tags: [], forbids: [].}
-
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:
Example:
Source Edittype 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
proc hasClosure(fn: NimNode): bool {....raises: [], tags: [], forbids: [].}
- Returns 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
proc hasDefaultValue(t: typedesc): bool {.magic: "TypeTrait", ...raises: [], tags: [], forbids: [].}
-
Returns true if t has a valid default value.
Example:
Source Edit{.experimental: "strictNotNil".} type NilableObject = ref object a: int Object = NilableObject not nil RequiresInit[T] = object a {.requiresInit.}: T assert hasDefaultValue(NilableObject) assert not hasDefaultValue(Object) assert hasDefaultValue(string) assert not hasDefaultValue(var string) assert not hasDefaultValue(RequiresInit[int])
proc isNamedTuple(T: typedesc): bool {.magic: "TypeTrait", ...raises: [], tags: [], forbids: [].}
-
Returns true for named tuples, false for any other type.
Example:
Source EditdoAssert not isNamedTuple(int) doAssert not isNamedTuple((string, int)) doAssert isNamedTuple(tuple[name: string, age: int])
-
Returns the base type for range types, or the type itself otherwise.
See also:
Example:
Source Edittype MyRange = range[0..5] type MyEnum = enum a, b, c type MyEnumRange = range[b..c] doAssert rangeBase(MyRange) is int doAssert rangeBase(MyEnumRange) is MyEnum doAssert rangeBase(range['a'..'z']) is char
proc stripGenericParams(t: typedesc): typedesc {.magic: "TypeTrait", ...raises: [], tags: [], forbids: [].}
-
This trait is similar to genericHead, but instead of producing an error for non-generic types, it will just return them unmodified.
Example:
Source Edittype Foo[T] = object doAssert stripGenericParams(Foo[string]) is Foo doAssert stripGenericParams(int) is int
proc supportsCopyMem(t: typedesc): bool {.magic: "TypeTrait", ...raises: [], tags: [], forbids: [].}
-
Returns true if t is safe to use for copyMem.
Other languages name a type like these blob.
Source Edit
Templates
template distinctBase[T](a: T; recursive: static bool = true): untyped
-
Overload of distinctBase for values.
Example:
Source Edittype 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
template elementType(a: untyped): typedesc
-
Returns the element type of a, which can be any iterable (over which you can iterate).
Example:
Source Edititerator 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
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.
Example:
Source Edittype 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)
template pointerBase[T](_: typedesc[ptr T | ref T]): typedesc
-
Returns T for ref T | ptr T.
Example:
Source Editassert (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
-
Overload of rangeBase for values.
Example:
Source Edittype MyRange = range[0..5] type MyEnum = enum a, b, c type MyEnumRange = range[b..c] let x = MyRange(3) doAssert rangeBase(x) is int doAssert $typeof(rangeBase(x)) == "int" doAssert rangeBase(x) == 3 let y: set[MyEnumRange] = {c} for e in y: doAssert rangeBase(e) is MyEnum doAssert $typeof(rangeBase(e)) == "MyEnum" doAssert rangeBase(e) == c let z: seq[range['a'..'z']] = @['c'] doAssert rangeBase(z[0]) is char doAssert $typeof(rangeBase(z[0])) == "char" doAssert rangeBase(z[0]) == 'c'
template toUnsigned(T: typedesc[SomeInteger and not range]): untyped
-
Returns an unsigned type with same bit size as T.
Example:
Source Editassert int8.toUnsigned is uint8 assert uint.toUnsigned is uint assert int.toUnsigned is uint # range types are currently unsupported: assert not compiles(toUnsigned(range[0..7]))