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
• Values
• Types
• Arrays
• Maps
• Structs

Installation

v install elliotchance.reflect

Values

A Value can be created from any literal or simple value, for example:

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 have a Type which can be accessed on the .typ field.

• .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"
}