Generics

  1. // wip
  3. struct Repo<T> {
  4.     db DB
  5. }
  7. struct User {
  8.     id   int
  9.     name string
  10. }
  12. struct Post {
  13.     id   int
  14.     user_id int
  15.     title string
  16.     body string
  17. }
  19. fn new_repo<T>(db DB) Repo<T> {
  20.     return Repo<T>{db: db}
  21. }
  23. // This is a generic function. V will generate it for every type it's used with.
  24. fn (r Repo<T>) find_by_id(id int) ?T {
  25.     table_name := T.name // in this example getting the name of the type gives us the table name
  26.     return r.db.query_one<T>('select * from $table_name where id = ?', id)
  27. }
  29. db := new_db()
  30. users_repo := new_repo<User>(db) // returns Repo<User>
  31. posts_repo := new_repo<Post>(db) // returns Repo<Post>
  32. user := users_repo.find_by_id(1)? // find_by_id<User>
  33. post := posts_repo.find_by_id(1)? // find_by_id<Post>

Currently generic function definitions must declare their type parameters, but in future V will infer generic type parameters from single-letter type names in runtime parameter types. This is why find_by_id can omit <T>, because the receiver argument r uses a generic type T.

Another example:

  1. fn compare<T>(a T, b T) int {
  2.     if a < b {
  3.         return -1
  4.     }
  5.     if a > b {
  6.         return 1
  7.     }
  8.     return 0
  9. }
  11. // compare<int>
  12. println(compare(1, 0)) // Outputs: 1
  13. println(compare(1, 1)) //          0
  14. println(compare(1, 2)) //         -1
  15. // compare<string>
  16. println(compare('1', '0')) // Outputs: 1
  17. println(compare('1', '1')) //          0
  18. println(compare('1', '2')) //         -1
  19. // compare<f64>
  20. println(compare(1.1, 1.0)) // Outputs: 1
  21. println(compare(1.1, 1.1)) //          0
  22. println(compare(1.1, 1.2)) //         -1