# typetraits

Dark Mode

- Manual
- Standard library
- Index
- Compiler docs
- Fusion docs

Search:

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

Unstable API.

# Imports

since, macros

# Types

    StaticParam[value] = object

  used to wrap a static value in `genericParams` Source Edit

# Procs

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

  Returns the name of the given type.

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

  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.

  Example:

      assert arity(seq[string]) == 1
      assert arity(array[3, int]) == 2
      assert 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:

  - stripGenericParams

  Example:

      type
        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 error for non-generic types, it will just return them unmodified. 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".}

  Return true for named tuples, false for any other type. Source Edit

    proc distinctBase(T: typedesc): typedesc {...}{.magic: "TypeTrait".}

  Returns base type for distinct types, works only for distinct types. compile time error otherwise Source Edit

    proc tupleLen(T: typedesc[tuple]): int {...}{.magic: "TypeTrait".}

  Return number of elements of `T` Source Edit

# Templates

    template distinctBase[T](a: T): untyped

  overload for values

  Example:

      type MyInt = distinct int
      doAssert 12.MyInt.distinctBase == 12

  Source Edit

    template tupleLen(t: tuple): int

  Return number of elements of `t` Source Edit

    template get(T: typedesc[tuple]; i: static int): untyped

  Return `i`th element of `T` Source Edit

    template elementType(a: untyped): typedesc

  return 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 genericParams(T: typedesc): untyped

  return tuple of generic params for generic `T`

  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],)

      # NOTE: For the builtin array type, the index generic param will
      #       **always** become a range type after it's bound to a variable.
      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

# Exports

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