Generics

type parameters, fn name[T], generic arrays, explicit type arguments

Do not paste the complete program immediately. Create the file, type the first step, run vpp check, and then run the program when a complete entry point exists. Read the explanation before looking at the snippet. After each step, predict what the new code should do. This turns the page into a lesson rather than a code dump.

T is a type parameter. The function accepts a value of any concrete type and returns that same type. The compiler can specialize the generic function for each concrete use.

After typing the snippet, identify the new names introduced by the step. Ask what each name represents, what type the compiler should infer or check, and what value should exist after the code runs.

fn id[T](x: T) -> T {
    return x
}

The same type parameter can describe an array element and the return value. first therefore works for arrays of integers, strings, or other supported types.

Before moving forward, explain how this step connects to the previous one. In particular, identify which values cross a function boundary, which values change, and which values are guaranteed by the type system.

fn first[T](items: array[T]) -> T {
    return items[0]
}

Explicit type arguments make the intended specialization visible. id[int] creates an integer use and id[string] creates a string use. first[string] accepts an array of strings.

Before moving forward, explain how this step connects to the previous one. In particular, identify which values cross a function boundary, which values change, and which values are guaranteed by the type system.

fn main() -> int {
    print(id[int](42))
    print(id[string]("v++"))
    let words = ["alpha", "beta", "gamma"]
    print(first[string](words))
    return 0
}

The complete program should produce the following output when run with the command shown below. Exact formatting should follow the current V++ runtime.

42
v++
alpha

Generics let one function describe a family of concrete functions. Monomorphization means concrete uses can be compiled with concrete types.

1. Using a concrete type where T is required
2. Forgetting explicit type arguments when the example requires them
3. Passing an array whose element type does not match T

Create a generic last[T] function. Test it with an integer array and a string array.

A strong learner should be able to explain the program without looking at the code, rebuild the core idea from memory, and make the practice change without copying a solution.