type alias, design flaw or design pattern?

[felixf4xu]

Hi,

I'm testing type alias by the following code

module main

type String = string

//fn (s string) test_str(){}	//error: cannot define new methods on non-local type string

fn (s String) test_str(){}

fn main() {
	s1 := String("")
	s2 := string("")

	s1.test_str()
	// s2.test_str()	//error: unknown method or field: `string.test_str`

	String(s2).test_str()
}

I have 2 questions.

1. why I can define new method for String but not string? this is not my understanding of alias, it seems that a new type is defined.

2. How to decide a type can be cast to the alias? always?

I'm not sure if this is a design flaw (bad) or design pattern (good), if it's a design pattern, then this will be a way to add new methods to existing types, but it's a little bit redundant to use type alias to do it in my point of view.

[JalonSolov]

No, it's not a flaw. If you were allowed to define new methods on built-in types, it could lead to confusion in the code base, bug reports because someone saw your method without seeing your definition, and wondering why it didn't work in their code, etc., etc.

Creating an alias is essentially creating a new type, and new types can have whatever methods you wish to define on them, as well as the ones they inherit from their parent types.

This is less confusing in V due to the naming conventions. If someone sees a method on a name with a capital letter, they know it's something defined in your code (or something you imported), rather than a built-in type.

[felixf4xu]

then is it some kind of "inheritance"?

[JalonSolov]

No. It is an alias. This means it has all the properties of the original. It simply has the extra property that you can add new methods to it, since the alias belongs to you, not the compiler.