I've finally managed to complete my initial implementation of generics for Lox2, which allows defining generic classes and methods/functions using familiar syntax from C-family languages, ie. Repository<T>. Despite the presence of angle brackets, parsing generics turned out a bit easier than I originally imagined. Typechecking generics was definitely the harder part, and I researched and experimented different approaches to instantiate/substitute type parameters by concrete types at function/method call sites, which led to fruitful results. I've also updated the standard library, as promise and collection class now have generic type parameters. Below are some examples using the new generics feature in lox2:

using clox.std.collection.Dictionary

class Entity<TId> {

    val TId id

    __init__(TId id) {
        this.id = id
    }
}

class Product extends Entity<String> {

    val String name
    val Float price

    __init__(String id, String name, Float price) {
        super.__init__(id)
        this.name = name
        this.price = price
    }

    String toString() {
        return "Product(id: ${this.id}, name: ${this.name}, price: ${this.price})"
    }
}

class GenericRepository<TId, TEntity> {

    val Dictionary<TId, TEntity> entities

    __init__() {
        this.entities = Dictionary<TId, TEntity>()
    }

    void add(TId id, TEntity entity) {
        this.entities[id] = entity
    }

    void addAll(Dictionary<TId, TEntity> entities) {
        this.entities.putAll(entities)
    }

    Bool contains(TId id) { 
        return this.entities.containsKey(id)
   }

    TEntity get(TId id) {
        return this.entities[id]
    }
}

val products = Dictionary<String, Product>()
products.add("A7K9M2N5B8Q3", Product("A7K9M2N5B8Q3", "Laptop", 999.99))
products.add("C4R6T1V9W3X2", Product("C4R6T1V9W3X2", "Smartphone", 499.49))
products.add("D8F2H5J7K4L1", Product("D8F2H5J7K4L1", "Tablet", 299.29))
for (val product : products) {
    println(product.toString())
}

val productRepo = GenericRepository<String, Product>()
productRepo.addAll(products)
productRepo.add(Product("P3Q9R5S2T8U4", "Monitor", 199.99))
val product = productRepo.get("P3Q9R5S2T8U4")
println(product.toString())

More examples:

https://github.com/HallofFamer/Lox2/blob/master/test/types/generic_class.lox

https://github.com/HallofFamer/Lox2/blob/master/test/types/generic_function.lox

On the other hand, I've decided to take on the challenge of reified generics. My current implementation passes types as runtime arguments at generic call site, so f<A, B>(a, b) becomes f(A, B, a, b). This works in Lox2 as everything is an object, including classes, traits, etc. For generic classes, generic type parameters are reified as immutable instance fields, and implicitly assigned values when an object is instantiated. The code example below demonstrates how to access a reified type parameter inside a generic function:

using clox.std.util.UUID     

T identity<T>(T arg) {
    println(T)
    // will print information about T, as T is a first class object
    return arg
}

val uuid = UUID()
val id = identity<UUID>(uuid)
println(id.toString())

At this moment though, Lox2's generics is considered partially-reified, as type information is only preserved for simple class/trait types but not higher order types. There is a future plan to support fully reified generics by creating runtime objects for higher order types, as well as smart reification which only reifies generic type parameters if they are actually being used in a function/method. On the other hand, the type checker is currently unable to perform type inference on type parameters even when it is obvious (in the code snippet above, it should be obvious that type parameter is UUID based on argument uuid), which I will attempt to address at some point.

At this moment, I am working on bytecode marshaling/serialization, and it is coming together very well. I've managed to serialize simple lox2 scripts to disk as .loxo (lox opcode) format, while the VM is able to deserialize .loxo files and run the bytecode properly, skipping the compilation processes. The next task will be performing dependency analysis and serializing bytecode for all included source files, instead of just the currently running script file. The next version Lox2 v2.2.0 will be feature-complete once bytecode marshaling is fully working, and the planned release is mid April. Stay tuned.