Looking for Feedback regarding Interpreter in V

[miraculli]

Hi V-Enthusiast,

I only have decent developer experience and basically in OOP-Languages. I came across V and thought this could be the right choice for a project I have in mind vor quite some time now: A visual, collaborative flow-programming low-code platform.

The basic idea is to let the user create and manipulate a tree of nodes or "Ops" and connect the output of one node to the input of the other. Something like that is quite common and VFX/CG industry etc. For the user everything should feel more like a dynamic language and debugging, profiling, reflections stuff should be possible.

So my problem is a little bit how to "compose" this three topics: Nodes, Ops and Types.

• The Type system should be dynamic and very simple like in Lua or Excel (bool, number, string, table) and may more specific (u16, f64, rune, string etc.) for advanced users.
• The Ops should consist of a struct with Types and one "fn eval()" that calculates the output of an Op
• The Node struct should contain generic infos about the visual representation like position, name, color but also the connected input-nodes. An input always needs to map to a Ops field aka. "slot" and the Node should do the tree-traversing and calling eval()

So this is what I came up with by tinkering, reading docs, exploring some V features, ask ChatGPT and so on. I think it could work like that but overall I feel this not how V works because I think too much in OOP-Patterns

Types:

enum Type {
    bool
    number
    text
    table
}

struct Value {
    kind Type
    bool bool   
    number f64
    text string
    table map[string]Value
}

fn new_number(n f64) Value {
    return Value{
        kind: .number
        number: n
    }
}

fn new_text(value string) Value {
    return Value{
        kind: .text
        text: value
    }
}


fn main() {
    num := new_number(3.14159)
    txt := new_text('π')

    println(num)
    println(txt)
}

Nodes and Ops

interface Op {
    eval() Value
}

struct Node {
mut:
    pos struct {
        x int
        y int
    }
    color string   
    slots map[string]&Node
}

fn (mut n Node) walk() {
    for slot, input in n.slots {
            // recursivly walk down the node-tree
        }
}

struct Sum implements Op {
    Node
mut:
    lhs Value
    rhs Value
}

fn (s Sum) eval() Value {
    return new_number(s.lhs.number + s.rhs.number)
}

In general I struggle with this mixed the Node.slots and fields of an Op which should be somehow get defined during the walk(). Now, after further reading the docs I´m not sure if something completely different like utilizing comptime or @[params] is the way to go here?!

I hope I could describe where I am at and where I want to go and someone finds this interesting enough to give some god advice.
Thanks so far

:wq mirac

[gechandesu]

I don't know much about writing parsers and interpreters, but I think you might find this example useful https://github.com/shineslove/monkey_v

[JalonSolov]

Check here for examples: https://github.com/vlang/awesome-v?tab=readme-ov-file#interpreterscompilers

[JalonSolov]

Also see <v install dir>/examples/mini_calculator_recursive_descent.v for a recursive-descent parser implementation.