how to extend map interface for hashmap in vlang?

[theseusyang]

how to extend map interface for implementing hashmap in vlang?

do vlang have some tutorials for it ?

[ghost]

Maybe you have misunderstood the idea of Interface in V or Go.
The basic idea of Interface is completely different from that of Java or C#.
I recommend that you first learn about Go's interface concepts and concrete practical examples.

[theseusyang]

It doesn't matter, we don't talk about interface, I means that if I reimplement a new hashmap to extend vlang's map, how to do it?

[ghost]

Your title says about interface.

Do you know embedding of V？

In the first place, there is no concept of implement and extend in V or Go.
Instead, there is delegation, or embedding.
In V and Go, this embedding allows you to reuse existing structs.

https://github.com/vlang/v/blob/master/doc/docs.md#embedded-structs

[theseusyang]

OK, I know the embedded struct, you mean that I need embed the whole vlang's map into new hashmap implementation?

[ghost]

It's hard to say without seeing the concrete code of what you want to do, but maybe yes is the answer to it.

If you want to implement Interface in the Java sense, you are fundamentally mistaken, as I mentioned above.
There is no such concept in Go or V.
There is no concept that a struct needs to implement the methods required by an interface.
It is the other way around.
Interfaces exist to extract or substitute structs with the methods they need.

[JalonSolov]

V's maps are already hashmaps - all keys are hashed using wyhash.

[theseusyang]

I want to reimplement a custom hashmap and hashset according to Java util library

[theseusyang]

and some methods is missing in existing vlang's map.

[spytheman]

you can not

[ghost]

Maybe "type alias" for that purpose?

struct Foo{
	x int
}

type MyFoo = Foo

fn (mf MyFoo) add() int{
	return mf.x + mf.x
}

fn main(){
	f := Foo{3}
	// dump(f.add()) error
	mf := MyFoo{3}
	dump(mf.add())
}

[main.v:15] mf.add(): 6

Well, but if I were you, I'd use the embedding.
Embedding can also do the same thing as method overriding(but not method overriding strictly meaning), which is easy to understand for people come from OOP.

[theseusyang]

OK, I try this

[spytheman]

The builtin maps have compiler support in V.
Currently you can not implement your own maps, unless you also extend the compiler.

[spytheman]

The best you can do, is make your own generic struct having the behaviors that you need, but it will not be usable interchangeably with V's builtin maps.