mirror/v
1
0
Fork 0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
Code Issues Projects Releases Wiki Activity

docs: improve the operator overload description (#17085)

Browse Source
This commit is contained in:
Makhnev Petr 2023-01-24 02:24:50 +04:00 committed by GitHub
parent f4289cd302
commit 5dde4ce981
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 31 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
doc/docs.md
View File

@ -5605,6 +5605,8 @@ assert __offsetof(Foo, b) == 4
## Limited operator overloading ## Limited operator overloading
Operator overloading defines the behavior of certain binary operators for certain types.
```v ```v
struct Vec { struct Vec {
x int x int
@ -5627,30 +5629,46 @@ fn main() {
a := Vec{2, 3} a := Vec{2, 3}
b := Vec{4, 5} b := Vec{4, 5}
mut c := Vec{1, 2} mut c := Vec{1, 2}
println(a + b) // "{6, 8}" println(a + b) // "{6, 8}"
println(a - b) // "{-2, -2}" println(a - b) // "{-2, -2}"
c += a c += a
//^^ autogenerated from + overload
println(c) // "{3, 5}" println(c) // "{3, 5}"
} }
``` ```
Operator overloading goes against V's philosophy of simplicity and predictability. > Operator overloading goes against V's philosophy of simplicity and predictability.
But since scientific and graphical applications are among V's domains, > But since scientific and graphical applications are among V's domains,
operator overloading is an important feature to have in order to improve readability: > operator overloading is an important feature to have in order to improve readability:
>
> `a.add(b).add(c.mul(d))` is a lot less readable than `a + b + c * d`.
`a.add(b).add(c.mul(d))` is a lot less readable than `a + b + c * d`. Operator overloading is possible for the following binary operators: `+, -, *, /, %, <, ==`.
To improve safety and maintainability, operator overloading is limited: ### Implicitly generated overloads
- It's only possible to overload `+, -, *, /, %, <, >, ==, !=, <=, >=` operators. - `==` is automatically generated by the compiler, but can be overridden.
- `==` and `!=` are self generated by the compiler but can be overridden.
- Calling other functions inside operator functions is not allowed. - `!=`, `>`, `<=` and `>=` are automatically generated when `==` and `<` are defined.
- Operator functions can't modify their arguments. They cannot be explicitly overridden.
- When using `<` and `==` operators, the return type must be `bool`. - Assignment operators (`*=`, `+=`, `/=`, etc) are automatically generated when the corresponding
- `!=`, `>`, `<=` and `>=` are auto generated when `==` and `<` are defined. operators are defined and the operands are of the same type.
They cannot be explicitly overridden.
### Restriction
To improve safety and maintainability, operator overloading is limited.
#### Type restrictions
- When overriding `<` and `==`, the return type must be strictly `bool`.
- Both arguments must have the same type (just like with all operators in V). - Both arguments must have the same type (just like with all operators in V).
- Assignment operators (`*=`, `+=`, `/=`, etc)
are auto generated when the corresponding operators are defined and operands are of the same type. #### Other restrictions
- Arguments cannot be changed inside overloads.
- Calling other functions inside operator functions is not allowed (**planned**).
## Performance tuning ## Performance tuning