improved naming

orange-cpp · orange-cpp · commit 17eb0cd0dc1d · 2025-05-13T09:47:08.000+03:00
diff --git a/include/omath/vector2.hpp b/include/omath/vector2.hpp
@@ -30,78 +30,78 @@ namespace omath
 
         // Equality operators
         [[nodiscard]]
-        constexpr bool operator==(const Vector2& src) const noexcept
+        constexpr bool operator==(const Vector2& other) const noexcept
         {
-            return x == src.x && y == src.y;
+            return x == other.x && y == other.y;
         }
 
         [[nodiscard]]
-        constexpr bool operator!=(const Vector2& src) const noexcept
+        constexpr bool operator!=(const Vector2& other) const noexcept
         {
-            return !(*this == src);
+            return !(*this == other);
         }
 
         // Compound assignment operators
-        constexpr Vector2& operator+=(const Vector2& v) noexcept
+        constexpr Vector2& operator+=(const Vector2& other) noexcept
         {
-            x += v.x;
-            y += v.y;
+            x += other.x;
+            y += other.y;
 
             return *this;
         }
 
-        constexpr Vector2& operator-=(const Vector2& v) noexcept
+        constexpr Vector2& operator-=(const Vector2& other) noexcept
         {
-            x -= v.x;
-            y -= v.y;
+            x -= other.x;
+            y -= other.y;
 
             return *this;
         }
 
-        constexpr Vector2& operator*=(const Vector2& v) noexcept
+        constexpr Vector2& operator*=(const Vector2& other) noexcept
         {
-            x *= v.x;
-            y *= v.y;
+            x *= other.x;
+            y *= other.y;
 
             return *this;
         }
 
-        constexpr Vector2& operator/=(const Vector2& v) noexcept
+        constexpr Vector2& operator/=(const Vector2& other) noexcept
         {
-            x /= v.x;
-            y /= v.y;
+            x /= other.x;
+            y /= other.y;
 
             return *this;
         }
 
-        constexpr Vector2& operator*=(const Type& fl) noexcept
+        constexpr Vector2& operator*=(const Type& value) noexcept
         {
-            x *= fl;
-            y *= fl;
+            x *= value;
+            y *= value;
 
             return *this;
         }
 
-        constexpr Vector2& operator/=(const Type& fl) noexcept
+        constexpr Vector2& operator/=(const Type& value) noexcept
         {
-            x /= fl;
-            y /= fl;
+            x /= value;
+            y /= value;
 
             return *this;
         }
 
-        constexpr Vector2& operator+=(const Type& fl) noexcept
+        constexpr Vector2& operator+=(const Type& value) noexcept
         {
-            x += fl;
-            y += fl;
+            x += value;
+            y += value;
 
             return *this;
         }
 
-        constexpr Vector2& operator-=(const Type& fl) noexcept
+        constexpr Vector2& operator-=(const Type& value) noexcept
         {
-            x -= fl;
-            y -= fl;
+            x -= value;
+            y -= value;
 
             return *this;
         }
@@ -164,24 +164,24 @@ namespace omath
         }
 
         // Binary arithmetic operators
-        [[nodiscard]] constexpr Vector2 operator+(const Vector2& v) const noexcept
+        [[nodiscard]] constexpr Vector2 operator+(const Vector2& other) const noexcept
         {
-            return {x + v.x, y + v.y};
+            return {x + other.x, y + other.y};
         }
 
-        [[nodiscard]] constexpr Vector2 operator-(const Vector2& v) const noexcept
+        [[nodiscard]] constexpr Vector2 operator-(const Vector2& other) const noexcept
         {
-            return {x - v.x, y - v.y};
+            return {x - other.x, y - other.y};
         }
 
-        [[nodiscard]] constexpr Vector2 operator*(const Type& fl) const noexcept
+        [[nodiscard]] constexpr Vector2 operator*(const Type& value) const noexcept
         {
-            return {x * fl, y * fl};
+            return {x * value, y * value};
         }
 
-        [[nodiscard]] constexpr Vector2 operator/(const Type& fl) const noexcept
+        [[nodiscard]] constexpr Vector2 operator/(const Type& value) const noexcept
         {
-            return {x / fl, y / fl};
+            return {x / value, y / value};
         }
 
         // Sum of elements
diff --git a/include/omath/vector3.hpp b/include/omath/vector3.hpp
@@ -29,76 +29,76 @@ namespace omath
         }
         constexpr Vector3() noexcept: Vector2<Type>() {};
 
-        [[nodiscard]] constexpr bool operator==(const Vector3& src) const noexcept
+        [[nodiscard]] constexpr bool operator==(const Vector3& other) const noexcept
         {
-            return Vector2<Type>::operator==(src) && (src.z == z);
+            return Vector2<Type>::operator==(other) && (other.z == z);
         }
 
-        [[nodiscard]] constexpr bool operator!=(const Vector3& src) const noexcept
+        [[nodiscard]] constexpr bool operator!=(const Vector3& other) const noexcept
         {
-            return !(*this == src);
+            return !(*this == other);
         }
 
-        constexpr Vector3& operator+=(const Vector3& v) noexcept
+        constexpr Vector3& operator+=(const Vector3& other) noexcept
         {
-            Vector2<Type>::operator+=(v);
-            z += v.z;
+            Vector2<Type>::operator+=(other);
+            z += other.z;
 
             return *this;
         }
 
-        constexpr Vector3& operator-=(const Vector3& v) noexcept
+        constexpr Vector3& operator-=(const Vector3& other) noexcept
         {
-            Vector2<Type>::operator-=(v);
-            z -= v.z;
+            Vector2<Type>::operator-=(other);
+            z -= other.z;
 
             return *this;
         }
 
-        constexpr Vector3& operator*=(const float fl) noexcept
+        constexpr Vector3& operator*=(const Type& value) noexcept
         {
-            Vector2<Type>::operator*=(fl);
-            z *= fl;
+            Vector2<Type>::operator*=(value);
+            z *= value;
 
             return *this;
         }
 
-        constexpr Vector3& operator*=(const Vector3& v) noexcept
+        constexpr Vector3& operator*=(const Vector3& other) noexcept
         {
-            Vector2<Type>::operator*=(v);
-            z *= v.z;
+            Vector2<Type>::operator*=(other);
+            z *= other.z;
 
             return *this;
         }
 
-        constexpr Vector3& operator/=(const Vector3& v) noexcept
+        constexpr Vector3& operator/=(const Vector3& other) noexcept
         {
-            Vector2<Type>::operator/=(v);
-            z /= v.z;
+            Vector2<Type>::operator/=(other);
+            z /= other.z;
 
             return *this;
         }
 
-        constexpr Vector3& operator+=(const float fl) noexcept
+        constexpr Vector3& operator+=(const Type& value) noexcept
         {
-            Vector2<Type>::operator+=(fl);
-            z += fl;
+            Vector2<Type>::operator+=(value);
+            z += value;
 
             return *this;
         }
 
-        constexpr Vector3& operator/=(const float fl) noexcept
+        constexpr Vector3& operator/=(const Type& value) noexcept
         {
-            Vector2<Type>::operator/=(fl);
-            z /= fl;
+            Vector2<Type>::operator/=(value);
+            z /= value;
 
             return *this;
         }
 
-        constexpr Vector3& operator-=(const float fl) noexcept
+        constexpr Vector3& operator-=(const Type& value) noexcept
         {
-            Vector2<Type>::operator-=(fl);
-            z -= fl;
+            Vector2<Type>::operator-=(value);
+            z -= value;
 
             return *this;
         }
@@ -175,40 +175,42 @@ namespace omath
             return {-this->x, -this->y, -z};
         }
 
-        [[nodiscard]] constexpr Vector3 operator+(const Vector3& v) const noexcept
+        [[nodiscard]] constexpr Vector3 operator+(const Vector3& other) const noexcept
         {
-            return {this->x + v.x, this->y + v.y, z + v.z};
+            return {this->x + other.x, this->y + other.y, z + other.z};
         }
 
-        [[nodiscard]] constexpr Vector3 operator-(const Vector3& v) const noexcept
+        [[nodiscard]] constexpr Vector3 operator-(const Vector3& other) const noexcept
         {
-            return {this->x - v.x, this->y - v.y, z - v.z};
+            return {this->x - other.x, this->y - other.y, z - other.z};
         }
 
-        [[nodiscard]] constexpr Vector3 operator*(const Type& fl) const noexcept
+        [[nodiscard]] constexpr Vector3 operator*(const Type& value) const noexcept
         {
-            return {this->x * fl, this->y * fl, z * fl};
+            return {this->x * value, this->y * value, z * value};
         }
 
-        [[nodiscard]] constexpr Vector3 operator*(const Vector3& v) const noexcept
+        [[nodiscard]] constexpr Vector3 operator*(const Vector3& other) const noexcept
         {
-            return {this->x * v.x, this->y * v.y, z * v.z};
+            return {this->x * other.x, this->y * other.y, z * other.z};
         }
 
-        [[nodiscard]] constexpr Vector3 operator/(const Type& fl) const noexcept
+        [[nodiscard]] constexpr Vector3 operator/(const Type& value) const noexcept
         {
-            return {this->x / fl, this->y / fl, z / fl};
+            return {this->x / value, this->y / value, z / value};
         }
 
-        [[nodiscard]] constexpr Vector3 operator/(const Vector3& v) const noexcept
+        [[nodiscard]] constexpr Vector3 operator/(const Vector3& other) const noexcept
         {
-            return {this->x / v.x, this->y / v.y, z / v.z};
+            return {this->x / other.x, this->y / other.y, z / other.z};
         }
 
-        [[nodiscard]] constexpr Vector3 cross(const Vector3& v) const noexcept
+        [[nodiscard]] constexpr Vector3 cross(const Vector3& other) const noexcept
         {
-            return {this->y * v.z - z * v.y, z * v.x - this->x * v.z, this->x * v.y - this->y * v.x};
+            return {this->y * other.z - z * other.y, z * other.x - this->x * other.z,
+                    this->x * other.y - this->y * other.x};
         }
+
         [[nodiscard]] constexpr Type sum() const noexcept
         {
             return sum_2d() + z;
diff --git a/include/omath/vector4.hpp b/include/omath/vector4.hpp

Original file line number	Diff line number	Diff line change
`@@ -30,78 +30,78 @@ namespace omath`
`30`	`30`
`31`	`31`	`// Equality operators`
`32`	`32`	`[[nodiscard]]`
`33`		`- constexpr bool operator==(const Vector2& src) const noexcept`
	`33`	`+ constexpr bool operator==(const Vector2& other) const noexcept`
`34`	`34`	`{`
`35`		`- return x == src.x && y == src.y;`
	`35`	`+ return x == other.x && y == other.y;`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`[[nodiscard]]`
`39`		`- constexpr bool operator!=(const Vector2& src) const noexcept`
	`39`	`+ constexpr bool operator!=(const Vector2& other) const noexcept`
`40`	`40`	`{`
`41`		`- return !(*this == src);`
	`41`	`+ return !(*this == other);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`// Compound assignment operators`
`45`		`- constexpr Vector2& operator+=(const Vector2& v) noexcept`
	`45`	`+ constexpr Vector2& operator+=(const Vector2& other) noexcept`
`46`	`46`	`{`
`47`		`- x += v.x;`
`48`		`- y += v.y;`
	`47`	`+ x += other.x;`
	`48`	`+ y += other.y;`
`49`	`49`
`50`	`50`	`return *this;`
`51`	`51`	`}`
`52`	`52`
`53`		`- constexpr Vector2& operator-=(const Vector2& v) noexcept`
	`53`	`+ constexpr Vector2& operator-=(const Vector2& other) noexcept`
`54`	`54`	`{`
`55`		`- x -= v.x;`
`56`		`- y -= v.y;`
	`55`	`+ x -= other.x;`
	`56`	`+ y -= other.y;`
`57`	`57`
`58`	`58`	`return *this;`
`59`	`59`	`}`
`60`	`60`
`61`		`- constexpr Vector2& operator*=(const Vector2& v) noexcept`
	`61`	`+ constexpr Vector2& operator*=(const Vector2& other) noexcept`
`62`	`62`	`{`
`63`		`- x *= v.x;`
`64`		`- y *= v.y;`
	`63`	`+ x *= other.x;`
	`64`	`+ y *= other.y;`
`65`	`65`
`66`	`66`	`return *this;`
`67`	`67`	`}`
`68`	`68`
`69`		`- constexpr Vector2& operator/=(const Vector2& v) noexcept`
	`69`	`+ constexpr Vector2& operator/=(const Vector2& other) noexcept`
`70`	`70`	`{`
`71`		`- x /= v.x;`
`72`		`- y /= v.y;`
	`71`	`+ x /= other.x;`
	`72`	`+ y /= other.y;`
`73`	`73`
`74`	`74`	`return *this;`
`75`	`75`	`}`
`76`	`76`
`77`		`- constexpr Vector2& operator*=(const Type& fl) noexcept`
	`77`	`+ constexpr Vector2& operator*=(const Type& value) noexcept`
`78`	`78`	`{`
`79`		`- x *= fl;`
`80`		`- y *= fl;`
	`79`	`+ x *= value;`
	`80`	`+ y *= value;`
`81`	`81`
`82`	`82`	`return *this;`
`83`	`83`	`}`
`84`	`84`
`85`		`- constexpr Vector2& operator/=(const Type& fl) noexcept`
	`85`	`+ constexpr Vector2& operator/=(const Type& value) noexcept`
`86`	`86`	`{`
`87`		`- x /= fl;`
`88`		`- y /= fl;`
	`87`	`+ x /= value;`
	`88`	`+ y /= value;`
`89`	`89`
`90`	`90`	`return *this;`
`91`	`91`	`}`
`92`	`92`
`93`		`- constexpr Vector2& operator+=(const Type& fl) noexcept`
	`93`	`+ constexpr Vector2& operator+=(const Type& value) noexcept`
`94`	`94`	`{`
`95`		`- x += fl;`
`96`		`- y += fl;`
	`95`	`+ x += value;`
	`96`	`+ y += value;`
`97`	`97`
`98`	`98`	`return *this;`
`99`	`99`	`}`
`100`	`100`
`101`		`- constexpr Vector2& operator-=(const Type& fl) noexcept`
	`101`	`+ constexpr Vector2& operator-=(const Type& value) noexcept`
`102`	`102`	`{`
`103`		`- x -= fl;`
`104`		`- y -= fl;`
	`103`	`+ x -= value;`
	`104`	`+ y -= value;`
`105`	`105`
`106`	`106`	`return *this;`
`107`	`107`	`}`
`@@ -164,24 +164,24 @@ namespace omath`
`164`	`164`	`}`
`165`	`165`
`166`	`166`	`// Binary arithmetic operators`
`167`		`- [[nodiscard]] constexpr Vector2 operator+(const Vector2& v) const noexcept`
	`167`	`+ [[nodiscard]] constexpr Vector2 operator+(const Vector2& other) const noexcept`
`168`	`168`	`{`
`169`		`- return {x + v.x, y + v.y};`
	`169`	`+ return {x + other.x, y + other.y};`
`170`	`170`	`}`
`171`	`171`
`172`		`- [[nodiscard]] constexpr Vector2 operator-(const Vector2& v) const noexcept`
	`172`	`+ [[nodiscard]] constexpr Vector2 operator-(const Vector2& other) const noexcept`
`173`	`173`	`{`
`174`		`- return {x - v.x, y - v.y};`
	`174`	`+ return {x - other.x, y - other.y};`
`175`	`175`	`}`
`176`	`176`
`177`		`- [[nodiscard]] constexpr Vector2 operator*(const Type& fl) const noexcept`
	`177`	`+ [[nodiscard]] constexpr Vector2 operator*(const Type& value) const noexcept`
`178`	`178`	`{`
`179`		`- return {x * fl, y * fl};`
	`179`	`+ return {x * value, y * value};`
`180`	`180`	`}`
`181`	`181`
`182`		`- [[nodiscard]] constexpr Vector2 operator/(const Type& fl) const noexcept`
	`182`	`+ [[nodiscard]] constexpr Vector2 operator/(const Type& value) const noexcept`
`183`	`183`	`{`
`184`		`- return {x / fl, y / fl};`
	`184`	`+ return {x / value, y / value};`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`// Sum of elements`
Original file line number	Diff line number	Diff line change
`@@ -29,76 +29,76 @@ namespace omath`
`29`	`29`	`}`
`30`	`30`	`constexpr Vector3() noexcept: Vector2<Type>() {};`
`31`	`31`
`32`		`- [[nodiscard]] constexpr bool operator==(const Vector3& src) const noexcept`
	`32`	`+ [[nodiscard]] constexpr bool operator==(const Vector3& other) const noexcept`
`33`	`33`	`{`
`34`		`- return Vector2<Type>::operator==(src) && (src.z == z);`
	`34`	`+ return Vector2<Type>::operator==(other) && (other.z == z);`
`35`	`35`	`}`
`36`	`36`
`37`		`- [[nodiscard]] constexpr bool operator!=(const Vector3& src) const noexcept`
	`37`	`+ [[nodiscard]] constexpr bool operator!=(const Vector3& other) const noexcept`
`38`	`38`	`{`
`39`		`- return !(*this == src);`
	`39`	`+ return !(*this == other);`
`40`	`40`	`}`
`41`	`41`
`42`		`- constexpr Vector3& operator+=(const Vector3& v) noexcept`
	`42`	`+ constexpr Vector3& operator+=(const Vector3& other) noexcept`
`43`	`43`	`{`
`44`		`- Vector2<Type>::operator+=(v);`
`45`		`- z += v.z;`
	`44`	`+ Vector2<Type>::operator+=(other);`
	`45`	`+ z += other.z;`
`46`	`46`
`47`	`47`	`return *this;`
`48`	`48`	`}`
`49`	`49`
`50`		`- constexpr Vector3& operator-=(const Vector3& v) noexcept`
	`50`	`+ constexpr Vector3& operator-=(const Vector3& other) noexcept`
`51`	`51`	`{`
`52`		`- Vector2<Type>::operator-=(v);`
`53`		`- z -= v.z;`
	`52`	`+ Vector2<Type>::operator-=(other);`
	`53`	`+ z -= other.z;`
`54`	`54`
`55`	`55`	`return *this;`
`56`	`56`	`}`
`57`	`57`
`58`		`- constexpr Vector3& operator*=(const float fl) noexcept`
	`58`	`+ constexpr Vector3& operator*=(const Type& value) noexcept`
`59`	`59`	`{`
`60`		`- Vector2<Type>::operator*=(fl);`
`61`		`- z *= fl;`
	`60`	`+ Vector2<Type>::operator*=(value);`
	`61`	`+ z *= value;`
`62`	`62`
`63`	`63`	`return *this;`
`64`	`64`	`}`
`65`	`65`
`66`		`- constexpr Vector3& operator*=(const Vector3& v) noexcept`
	`66`	`+ constexpr Vector3& operator*=(const Vector3& other) noexcept`
`67`	`67`	`{`
`68`		`- Vector2<Type>::operator*=(v);`
`69`		`- z *= v.z;`
	`68`	`+ Vector2<Type>::operator*=(other);`
	`69`	`+ z *= other.z;`
`70`	`70`
`71`	`71`	`return *this;`
`72`	`72`	`}`
`73`	`73`
`74`		`- constexpr Vector3& operator/=(const Vector3& v) noexcept`
	`74`	`+ constexpr Vector3& operator/=(const Vector3& other) noexcept`
`75`	`75`	`{`
`76`		`- Vector2<Type>::operator/=(v);`
`77`		`- z /= v.z;`
	`76`	`+ Vector2<Type>::operator/=(other);`
	`77`	`+ z /= other.z;`
`78`	`78`
`79`	`79`	`return *this;`
`80`	`80`	`}`
`81`	`81`
`82`		`- constexpr Vector3& operator+=(const float fl) noexcept`
	`82`	`+ constexpr Vector3& operator+=(const Type& value) noexcept`
`83`	`83`	`{`
`84`		`- Vector2<Type>::operator+=(fl);`
`85`		`- z += fl;`
	`84`	`+ Vector2<Type>::operator+=(value);`
	`85`	`+ z += value;`
`86`	`86`
`87`	`87`	`return *this;`
`88`	`88`	`}`
`89`	`89`
`90`		`- constexpr Vector3& operator/=(const float fl) noexcept`
	`90`	`+ constexpr Vector3& operator/=(const Type& value) noexcept`
`91`	`91`	`{`
`92`		`- Vector2<Type>::operator/=(fl);`
`93`		`- z /= fl;`
	`92`	`+ Vector2<Type>::operator/=(value);`
	`93`	`+ z /= value;`
`94`	`94`
`95`	`95`	`return *this;`
`96`	`96`	`}`
`97`	`97`
`98`		`- constexpr Vector3& operator-=(const float fl) noexcept`
	`98`	`+ constexpr Vector3& operator-=(const Type& value) noexcept`
`99`	`99`	`{`
`100`		`- Vector2<Type>::operator-=(fl);`
`101`		`- z -= fl;`
	`100`	`+ Vector2<Type>::operator-=(value);`
	`101`	`+ z -= value;`
`102`	`102`
`103`	`103`	`return *this;`
`104`	`104`	`}`
`@@ -175,40 +175,42 @@ namespace omath`
`175`	`175`	`return {-this->x, -this->y, -z};`
`176`	`176`	`}`
`177`	`177`
`178`		`- [[nodiscard]] constexpr Vector3 operator+(const Vector3& v) const noexcept`
	`178`	`+ [[nodiscard]] constexpr Vector3 operator+(const Vector3& other) const noexcept`
`179`	`179`	`{`
`180`		`- return {this->x + v.x, this->y + v.y, z + v.z};`
	`180`	`+ return {this->x + other.x, this->y + other.y, z + other.z};`
`181`	`181`	`}`
`182`	`182`
`183`		`- [[nodiscard]] constexpr Vector3 operator-(const Vector3& v) const noexcept`
	`183`	`+ [[nodiscard]] constexpr Vector3 operator-(const Vector3& other) const noexcept`
`184`	`184`	`{`
`185`		`- return {this->x - v.x, this->y - v.y, z - v.z};`
	`185`	`+ return {this->x - other.x, this->y - other.y, z - other.z};`
`186`	`186`	`}`
`187`	`187`
`188`		`- [[nodiscard]] constexpr Vector3 operator*(const Type& fl) const noexcept`
	`188`	`+ [[nodiscard]] constexpr Vector3 operator*(const Type& value) const noexcept`
`189`	`189`	`{`
`190`		`- return {this->x * fl, this->y * fl, z * fl};`
	`190`	`+ return {this->x * value, this->y * value, z * value};`
`191`	`191`	`}`
`192`	`192`
`193`		`- [[nodiscard]] constexpr Vector3 operator*(const Vector3& v) const noexcept`
	`193`	`+ [[nodiscard]] constexpr Vector3 operator*(const Vector3& other) const noexcept`
`194`	`194`	`{`
`195`		`- return {this->x * v.x, this->y * v.y, z * v.z};`
	`195`	`+ return {this->x * other.x, this->y * other.y, z * other.z};`
`196`	`196`	`}`
`197`	`197`
`198`		`- [[nodiscard]] constexpr Vector3 operator/(const Type& fl) const noexcept`
	`198`	`+ [[nodiscard]] constexpr Vector3 operator/(const Type& value) const noexcept`
`199`	`199`	`{`
`200`		`- return {this->x / fl, this->y / fl, z / fl};`
	`200`	`+ return {this->x / value, this->y / value, z / value};`
`201`	`201`	`}`
`202`	`202`
`203`		`- [[nodiscard]] constexpr Vector3 operator/(const Vector3& v) const noexcept`
	`203`	`+ [[nodiscard]] constexpr Vector3 operator/(const Vector3& other) const noexcept`
`204`	`204`	`{`
`205`		`- return {this->x / v.x, this->y / v.y, z / v.z};`
	`205`	`+ return {this->x / other.x, this->y / other.y, z / other.z};`
`206`	`206`	`}`
`207`	`207`
`208`		`- [[nodiscard]] constexpr Vector3 cross(const Vector3& v) const noexcept`
	`208`	`+ [[nodiscard]] constexpr Vector3 cross(const Vector3& other) const noexcept`
`209`	`209`	`{`
`210`		`- return {this->y * v.z - z * v.y, z * v.x - this->x * v.z, this->x * v.y - this->y * v.x};`
	`210`	`+ return {this->y * other.z - z * other.y, z * other.x - this->x * other.z,`
	`211`	`+ this->x * other.y - this->y * other.x};`
`211`	`212`	`}`
	`213`	`+`
`212`	`214`	`[[nodiscard]] constexpr Type sum() const noexcept`
`213`	`215`	`{`
`214`	`216`	`return sum_2d() + z;`