question about interfaces

[thacuber2a03]

question about interfaces

[vtereshkov]

null is a value, not a type. There is no name for the base type of the null constant.

[thacuber2a03]

@vtereshkov thanks :D
edit: the commit notice is there already lol

[vtereshkov]

No, this is not possible. The feature would have a high runtime cost. It has been considered in #179 and rejected.

However, I cannot see why you need this hierarchy of interfaces at all. Your Value is just a VM stack slot, not even an AST node. It's quite "passive", i.e., it shouldn't know how to evaluate() itself, as this is done by the appropriate VM instructions. Everything on the stack, including functions and objects, can be Values.

My radical suggestion is:

type Value* = any

Thus you also get the type information out of the box. Why write

if a.valueType() == .String && b.valueType() == .String {
	push(value::String(a) + value::String(b))
}

if you can write

    if lhs, rhs := ^str(a), ^str(b); lhs != null && rhs != null {
        push(lhs^ + rhs^)
    }

?

[thacuber2a03]

Thus you also get the type information out of the box. Why write

if a.valueType() == .String && b.valueType() == .String {
    push(value::String(a) + value::String(b))
}

if you can write

if lhs, rhs := ^str(a), ^str(b); lhs != null && rhs != null {
    push(lhs^ + rhs^)
}

?

what about the values that aren't base types, like value::Nil:

type Nil* = struct {}

or, say, this Function type:

type Function* = struct {
	arity: uint
	chunk: chunk::Chunk
	name: value::String
}

[thacuber2a03]

off-topic but I got issue number 404 XD

[thacuber2a03]

Thus you also get the type information out of the box. Why write

if a.valueType() == .String && b.valueType() == .String {
    push(value::String(a) + value::String(b))
}

if you can write

if lhs, rhs := ^str(a), ^str(b); lhs != null && rhs != null {
    push(lhs^ + rhs^)
}

?

what about the values that aren't base types, like value::Nil:

type Nil* = struct {}

or, say, this Function type:

type Function* = struct {
	arity: uint
	chunk: chunk::Chunk
	name: value::String
}

nevermind, did not read this:

Everything on the stack, including functions and objects, can be Values.

let me try that and see if it works out
I, however, want to keep the print and isFalsey methods

[vtereshkov]

what about the values that aren't base types, like value::Nil ... or, say, this Function type:

You can convert any type (not necessarily a basic type) to any. So you can put your Function into any and then check if it's indeed your Function:

val := any(Function{/*...*/})
//...
if f := ^Function(val); f != null {
    call(f^)
}

As for Nil, I don't know what is better: to use your own Nil as you defined it, or just set any to null.

Anyway, I think you needn't reinvent RTTI.

off-topic but I got issue number 404 XD

Also noticed this :)

[thacuber2a03]

As for Nil, I don't know what is better: to use your own Nil as you defined it, or just set any to null.

wait, I could make Nil a ^null instead, can't I?

[vtereshkov]

Great! By the way, you can join our community chat if you wish: https://discord.gg/PcT7cn59h9