Skip to main content

/

DocsCode

Mojo struct

Variadic

struct Variadic

A namespace for variadic utilities.

Implemented traits​

AnyType, ImplicitlyDestructible

comptime members​

__del__is_trivial​

comptime __del__is_trivial = True

concat​

comptime concat[T: AnyTrait[AnyType], //, *Ts: Variadic[T]] = #kgen.variadic.concat<#kgen.param.decl.ref<"Ts"> : !kgen.variadic<variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>>>

Represents the concatenation of multiple variadic sequences of types.

Parameters​

  • ​T (AnyTrait): The trait that types in the variadic sequences must conform to.
  • ​*Ts (Variadic): The variadic sequences to concatenate.

contains​

comptime contains[Trait: AnyTrait[AnyType], //, type: Trait, element_types: Variadic[Trait]] = #kgen.variadic.reduce<#kgen.variadic<{:i1 0}> : !kgen.variadic<!lit.struct<@std::@builtin::@bool::@Bool>>, #kgen.param.decl.ref<"element_types"> : !kgen.variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> Trait>, #kgen.gen<[cond(eq(:type !kgen.param<:!kgen.param<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> Trait> variadic_get(:variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> Trait> *(0,1), *(0,2))>, !kgen.param<:!kgen.param<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> Trait> type>), sugar_builtin(apply(:!lit.generator<() -> !lit.struct<@std::@builtin::@bool::@Bool>> @std::@sys::@intrinsics::@"_type_is_eq_parse_time[::AnyType,::AnyType]()"<:trait<@std::@builtin::@anytype::@AnyType> !kgen.param<:!kgen.param<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> Trait> variadic_get(:variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> Trait> *(0,1), *(0,2))>, :trait<@std::@builtin::@anytype::@AnyType> !kgen.param<:!kgen.param<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> Trait> type>>), {_mlir_value: i1 = eq(:type !kgen.param<:!kgen.param<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> Trait> variadic_get(:variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> Trait> *(0,1), *(0,2))>, !kgen.param<:!kgen.param<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> Trait> type>)}), variadic_get(:variadic<!lit.struct<@std::@builtin::@bool::@Bool>> *(0,0), 0))]> : !kgen.generator<!lit.generator<<"PrevV": variadic<!lit.struct<@std::@builtin::@bool::@Bool>>, "VA": variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> Trait>, "idx": index>variadic<!lit.struct<@std::@builtin::@bool::@Bool>>>>>[0]

Check if a type is contained in a variadic sequence.

Parameters​

  • ​Trait (AnyTrait): The trait that the types conform to.
  • ​type (Trait): The type to check for.
  • ​element_types (Variadic): The variadic sequence of types to search.

empty_of_trait​

comptime empty_of_trait[T: AnyTrait[AnyType]]

Empty comptime variadic of type values.

Parameters​

  • ​T (AnyTrait): The trait that types in the variadic sequence must conform to.

empty_of_type​

comptime empty_of_type[T: AnyType]

Empty comptime variadic of values.

Parameters​

  • ​T (AnyType): The type of values in the variadic sequence.

map_types_to_types​

comptime map_types_to_types[From: AnyTrait[AnyType], To: AnyTrait[AnyType], //, element_types: Variadic[From], Mapper: [From: From] To] = #kgen.variadic.reduce<#kgen.variadic<> : !kgen.variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> To>, #kgen.param.decl.ref<"element_types"> : !kgen.variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> From>, #kgen.gen<#kgen.variadic.concat<#kgen.variadic<*(0,0), [bind_params(:!lit.generator<<"From": !kgen.param<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> From>>!kgen.param<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> To>> Mapper, :!kgen.param<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> From> variadic_get(:variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> From> *(0,1), *(0,2)))]> : !kgen.variadic<variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> To>>>> : !kgen.generator<!lit.generator<<"PrevV": variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> To>, "VA": variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> From>, "idx": index>variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> To>>>>

Map a variadic of types to a new variadic of types using a mapper.

Returns a new variadic of types resulting from applying Mapper[T] to each type in the input variadic.

Examples:

from std.builtin.variadics import Variadic
from testing import *

trait MyError:
    comptime ErrorType: AnyType

struct Foo(MyError):
    comptime ErrorType = Int

struct Baz(MyError):
    comptime ErrorType = String

# Given a variadic of types [Foo, Baz]
comptime input_types = Variadic.types[T=MyError, Foo, Baz]

# And a mapper that maps the type to it's MyError `ErrorType` type
comptime mapper[T: MyError] = T.ErrorType

# The resulting variadic of types is [Int, String]
comptime output = Variadic.map_types_to_types[input_types, mapper]

assert_equal(Variadic.size(output), 2)
assert_true(_type_is_eq[output[0], Int]())
assert_true(_type_is_eq[output[1], String]())

Parameters​

  • ​From (AnyTrait): The trait that the input types conform to.
  • ​To (AnyTrait): The trait that the output types conform to.
  • ​element_types (Variadic): The input variadic of types to map.
  • ​Mapper (``): A generator that maps a type to another type. The generator type is [T: From] -> To.

reverse​

comptime reverse[T: AnyTrait[AnyType], //, *element_types: T] = #kgen.variadic.reduce<#kgen.variadic<> : !kgen.variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>, #kgen.param.decl.ref<"element_types"> : !kgen.variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>, #kgen.gen<#kgen.variadic.concat<#kgen.variadic<*(0,0), [variadic_get(:variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T> *(0,1), add(mul(*(0,2), -1), #kgen.variadic.size<#kgen.param.index.ref<0, 1> : !kgen.variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>>, -1))]> : !kgen.variadic<variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>>>> : !kgen.generator<!lit.generator<<"PrevV": variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>, "VA": variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>, "idx": index>variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>>>>

A wrapper to reverse a variadic sequence of types.

Parameters​

  • ​T (AnyTrait): The trait that the types conform to.
  • ​*element_types (T): The variadic sequence of types to reverse.

slice_types​

comptime slice_types[T: AnyTrait[AnyType], //, element_types: Variadic[T], start: Int = 0, end: Int = Variadic.size[T](element_types)] = #kgen.variadic.reduce<#kgen.variadic<> : !kgen.variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>, #kgen.param.decl.ref<"element_types"> : !kgen.variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>, #kgen.gen<cond(#lit.struct.extract<:!lit.struct<@std::@builtin::@bool::@Bool> cond(le(#lit.struct.extract<:!lit.struct<@std::@builtin::@int::@Int> start, "_mlir_value">, *(0,2)), {_mlir_value: i1 = lt(*(0,2), #lit.struct.extract<:!lit.struct<@std::@builtin::@int::@Int> end, "_mlir_value">)}, {_mlir_value: i1 = le(#lit.struct.extract<:!lit.struct<@std::@builtin::@int::@Int> start, "_mlir_value">, *(0,2))}), "_mlir_value">, #kgen.variadic.concat<#kgen.variadic<*(0,0), [variadic_get(:variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T> *(0,1), *(0,2))]> : !kgen.variadic<variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>>>, *(0,0))> : !kgen.generator<!lit.generator<<"PrevV": variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>, "VA": variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>, "idx": index>variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> T>>>>

Extract a contiguous subsequence from a variadic sequence.

Returns a new variadic containing elements from index start (inclusive) to index end (exclusive). Similar to Python's slice notation [start:end].

Constraints: - 0 <= start <= end <= Variadic.size(element_types)

Examples:

from std.builtin.variadics import Variadic
# Given a variadic of types [Int, String, Float64, Bool]
comptime MyTypes = Tuple[Int, String, Float64, Bool].element_types
# Extract middle elements: [String, Float64]
comptime Sliced = Variadic.slice_types[start=1, end=3, element_types=MyTypes]
# Extract first two: [Int, String]
comptime First2 = Variadic.slice_types[start=0, end=2, element_types=MyTypes]
# Extract last element: [Bool]
comptime Last = Variadic.slice_types[start=3, end=4, element_types=MyTypes]

Parameters​

  • ​T (AnyTrait): The trait that the types conform to.
  • ​element_types (Variadic): The variadic sequence to slice.
  • ​start (Int): The starting index (inclusive).
  • ​end (Int): The ending index (exclusive).

splat​

comptime splat[type: AnyType, count: Int] = #kgen.variadic.splat<:trait<@std::@builtin::@anytype::@AnyType> *"type", #lit.struct.extract<:!lit.struct<@std::@builtin::@int::@Int> count, "_mlir_value"> : index>

Splat a type into a variadic sequence.

Parameters​

  • ​type (AnyType): The type to splat.
  • ​count (Int): The number of times to splat the type.

types​

comptime types[T: AnyTrait[AnyType], //, *Ts: T] = Ts

Turn discrete type values (bound by T) into a single variadic.

Parameters​

  • ​T (AnyTrait): The trait that the types must conform to.
  • ​*Ts (T): The types to collect into a variadic sequence.

TypesOfTrait​

comptime TypesOfTrait[T: AnyTrait[AnyType]] = Variadic[T]

Represents a raw variadic sequence of types that satisfy the specified trait.

Parameters​

  • ​T (AnyTrait): The trait that types in the variadic sequence must conform to.

values​

comptime values[T: AnyType, //, *values_: T] = values_

Turn discrete values (bound by T) into a single variadic.

Parameters​

  • ​T (AnyType): The type of the values.
  • ​*values_ (T): The values to collect into a variadic sequence.

ValuesOfType​

comptime ValuesOfType[type: AnyType] = Variadic[type]

Represents a raw variadic sequence of values of the specified type.

Parameters​

  • ​type (AnyType): The type of values in the variadic sequence.

zip_types​

comptime zip_types[Trait: AnyTrait[AnyType], //, *types: Variadic[Trait]] = #kgen.variadic.zip<#kgen.param.decl.ref<"types"> : !kgen.variadic<variadic<:!lit.anytrait<<@std::@builtin::@anytype::@AnyType>> Trait>>>

Zips a group of variadics of types together.

Parameters​

  • ​Trait (AnyTrait): The trait that the types conform to.
  • ​*types (Variadic): The type to check for.

zip_values​

comptime zip_values[type: AnyType, //, *values: Variadic[type]] = #kgen.variadic.zip<#kgen.param.decl.ref<"values"> : !kgen.variadic<variadic<:trait<@std::@builtin::@anytype::@AnyType> *"type">>>

Zips a group of variadics of values together.

Parameters​

  • ​type (AnyType): The type that the values conform to.
  • ​*values (Variadic): The values to zip.

Methods​

size​

static size[T: AnyType](seq: Variadic[T]) -> Int

Returns the length of a variadic sequence.

Parameters:

  • ​T (AnyType): The type of values in the sequence.

Args:

  • ​seq (Variadic): The variadic sequence to measure.

Returns:

Int: The length of the variadic sequence.

static size[T: AnyTrait[AnyType]](seq: Variadic[T]) -> Int

Returns the length of a variadic sequence.

Parameters:

  • ​T (AnyTrait): The trait that types in the sequence must conform to.

Args:

  • ​seq (Variadic): The variadic sequence of types to measure.

Returns:

Int: The length of the variadic sequence.

View source

View source

Was this page helpful?

Models

Cookbook

Puzzles

Blog

Community

Contact