Generic Types

This page uses some general terminology of Type Theory for Type Systems

Generics in Gofra are form of lazy template for any concrete type

Current limitations and known problems

These must be resolved later - Applying generic type requires type parameter name - Cannot use literals (e.g int[T]) - Cannot define generic for function or struct - Cannot apply/reference generic in form of defining another generic

Concrete types

By default any primitives type (int, char, ...) are concrete types, this means they have known size in bytes, and structure field / variable can has type of concrete kind.

Composite types (Pointers, Arrays) with primitive types also concrete - they has known size directly

Only concrete types may be used inside any non type-expression definition (e.g type) form (unless for Generics they must applied into Concrete types with Generic Type Parameters)

Defining an generic type

// Generic defined as *Identity* (apply Type Parameter to concrete type of same type)
type Identity{T} = T

// Pointer to generic type parameter
type XT{T} = *T 

Applying generic types into concrete one

As far you know - generic types cannot be used outside of type definition, you need to apply them otherwise

Applying generic type - is same as transforming it to generic one with known size and types

type Identity{T} = T

// Applying generic type into concrete (expanding type parameters)
var HasConcreteType = Identity{T = int}
// typeof is `int`

Terminology

• Type Parameter: T in Identity{T}
• Type Argument: int in Identity{T = int}
• Generic Type: Identity{T} (unapplied)
• Applied Generic: Identity{T = int} (concrete)
• Concrete Type: Fully resolved type with known size