Update Operators Topic

Author: LeonnardoVerol

docs/programming-languages/operators/operators-overloading/_c.mdx

@@ -1,3 +1,18 @@
 ```C
-// TODO
+// No Native Support.
+// Use named functions instead.
+
+typedef struct Vector2
+{
+	float x;
+	float y;
+} Vector2;
+
+Vector2 add(Vector2 first, Vector2 second)
+{
+	return (Vector2) {
+		.x = first.x + second.x,
+		.y = first.y + second.y
+	};
+}
 ```

docs/programming-languages/operators/operators-overloading/_cpp.mdx

@@ -1,3 +1,20 @@
 ```Cpp
-// TODO
+class Vector2
+{
+public:
+	float x;
+	float y;
+
+	Vector2 operator+(Vector2 const& other) const
+	{
+		return Vector2 { x + other.x, y + other.y };
+	}
+
+	bool operator==(Vector2 const& other) const
+	{
+		return x == other.x && y == other.y;
+	}
+};
+
+Vector2 result = first + second;
 ```

docs/programming-languages/operators/operators-overloading/_csharp.mdx

@@ -1,3 +1,20 @@
 ```Cs
-// TODO
+public struct Vector2
+{
+	public float X { get; }
+	public float Y { get; }
+
+	public Vector2(float x, float y)
+	{
+		X = x;
+		Y = y;
+	}
+
+	public static Vector2 operator +(Vector2 first, Vector2 second)
+	{
+		return new Vector2(first.X + second.X, first.Y + second.Y);
+	}
+}
+
+Vector2 result = first + second;
 ```

docs/programming-languages/operators/operators-overloading/_go.mdx

@@ -1,3 +1,18 @@
 ```Go
-// TODO
+// No Native Support.
+// Use named methods or functions instead.
+
+type Vector2 struct {
+	X float64
+	Y float64
+}
+
+func (first Vector2) Add(second Vector2) Vector2 {
+	return Vector2{
+		X: first.X + second.X,
+		Y: first.Y + second.Y,
+	}
+}
+
+result := first.Add(second)
 ```

docs/programming-languages/operators/operators-overloading/_java.mdx

@@ -1,3 +1,12 @@
 ```Java
-// TODO
+// No Native Support.
+// Use named methods instead.
+
+record Vector2(float x, float y) {
+	public Vector2 add(Vector2 other) {
+		return new Vector2(x + other.x, y + other.y);
+	}
+}
+
+Vector2 result = first.add(second);
 ```

docs/programming-languages/operators/operators-overloading/_javascript.mdx

@@ -1,3 +1,17 @@
 ```Javascript
-// TODO
+// No Native Support for custom operator overloading.
+// Use named methods instead.
+
+class Vector2 {
+	constructor(x, y) {
+		this.x = x;
+		this.y = y;
+	}
+
+	add(other) {
+		return new Vector2(this.x + other.x, this.y + other.y);
+	}
+}
+
+const result = first.add(second);
 ```

docs/programming-languages/operators/operators-overloading/_python.mdx

@@ -1,3 +1,16 @@
 ```Python
-# TODO
+class Vector2:
+	def __init__(self, x: float, y: float) -> None:
+		self.x = x
+		self.y = y
+
+	def __add__(self, other: "Vector2") -> "Vector2":
+		return Vector2(self.x + other.x, self.y + other.y)
+
+	def __eq__(self, other: object) -> bool:
+		if not isinstance(other, Vector2):
+			return False
+		return self.x == other.x and self.y == other.y
+
+result = first + second
 ```

docs/programming-languages/operators/operators-overloading/_rust.mdx

@@ -1,3 +1,21 @@
 ```Rust
-// TODO
+use std::ops::Add;
+
+struct Vector2 {
+	x: f32,
+	y: f32,
+}
+
+impl Add for Vector2 {
+	type Output = Vector2;
+
+	fn add(self, other: Vector2) -> Vector2 {
+		Vector2 {
+			x: self.x + other.x,
+			y: self.y + other.y,
+		}
+	}
+}
+
+let result = first + second;
 ```

docs/programming-languages/operators/operators-overloading/_typescript.mdx

@@ -1,3 +1,17 @@
 ```Typescript
-// TODO
+// No Native Support for custom operator overloading.
+// Use named methods instead.
+
+class Vector2 {
+	public constructor(
+		public readonly x: number,
+		public readonly y: number,
+	) {}
+
+	public add(other: Vector2): Vector2 {
+		return new Vector2(this.x + other.x, this.y + other.y);
+	}
+}
+
+const result = first.add(second);
 ```