elliotchance.reflect
Runtime reflection for
V
V does not carry runtime information about types. Although compile-time reflection is more performant it can be limiting in some cases that can't be avoided.
IMPORTANT: This project is more to demonstrate that a lot of the runtime reflection functionality one might need can be done without technically using runtime types. This implementation relies on static code being generated from compile-time reflection for known types going into the appropriate constructors.
Installation
v install elliotchance.reflect
Values
A
Value
import elliotchance.reflect
fn main() {
v := reflect.value_of(1.23)
println(v.typ) // "f64"
println(v.get_f64()) // 1.23
println(v.get_int()) // V panic: value must be int but is f64
}
This becomes especially useful when dealing with arrays of mixed types:
// Only sum numbers.
fn sum(items []reflect.Value) f64 {
mut total := 0.0
for item in items {
match item.typ.kind {
.is_f64 { total += item.get_f64() }
.is_int { total += item.get_int() }
else { /* ignore */ }
}
}
return total
}
fn main() {
v := [
reflect.value_of(1.23),
reflect.value_of("hello"),
reflect.value_of(7),
]
println(sum(v)) // 8.23
}
Types
All
Values
Type
.typ
-
.kind
: one of the Kind
values: is_bool
, is_string
, is_i8
, is_i16
, is_int
, is_i64
, is_byte
, is_u16
, is_u32
, is_u64
, is_rune
, is_f32
, is_f64
. -
.elem
: Only applies for arrays, describes the element type. -
.str()
: The string representation that matches the compile-time type in V.
Arrays
import elliotchance.reflect
fn main() {
v := reflect.array_of([5, 6, 7])
println(v.typ) // "[]int"
println(v.typ.kind) // "array"
println(v.typ.elem.kind) // "int"
println(v.len()) // 3
println(v.cap()) // 3
println(v.get_index(1).get_int()) // 6
println(v.get_index(5)) // V panic: array index 5 is out of bounds (len = 3)
}
Maps
import elliotchance.reflect
fn main() {
mut m := map[string]int{}
m['a'] = 5
m['b'] = 7
m['c'] = 9
v := reflect.map_of(m)
println(v.typ) // "map[string]int"
println(v.typ.kind) // "map"
println(v.typ.key.kind) // "string"
println(v.typ.elem.kind) // "int"
println(v.len()) // 3
println(v.keys()) // ['a', 'b', 'c']
println(v.get_key(reflect.value_of('b')).get_int()) // 7
println(v.get_key(reflect.value_of('d'))) // V panic: key not found: d
println(v.get_key(reflect.value_of(123))) // V panic: value must be string but is int
}
Structs
import elliotchance.reflect
struct Foo {
a int
b f64
c string
}
fn main() {
s := Foo{123, 4.56, 'hello'}
v := reflect.struct_of(&s)
println(v.typ) // "main.Foo"
println(v.typ.kind) // "struct"
println(v.fields()) // ['a', 'b', 'c']
println(v.field('b').typ) // "f64"
println(v.field('b').get_f64()) // 4.56
println(v.field('d')) // V panic: field not found: d
v.field('b').set_string('hi') // V panic: value must be f64 but is string
v.field('c').set_string('hi')
println(v.field('c').get_string()) // "hi"
println(s.c) // "hi"
}