# typetraits

Dark Mode

- Manual
- Standard library
- Index
- devel, stable

Search:
Group by:

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

Unstable API.

# Imports

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.

  Examples:

      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.

  For example:

  - `seq[int].genericHead` will be just `seq`
  - `seq[int].genericHead[float]` will be `seq[float]`

  A compile-time error will be produced if the supplied type is not generic.

  See also:

  - stripGenericParams

  Example:

      type
        Functor[A] = concept f
          type MatchedGenericType = genericHead(f.type)
            # `f` will be a value of a type such as `Option[T]`
            # `MatchedGenericType` will become the `Option` type

  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 iff 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

  Examples:

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

  return tuple of generic params for generic `T`

  Examples:

      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

  Source Edit

# Exports

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