Operator overloading [] [Feature Request]

[LukyGuyLucky]

Describe the feature

V support simple operator overloading like +/-/*/\ ,but no index operator overloading [] which is quite useful and much convenient when a UDT type has elements.
Would this feature be considered to add in the language?

Use Case

It is preferrable to write iList[2]:=33 other than iList.at(2)=33

Proposed Solution

No response

Other Information

No response

Acknowledgements

• I may be able to implement this feature request
• This feature might incur a breaking change

Version used

0.4.8

Environment details (OS name and version, etc.)

Win 10,64bit

Note

You can use the 👍 reaction to increase the issue's priority for developers.

Please note that only the 👍 reaction to the issue itself counts as a vote.
Other reactions and those to comments will not be taken into account.

[jorgeluismireles]

I didn't know operator overloading permit the result to be of different type of the arguments. Is a bug or with something in mind? Next code is valid... Guess what the programmer wanted to do:

type Byte = u8
type Short = u16
type String = string

pub fn (b1 Byte) + (b2 Byte) Short {
	return u16(b1) + u16(b2)
}
pub fn (b1 Byte) - (b2 Byte) bool {
	if b1 > b2 {
		return true
	}
	return false
}
pub fn (b1 Byte) % (b2 Byte) String {
	return '${b1}%${b2}'
}
pub fn (b1 Byte) / (b2 Byte) String {
	return '${f64(b1)/f64(b2)}'
}

fn main() {
	println('sum:  ${Byte(255) + Byte(1)}') // 256
	println('diff: ${Byte(255) - Byte(1)}') // 1
	println('mod:  ${Byte(255) % Byte(1)}') // 255%1
	println('div:  ${Byte(1) / Byte(3)}')   // 0.3333333333333333
}

A lot of power requires a lot of responsability...

[viocha]

I think this operator is necessary for generic containers.