Generics And Capabilities

Inferring Type Arguments

A call can leave out its type arguments when the arguments say what they are. When several arguments feed the same in T, Camp picks the common type of all of them, in either order, and converts each argument to it. A literal adapts:

T chooseFirst<T>(in T first, in T second, sizeof(T)) => first;

long wide = chooseFirst(count, 5000000000L);   // T is long, count converts
uint unsignedValue = chooseFirst(small, 2);    // T is uint, the literal adapts
// chooseFirst(count, small);                  // ERROR: int and uint have no common type

A type parameter inside another type, such as T* or T[], is matched against the argument’s type. The first argument that supplies it fixes it, and a later one must convert to that type. A qualifier the parameter adds does not take part, so const T* accepts both int* and const int* and gives T as int.

An out T slot is an exact bound. The type of the storage you pass fixes T, wherever the out argument is written, and each in argument must convert to it. A typed declaration such as out long result gives its declared type, while out _ gives none:

void exchange<T>(in T source, out T destination, sizeof(T)) { destination = source; }

int small = 1;
long wide = 2;
exchange(small, out wide);     // T is long, small converts
// exchange(wide, out small);  // ERROR at wide: a long does not convert to int

Two out T arguments must have the same type, and so must the storage of an out argument when the type argument is written (exchange<int>(small, out wide) is an error at wide).

null takes its type from a sibling pointer in either order, so chooseFirst(buffer, null) is a pointer to what buffer points to. null, default, [] and brace lists supply no type on their own. When nothing else does, the call is an error at the function name; write the type argument: describe<int>(default).

Type Names

typenameof(T) provides the source type name for exactly its operand:

string nameOf<T>(typenameof(T)) => typenameof(T);

It grants no size, copying, dispatch or reflection. A capability for T does not also supply names for T*, T[] or const T. A known represented value names its actual argument, not its carrier. Names are not type identities.

Interface Witnesses

Use a typed witness when generic code needs interface dispatch:

interface Reader { int read(); }

int readOne<T>(T* value, vtableof(T: Reader))
{
    return value.read();
}

The actual argument must be a direct class or struct implementing Reader. A pointer to such an object is a different argument and does not qualify as the witness operand. Witnesses require void representation and provide dispatch, not copying or size.

Ordinary witness slots receive T*, while ordinary interface-table slots receive Reader*. Source typing preserves that distinction despite a shared C layout. Lifecycle witness slots use the declared constructor/destroy and allocator contracts. A witness-only class algorithm can dispatch without requesting size. An ordinary implementing copyable struct may combine size and a witness through legal indirect transport; that still does not permit direct T input.

A witness can name a constructed interface. vtableof(T: Check<byte>) requires a type that implements exactly Check<byte>; its members are typed with that construction, so v.pass(x) takes and returns byte. A type that implements Check<short> does not qualify, and a call that would infer a different construction from its other arguments is rejected.

byte viaWitness<T>(T* v, byte x, vtableof(T: Check<byte>))
{
    return v.pass(x);
}

Forwarding Capabilities

A generic function that calls another generic function supplies the callee’s capabilities from its own. Each capability follows its operand, not a name:

int pairRead<T, U>(T* first, U* second, vtableof(T: Reader), vtableof(U: Reader))
{
    return first.read() * 100 + second.read();
}

int swappedRead<T, U>(T* first, U* second, vtableof(T: Reader), vtableof(U: Reader))
{
    return pairRead<U, T>(second, first);
}

The caller must declare the capability for the operand it forwards; a size, name or witness for another operand, a plain nuint or string, or a witness for a different interface is rejected at the call. A signature declares at most one witness for each parameter, even for the same interface.

Retained Capabilities

Generic class constructors retain requested size, name and witness values for later instance operations. They do not make unknown-size T fields legal. Method-local capabilities do not become class-wide state. A method cannot request a second witness for a parameter whose witness the constructor retains, even for the same interface; a method with its own type parameter may request a witness for that parameter. A witness retained for a derived interface supplies the inherited slots, including construction and destruction. Generic structs receive required capabilities per call; ordinary integer/string/raw-pointer fields do not manufacture evidence.

List, HashMap and HashSet retain checked constructor size capabilities for the copying and layout work performed by their methods. Their array storage can hold ordinary optional and expanded values whole.

Local Storage And Results

Use explicit stackalloc plus size for an exact void T local:

void swapFirst<T>(T[] values, sizeof(T))
{
    stackalloc T temporary = values[0];
    values[0] = values[1];
    values[1] = temporary;
}

An ordinary T local or an auto requiring unknown-size storage is invalid. Integer-represented T uses an ordinary local. Stack storage is allocated on entry, including each resume activation; initializer effects occur where the declaration is written. Reassign named stack storage after yield/await before reading it; stack addresses do not survive suspension.

Choose the new contract from the work the body performs:

Do not remove a constraint word and assume the contract is preserved. Review input modes, callbacks, retained facts, exported source signatures and native ABI together. Rebuild affected producers and consumers when those contracts change.