assignment operator overload swift

Overloading & Creating New Operators In Swift 5

We'll cover everything you need to know about operator overloading and creating custom operators with unique precedence and associativity behavior.

Operator overloading allows you to change how existing operators (e.g. + , - , * , / , etc.) interact with custom types in your codebase. Leveraging this language feature correctly can greatly improve the readability of your code.

Let’s say we had a struct to represent Money :

Now, imagine we’re building an e-commerce application. We’d likely need a convenient way of adding up the prices of all items in our shopping cart.

With operator overloading, instead of only being able to add numeric values together, we could extend the + operator to support adding Money objects together. Moreover, as part of this implementation, we could even add logic to support adding different currency types together!

In order to take advantage of this language feature, we just need to provide a custom implementation for the operator in our type's implementation:

You may have even used operator overloading without realizing it. If you've ever implemented the Equatable protocol, it requires you to provide a custom implementation for the == operator:

I hope you'll agree that, in these examples, operator overloading has increased the code's readability and expressiveness. However, we should be careful not to overdo it.

Whenever you're creating or overriding an operator, make sure its use is obvious and undisputed. Language features like this often produce diminishing returns, as the more custom behavior we introduce, the harder it is for other developers to understand our code.

Creating Custom Operators

Whenever we're discussing custom operators, overloading an existing operator is always going to be the easier option. Assuming, of course, this doesn't compromise the code's legibility.

Instead, if we want to create our own operator, we'll need to specify 3 additional pieces of information: the type of the operator, the precedence order, and the associativity behavior.

When we're simply overloading an existing operator, we inherit all of this information from the parent operator directly.

Operator Types

When we want to create our own operator, we’ll need to specify whether it's of the prefix , postfix , or infix variety.

prefix - describes an operator that comes before the value it is meant to be used with (e.x. !isEmpty )

postfix - describes an operator that comes after the value it is meant to be used with (e.x. the force-unwrapping operator - user.firstName! )

prefix and postfix are also referred to as "unary” operators as they only affect a single value.

infix - describes an operator that comes in between the value it is meant to be used with and is the most common type (e.x. + , - , / , * are all infix operators)

infix are also referred to as "binary” operators since they operate on two values.

For the statement - 2 + 5 x 5 - we know that the answer is 2 + (5 x 5) => 27 because the precedence of the operators involved tell us the order in which to evaluate the expression.

In the same way that the higher precedence of multiplication resolves the ambiguity in the order of operations here, we need to provide the compiler with similar information when we create a custom operator.

By specifying the precedence, we can control the order in which the expression is evaluated as operations belonging to a higher precedence group are always evaluated first.

We'll see how to specify the precedence of our operator shortly, but let's understand the current state of affairs in Swift first.

The following image shows a list of all precedence group types in Swift from the highest priority to the lowest priority:

If you declare a new operator without specifying a precedence group, it is a member of the DefaultPrecedence precedence group which has no associativity.

Associativity

The associativity of an operator is simply a property that specifies how operators of the same precedence level are grouped in the absence of parentheses.

Imagine we have an expression with multiple operators all belonging to the same precedence level:

We could process this expression in 2 different ways:

(20 / 2) / 5

20 / (2 / 5)

which would give us 2 and 50 , respectively.

This ambiguity is exactly what the operator's associativity helps us resolve.

An operator can be associative (meaning the operations can be grouped arbitrarily), left-associative (meaning the operations are grouped from the left), and right-associative (meaning the operations are grouped from the right).

In the simplest terms, when we say an operator is left-associative we simply evaluate our expression from left to right. Conversely, for a right-associative operator, we evaluate our expression from right to left.

As another example, we know that * , / , and % all have the same precedence, but by changing their associativity, we can get wildly different results:

Left-Associative

(4 * 8) / 2 % 5 ==> (32 / 2) % 5 ==> 16 % 5 ==> 1

Right-Associative

4 * 8 /(2 % 5) ==> 4 * ( 8 / 2) ==> 4 * 4 ==> 16

Put differently, operator associativity allows us to specify how an expression should be evaluated when it involves multiple operators of the same precedence group.

All arithmetic operators are left-associative.

In order for expressions involving our custom operator to evaluate correctly, we'll need to be mindful of both the operator's precedence and associativity behavior.

Creating A Custom Operator

With all of the theory out of the way, let's create a custom operator that will allow us to easily perform exponentiation.

Since exponentiation has a higher precedence than multiplication and is right-associative, we'll need to create a new precedence group as this operation doesn't match any of Swift's existing precedence group options.

We'll create the precedencegroup by filling in the relevant fields from this template:

Next, we need to let the compiler know about the existence of our custom operator and specify its behavior:

And now, anywhere else in our code we're free to use our custom operator:

2 ^^ 8 => 256.0

It's important to mention here that our precedence group declaration and all operator declarations and functions must be placed at the file scope - outside of any enclosing type. Don't worry if you forget this, the compiler will dutifully remind you.

Limitations Of Operator Overloading

There are a few additional caveats to mention.

While ternary operator types (e.g. var userStatus = user.age > 18 ? .approved : .rejected ) also exist in Swift, the language does not currently allow for overloading their operation.

This same restriction applies to the default assignment operator ( = ) and the compound assignment operator ( += ).

Otherwise, all operators that begin with / , = , - , + , ! , * , % , < , > , & , | , ^ , ? , or ~ , or are one of the Unicode characters specified here are fair game.

Best Practices

While this language feature is extremely powerful and go a long way towards improving your code's legibility and friendliness, it can also take you in the opposite direction.

Let's take a moment to discuss some best practices around using this language feature.

Firstly, overloading operators in Swift should be done in a way that is consistent with how the operator is normally used. A new developer should be able to reason about the expected behavior of the operator without needing to check the implementation.

Next, in situations where the traditional operators don't make semantic sense, you may want to consider creating a custom operator instead.

Finally, and a more pragmatic point, they should be easy to remember and type on the keyboard - an obscure custom operator like .|. benefits no one as its meaning is neither intuitive nor is it convenient to type.

Ultimately, this is just a long-winded way of saying that custom operators, typealias , and all other forms of "syntactic sugar" can improve your code's clarity and your development speed when used with a bit of restraint and pragmatism.

If you're interested in more articles about iOS Development & Swift, check out my YouTube channel or follow me on Twitter .

Join the mailing list below to be notified when I release new articles!

Do you have an iOS Interview coming up?

Check out my book Ace The iOS Interview !

Subscribe to Digital Bunker

How to create custom operators and do operators overloading in Swift

What is the operator.

An operator is a special symbol that you use with one or more values to produce a specific result. For example, the addition operator (+) adds two numbers and resulting in the sum between those two, as in let i = 1 + 2 .

You can think of it as a function with a unique name that can call in unusual places such as front, between, and after the value. You will see in the later section how creating a custom operator is similar to creating a function.

Before we begin to override or create a custom operator, let's learn how many types of operators we have in Swift. Which one that we can override and some limitation when we want to create a custom one.

You can easily support sarunw.com by checking out this sponsor.

Screenshot Studio: Create App Store screenshots in seconds not minutes.

Types of operators

We can categorize operators into three groups. Unary operators Binary operators Ternary operators

Unary operators

Unary operators operate on a single target such as -1, !booleanValue. Unary can appear in two places.

Unary prefix operators which appear immediately before their targets such as negative value ( -2 ) and logical not operator ( !booleanValue ).
Unary postfix operators which appear immediately after their target such as force unwrapping ( optionalValue! ).

We can overload and create a custom prefix and postfix operator.

Binary operators

Binary operators operate on two targets (such as 2 + 3). It can only appear in between their two targets, infix operator .

We can overload and create a custom infix operator.

Ternary operators

Ternary operators operate on three targets, such as the ternary conditional operator (a ? b : c).

We can't overload or create this kind of operator.

Not every type of operator can be overload. There are four restrictions that I know of:

You can't overload and create a custom ternary operator.
You can't overload the default assignment operator ( = ). You can overload other binary operators, including compound assignment operators such as a += 2.
Only a subset of the ASCII characters are supported. You can check the full list here .
Some characters and combinations are reserved for some operators. You can check the full list here .

Since we can't overload or create ternary operators, that left us with three kinds of operators to play with: Prefix Postfix Infix

Now that we know its limitation, let's try overloading existing operators, then defining your own.

Overloading the existing operators

Operator overloading lets us declare multiple operators of the same name with different implementations, in this case, different operands [1] and return type.

Let's start with overloading infix operators.

Overload new operator on strings

Swift supports the four standard arithmetic operators for all number types:

Addition (+)
Subtraction (-)
Multiplication (*)
Division (/)

Swift string doesn't support the * operator, but we will overload the * operator to work on it. We will overload the * operator to take string and integer as arguments and produce a new string representing the given string repeated the specified number of times. The result will look like this:

As I mentioned before, you can think of operators as a function with a special name. To declare overloading operators, we would do just that.

Declare as a global function You can declare it as a global function like this.

Declare as static function of a class or struct You can declare it as a static function under a class or struct. I prefer this form since it shows that the operator is a part of string capability (This is also how Swift declare the + operator on the string)

<1> We declare an infix operator that works on two operands, string, and integer, and returns a new string. <2> We create a new string representing the given string repeated the specified number of times.

Again, here is the result:

Overload existing operators with different arguments.

Swift string already overloading + operators, which concatenated two strings together.

We will overload the + operator with a different argument. Our new overloading operates on string and integer and produces a string with the last character repeated equals to the second operands.

<1> Try to get the last character. <2> Concatenate the string with the repeated last character.

To overloading a prefix operator, we need to add a prefix keyword before a func .

In the following example, I overload the - unary operator for a string, which will reverse the characters in a given string.

<1> We add the prefix keyword to tell the compiler that this is intended to use as a prefix operator.

And here is the result:

To overloading a postfix operator, we need to add a postfix keyword before a func .

In the following example, I overload ... unary operator for string which will append "..." string at the end of the given string.

<1> We add the postfix keyword to tell the compiler that this is intended to use as a postfix operator.

Adding a custom operator

If the existing operators are not enough for you, Swift allows you to define a new operator. We will create a new operator called 🦄 Unicorn operator ( .^. ). Then we will make this operator operate on a string. The unicorn operator will insert a rainbow emoji 🏳️‍🌈 according to the operation position (prefix, postfix, infix).

The first thing we need to do is telling Swift about our new operator. We will start with the infix version of our Unicorn operator.

This is a syntax to declare a new infix operator.

That's all we need to do. Now Swift knows about our new operator. We can use it the same way as we did with operator overloading.

<1> We overload our new operator with string operands. <2> Our Unicorn operator will insert a rainbow flag between two operands.

It is not much different on how to declare an infix operator. The only difference we need to make is changing the keyword from infix to postfix .

This is a syntax to declare a new postfix operator.

Then we use it just like before.

<1> We append a rainbow flag at the end of the string.

You might be able to guess. Here is how we declare a new prefix operator.

And here is how we implement it.

<1> We prepend a rainbow flag at the beginning of the string.

The difference between overload existing operator and a custom one

As you can see, the only difference between an overload existing operator and a custom one is declaring a new operator . If you are failing to do so, the compiler will give you this error.

Operator implementation without matching operator declaration error

It might be debatable about this Swift feature whether you should use it or not. In the end, it all about trades off. Using this feature would save you from some boilerplate code but might cause poor code readability since you introduce a new syntax and implementation to the existing operators. I think you would find a fair use case out of it when the time comes.

I also leave out some implementation detail of declaring a new operator, Operator Precedence and Associativity. I think it deserves its own article and I might write about it in the future. If you don't want to miss it, Subscribe or Follow me on Twitter and get notified.

Related Resourcess

Advanced Operators
Lexical Structure - Operators , List of characters that can be used to define custom operators.
Operator Declarations

The values that operators affect are operands . In the expression 1 + 2, the + symbol is a binary operator, and its two operands are the values 1 and 2. ↩︎

Enjoy the read?

If you enjoy this article, you can subscribe to the weekly newsletter. Every Friday , you'll get a quick recap of all articles and tips posted on this site . No strings attached. Unsubscribe anytime.

Feel free to follow me on Twitter and ask your questions related to this post. Thanks for reading and see you next time.

If you enjoy my writing, please check out my Patreon https://www.patreon.com/sarunw and become my supporter. Sharing the article is also greatly appreciated.

Part 2 in the series "Building Lists and Navigation in SwiftUI". We will explore a ScrollView, UIScrollView equivalent in SwiftUI.

Part 3 in the series "Building Lists and Navigation in SwiftUI". We will explore a List, UITableView equivalent in SwiftUI.

Sponsorship
Become a patron
Buy me a coffee
Privacy Policy

Overloading assignment operator

The ability to overload operators is very useful. However, that utility is diminished without the ability to overload the simple assignment operator ( = ). I vaguely recall reading somewhere that there is a reason for this having to do with syntax ambiguity. Can this problem be solved so that = can be overloaded?

Yes, I understand the concern you raise. I too have held that general opinion of overloading operators in other languages for many years. That said, overloading arithmetic and other operators causes the same opportunity for abuse. For example, overloading + for integers to do something different (like rounding instead of truncation) would make maintenance of existing programs into a giant guessing game.

That said, once the cat is out of the bag to overload operators, I don't see how adding support for = makes things any worse.

FYI, the reason for my suggestion is to add support for fixed decimal arithmetic just like that available in COBOL. Yeh I can hear the groans now. However, for business applications, fixed decimal arithmetic is a basic feature that has been tossed away in new languages by language designers who don't actually labor in the trenches. I've built a simple class to do just that - here is some sample code that uses my Number class that gives an idea of what the code does:

var amount = Number(left: 6, right: 2); var result = Number(left: 9, right: 2); amount <- 3.9; amount += 1; result <- amount * 4; print(result)

Note that <- is the assignment operator. I am sure all would agree that = is superior in this situation. Such code would be far more readable and the Number values would act just like and interoperate with Float and Int in all regards *except* that currently the = operator is not available for assignment.

PS. FWIW, the IEEE 754-2008 d128 alternative that Chris Lattner mentioned to me is inferior to the kind of support for fixed decimal arithmetic that I believe would help make Swift superior to C# for business applications.

On Dec 6, 2015, at 6:58 AM, Silvan Mosberger <[email protected]> wrote: Hi Don I think this is a terrible idea! Imagine what you’d be able to do with that: let x : String = 3 This would lead to the same problems already discussed with implicit initialisers: [swift-evolution] Proposal: Auto-convert for numbers when safe , just worse. Also assignment is something more fundamental than other operators, I doubt it’s even possible to do that. On 06 Dec 2015, at 14:44, Don Wills via swift-evolution <[email protected] <mailto:[email protected]>> wrote: The ability to overload operators is very useful. However, that utility is diminished without the ability to overload the simple assignment operator ( = ). I vaguely recall reading somewhere that there is a reason for this having to do with syntax ambiguity. Can this problem be solved so that = can be overloaded? Don Wills _______________________________________________ swift-evolution mailing list [email protected] <mailto:[email protected]> https://lists.swift.org/mailman/listinfo/swift-evolution

In your specific case, I think Alex Lew is completely correct: you really don’t want a ton of overloaded operators, you just want your decimal type to be literal-convertible.

But to answer the question more generally, no, I can’t foresee us ever allowing the overloading of =, no. = always means simple initialization/assignment in Swift; that is, it always simply propagates values around. That’s a very fundamental language concept to mess around with.

The way to fix your problem in a less ad hoc way is to allow user-defined implicit conversions, which is something we’ve talked about already in a different thread. What I said there was that it will require a lot of very careful language/type-checker design work. Here, I’d like to identity another problem: the behavior of implicit conversions can be very confusing for non-experts to reason about, and in the context of a language with a fair amount of other subtle behaviors (e.g. due to overloading), that’s a very dangerous thing to bring in. Explicit type coercions are much easier for non-experts to reason about.

On Dec 6, 2015, at 5:44 AM, Don Wills via swift-evolution <[email protected]> wrote: The ability to overload operators is very useful. However, that utility is diminished without the ability to overload the simple assignment operator ( = ). I vaguely recall reading somewhere that there is a reason for this having to do with syntax ambiguity. Can this problem be solved so that = can be overloaded?

Don, have you considered making your Number type FloatLiteralConvertible? This would allow you not just to *let number: Number = 4.9*, but also pass in 4.9 to a function that expected a *Number*. It would not let you set Number variables to be equal to other variables of type Float, it seems your main use case here is literals anyway.

On Sun, Dec 6, 2015 at 9:26 AM, Don Wills via swift-evolution < [email protected]> wrote:

Silvan, Yes, I understand the concern you raise. I too have held that general opinion of overloading operators in other languages for many years. That said, overloading arithmetic and other operators causes the same opportunity for abuse. For example, overloading + for integers to do something different (like rounding instead of truncation) would make maintenance of existing programs into a giant guessing game. That said, once the cat is out of the bag to overload operators, I don't see how adding support for = makes things any worse. FYI, the reason for my suggestion is to add support for fixed decimal arithmetic just like that available in COBOL. Yeh I can hear the groans now. However, for business applications, fixed decimal arithmetic is a basic feature that has been tossed away in new languages by language designers who don't actually labor in the trenches. I've built a simple class to do just that - here is some sample code that uses my Number class that gives an idea of what the code does: var amount = Number(left: 6, right: 2); var result = Number(left: 9, right: 2); amount <- 3.9; amount += 1; result <- amount * 4; print(result) Note that <- is the assignment operator. I am sure all would agree that = is superior in this situation. Such code would be far more readable and the Number values would act just like and interoperate with Float and Int in all regards *except* that currently the = operator is not available for assignment. Don Wills PS. FWIW, the IEEE 754-2008 d128 alternative that Chris Lattner mentioned to me is inferior to the kind of support for fixed decimal arithmetic that I believe would help make Swift superior to C# for business applications. On Dec 6, 2015, at 6:58 AM, Silvan Mosberger < [email protected]> > wrote: Hi Don I think this is a terrible idea! Imagine what you’d be able to do with that: let x : String = 3 This would lead to the same problems already discussed with implicit initialisers: [swift-evolution] Proposal: Auto-convert for numbers when safe , just worse. Also assignment is something more fundamental than other operators, I doubt it’s even possible to do that. On 06 Dec 2015, at 14:44, Don Wills via swift-evolution < > [email protected]> wrote: The ability to overload operators is very useful. However, that utility is diminished without the ability to overload the simple assignment operator ( = ). I vaguely recall reading somewhere that there is a reason for this having to do with syntax ambiguity. Can this problem be solved so that = can be overloaded? Don Wills _______________________________________________ swift-evolution mailing list [email protected] https://lists.swift.org/mailman/listinfo/swift-evolution Untracked with Trackbuster < Your contacts automatically up to date | evercontact ; _______________________________________________ swift-evolution mailing list [email protected] https://lists.swift.org/mailman/listinfo/swift-evolution

Yes, I meant for the email to go to the list.

Nope, that doesn't work because of my comment above. That's the change

to Swift I am hoping will be adopted for 3.0.

Did you try this? The idea is to write a function for multiplying a Number and an Int, so the rhs will create a Number which will then be set to the variable. It should work actually.

On Mon, Dec 7, 2015 at 00:47 Don Wills <[email protected]> wrote:

Hello Ilya, On Dec 6, 2015, at 1:09 PM, ilya <[email protected]> wrote: On Sun, Dec 6, 2015 at 5:26 PM, Don Wills via swift-evolution < > [email protected]> wrote: Silvan, Yes, I understand the concern you raise. I too have held that general opinion of overloading operators in other languages for many years. That said, overloading arithmetic and other operators causes the same opportunity for abuse.

For example, overloading + for integers to do something different (like

rounding instead of truncation) would make maintenance of existing programs into a giant guessing game. That said, once the cat is out of the bag to overload operators, I don't see how adding support for = makes things any worse.

This is not really the same. You only use + explicitely, but the compiler must insert some assigments automatically, for example by copying when the function closes over some variables. It must know exactly what the semantics in this case is to be able to compile correct program.

My example wasn't the best. IMO, there is almost no conceptual difference between "amount = 5.5;" and "amount += 5.5;". The second example works (that is += can be overloaded) where the first example is not allowed because when I try to define the "func = (...) {...}" overload implementation, the compiler squawks.

FYI, the reason for my suggestion is to add support for fixed decimal

arithmetic just like that available in COBOL. Yeh I can hear the groans now.

I'm with you.

However, for business applications, fixed decimal arithmetic is a basic feature that has been tossed away in new languages by language designers who don't actually labor in the trenches.

I didn't look into the new Foundation, but doesn't it contain NSDecimalNumber?

I've built a simple class to do just that - here is some sample code that

uses my Number class that gives an idea of what the code does: var amount = Number(left: 6, right: 2); var result = Number(left: 9, right: 2); amount <- 3.9; amount += 1; result <- amount * 4; print(result)

I'm not sure why you feel the need to overload = in this example. If Number * Int -> Number is defined, you can just use

result = amount * 4

Nope, that doesn't work because of my comment above. That's the change to Swift I am hoping will be adopted for 3.0.

Did you mean to not post your email to me only? I haven't figured out the protocol for this email list yet.

On Dec 6, 2015, at 10:54 PM, John McCall <[email protected]> wrote: On Dec 6, 2015, at 5:44 AM, Don Wills via swift-evolution <[email protected]> wrote: The ability to overload operators is very useful. However, that utility is diminished without the ability to overload the simple assignment operator ( = ). I vaguely recall reading somewhere that there is a reason for this having to do with syntax ambiguity. Can this problem be solved so that = can be overloaded?

I guess I missed the subtlety that in Swift the statement "x = y;" is fundamentally different than "x += y;". That surprises me. And it fails one of the basic principles that I've always applied to software design: The Principle of Least Astonishment.

Thanks for your response, even though it is quite disheartening to me. As I get to know the nuances of Swift, I'm starting to think that moving to Swift might be too big of a stretch for my programming staff.

Here, I’d like to identity another problem: the behavior of implicit conversions can be very confusing for non-experts to reason about, and in the context of a language with a fair amount of other subtle behaviors (e.g. due to overloading), that’s a very dangerous thing to bring in. Explicit type coercions are much easier for non-experts to reason about.

+1 to this. I am very skeptical that the benefit of implicit conversions are worth the complexity and potential for confusion, except where a natural subtype relationship exists like Chris has mentioned in relation to numerics.

I think that his number assignment (via `<~`) depends on the current state of `amount`, and that using FloatLiteralConvertible does not provide enough information at the call site (since the current value is not available in the initializer).

On Dec 6, 2015, at 1:43 PM, Alex Lew via swift-evolution <[email protected]> wrote: Don, have you considered making your Number type FloatLiteralConvertible? This would allow you not just to let number: Number = 4.9, but also pass in 4.9 to a function that expected a Number. It would not let you set Number variables to be equal to other variables of type Float, it seems your main use case here is literals anyway. FloatLiteralConvertible — SwiftDoc.org On Sun, Dec 6, 2015 at 9:26 AM, Don Wills via swift-evolution <[email protected] <mailto:[email protected]>> wrote: Silvan, Yes, I understand the concern you raise. I too have held that general opinion of overloading operators in other languages for many years. That said, overloading arithmetic and other operators causes the same opportunity for abuse. For example, overloading + for integers to do something different (like rounding instead of truncation) would make maintenance of existing programs into a giant guessing game. That said, once the cat is out of the bag to overload operators, I don't see how adding support for = makes things any worse. FYI, the reason for my suggestion is to add support for fixed decimal arithmetic just like that available in COBOL. Yeh I can hear the groans now. However, for business applications, fixed decimal arithmetic is a basic feature that has been tossed away in new languages by language designers who don't actually labor in the trenches. I've built a simple class to do just that - here is some sample code that uses my Number class that gives an idea of what the code does: var amount = Number(left: 6, right: 2); var result = Number(left: 9, right: 2); amount <- 3.9; amount += 1; result <- amount * 4; print(result) Note that <- is the assignment operator. I am sure all would agree that = is superior in this situation. Such code would be far more readable and the Number values would act just like and interoperate with Float and Int in all regards *except* that currently the = operator is not available for assignment. Don Wills PS. FWIW, the IEEE 754-2008 d128 alternative that Chris Lattner mentioned to me is inferior to the kind of support for fixed decimal arithmetic that I believe would help make Swift superior to C# for business applications. On Dec 6, 2015, at 6:58 AM, Silvan Mosberger < [email protected] <mailto:[email protected]>> wrote: Hi Don I think this is a terrible idea! Imagine what you’d be able to do with that: let x : String = 3 This would lead to the same problems already discussed with implicit initialisers: [swift-evolution] Proposal: Auto-convert for numbers when safe , just worse. Also assignment is something more fundamental than other operators, I doubt it’s even possible to do that. On 06 Dec 2015, at 14:44, Don Wills via swift-evolution < [email protected] <mailto:[email protected]>> wrote: The ability to overload operators is very useful. However, that utility is diminished without the ability to overload the simple assignment operator ( = ). I vaguely recall reading somewhere that there is a reason for this having to do with syntax ambiguity. Can this problem be solved so that = can be overloaded? Don Wills _______________________________________________ swift-evolution mailing list [email protected] <mailto:[email protected]> https://lists.swift.org/mailman/listinfo/swift-evolution

Untracked with Trackbuster < Your contacts automatically up to date | evercontact ; _______________________________________________ swift-evolution mailing list [email protected] <mailto:[email protected]> https://lists.swift.org/mailman/listinfo/swift-evolution

_______________________________________________ swift-evolution mailing list [email protected] https://lists.swift.org/mailman/listinfo/swift-evolution

Hello Ilya,

Yes, I meant for the email to go to the list. > Nope, that doesn't work because of my comment above. That's the change to Swift I am hoping will be adopted for 3.0. Did you try this? The idea is to write a function for multiplying a Number and an Int, so the rhs will create a Number which will then be set to the variable. It should work actually.

Yes, I've written a class named Number with many "func <operator> ( ... ) { ... }" implementations for the various permutations of Number, Double and operators. They all work except for when <operator> is the equal sign.

On Dec 6, 2015, at 3:05 PM, ilya <[email protected]> wrote:

On Mon, Dec 7, 2015 at 00:47 Don Wills <[email protected] <mailto:[email protected]>> wrote: Hello Ilya, On Dec 6, 2015, at 1:09 PM, ilya <[email protected] <mailto:[email protected]>> wrote: On Sun, Dec 6, 2015 at 5:26 PM, Don Wills via swift-evolution <[email protected] <mailto:[email protected]>> wrote: Silvan, Yes, I understand the concern you raise. I too have held that general opinion of overloading operators in other languages for many years. That said, overloading arithmetic and other operators causes the same opportunity for abuse. For example, overloading + for integers to do something different (like rounding instead of truncation) would make maintenance of existing programs into a giant guessing game. That said, once the cat is out of the bag to overload operators, I don't see how adding support for = makes things any worse. This is not really the same. You only use + explicitely, but the compiler must insert some assigments automatically, for example by copying when the function closes over some variables. It must know exactly what the semantics in this case is to be able to compile correct program.

FYI, the reason for my suggestion is to add support for fixed decimal arithmetic just like that available in COBOL. Yeh I can hear the groans now. I'm with you. However, for business applications, fixed decimal arithmetic is a basic feature that has been tossed away in new languages by language designers who don't actually labor in the trenches. I didn't look into the new Foundation, but doesn't it contain NSDecimalNumber? I've built a simple class to do just that - here is some sample code that uses my Number class that gives an idea of what the code does: var amount = Number(left: 6, right: 2); var result = Number(left: 9, right: 2); amount <- 3.9; amount += 1; result <- amount * 4; print(result) I'm not sure why you feel the need to overload = in this example. If Number * Int -> Number is defined, you can just use result = amount * 4

John, The ability to overload operators is very useful. However, that utility is diminished without the ability to overload the simple assignment operator ( = ). I vaguely recall reading somewhere that there is a reason for this having to do with syntax ambiguity. Can this problem be solved so that = can be overloaded?

I guess I missed the subtlety that in Swift the statement "x = y;" is fundamentally different than "x += y;". That surprises me.

It shouldn’t. I am not aware of any languages in which = (or its equivalent) is just a normal overloaded operator. Even in C++, (1) there are different formation rules for assignment operators, (2) assignment operators are often implicitly generated, (3) explicitly declared assignment operators can have subtle effects on formal language behavior, and (4) the resolution rules for assignment are different from the rules for other user-defined operators, even compound assignment.

Oh, and of course (5) the token “=" doesn’t mean assignment in the contexts where it actually means initialization, which is something that was actually confused earlier in this thread, and which is probably the single most common point of confusion among even quite knowledgeable C++ programmers — and which is, by and large, a problem that we’ve defined away in Swift by not introducing this kind of semantic confusion around the behavior of =.

And it fails one of the basic principles that I've always applied to software design: The Principle of Least Astonishment.

In fact, in my experience, programmers tend to be quite astonished by the behavior of overloaded assignment.

Again, the feature you actually need for all of your examples is literal convertibility, which already exists; please look into it before writing off the language.

On Dec 6, 2015, at 10:17 PM, Don Wills <[email protected]> wrote: On Dec 6, 2015, at 10:54 PM, John McCall <[email protected]> wrote: On Dec 6, 2015, at 5:44 AM, Don Wills via swift-evolution <[email protected]> wrote:

Thanks for your response, even though it is quite disheartening to me. As I get to know the nuances of Swift, I'm starting to think that moving to Swift might be too big of a stretch for my programming staff. Don Wills

Thanks to all who replied. I apologize that my responses were disjoint - my spam checker delayed a couple of the messages until this morning.

To those who suggested literal convertibles, I believe Stephen is correct in that it is insufficient to accomplish the semantics that I want with the syntax I had hoped for. It is about more than just initialization. I'll probably just use ":=" as the assignment operator. Not optimal, but it works.

On Dec 6, 2015, at 11:59 AM, Stephen Celis <[email protected]> wrote: I think that his number assignment (via `<~`) depends on the current state of `amount`, and that using FloatLiteralConvertible does not provide enough information at the call site (since the current value is not available in the initializer).

For what it's worth, you can accomplish a lot of assignment operator overload behavior via property get/set/willSet/didSet (similar to how Ruby methods suffixed with "=" are dispatched via dot notation), though it would require you to design your interface so that "=" is called on a property.

On Mon, Dec 7, 2015 at 9:15 AM, Don Wills via swift-evolution < [email protected]> wrote:

Thanks to all who replied. I apologize that my responses were disjoint - my spam checker delayed a couple of the messages until this morning. To those who suggested literal convertibles, I believe Stephen is correct in that it is insufficient to accomplish the semantics that I want with the syntax I had hoped for. It is about more than just initialization. I'll probably just use ":=" as the assignment operator. Not optimal, but it works. Don > On Dec 6, 2015, at 11:59 AM, Stephen Celis <[email protected]> > wrote: > > I think that his number assignment (via `<~`) depends on the current state of `amount`, and that using FloatLiteralConvertible does not provide enough information at the call site (since the current value is not available in the initializer). _______________________________________________ swift-evolution mailing list [email protected] https://lists.swift.org/mailman/listinfo/swift-evolution

Operator Overloading in Swift Tutorial

Learn how to extend operators for new types or create entirely new operators in this new Swift tutorial! By Corinne Krych.

Sign up/Sign in

With a free Kodeco account you can download source code, track your progress, bookmark, personalise your learner profile and more!

Already a member of Kodeco? Sign in

Operators: An Overview

Adding isn’t just for ints, operator overloading.

Defining Custom Operators
Naming Your Operator
Choosing a Type
Assigning Precedence and Associativity
Coding Your Custom Operator
Bonus Round!
Remember Related Operators!
Defining Operators for More Than One Type
Generics to the Rescue!
Extending With a Protocol
How Can I Use Overloading in Real Life?
Operators and CGPoints
Overloading in SKTUtils
Where to Go From Here?

Note from Ray: This is a brand new Swift tutorial released as part of the iOS 8 Feast . Enjoy!

As you’ve learned in earlier tutorials in the iOS 8 Feast, Swift offers many powerful modern programming features, such as generics, functional programming, first class enums and structs, and more.

But there’s another new feature of Swift that you should know and love: operator overloading !

This is a fancy way of saying you can make operators like + , - , / , or * to work with any type you’d like! You can even define your own operators if you’re feeling especially creative.

For example, we use operator overloading in our Swift Sprite Kit utility library to add and multiply CGPoints like this:

Handy, eh? Get ready to overload your Swift development powers – to over 9,000 !

Begin by creating a new playground to help you explore operators.

Add the following line to your playground:

You’ll see the expected result:

There are two familiar operators in play here:

First, you define a variable named simpleSum and set its value with the assignment operator ( = ).
Second, you sum the two integers using the addition operator ( + ).

You’ll be overriding operators like these in this tutorial. But first, you need to understand the concept of precedence .

You may remember from math class in school that rules of precedence apply to operators. These rules give some operators higher priority than others; higher-priority operators are applied first. For instance, you multiply before adding or subtracting.

Enter the following in your playground to confirm Swift operators follow these same rules:

You’ll see the following result:

In cases where arithmetic operators have the same precedence, Swift evaluates the operators from left to right. In this example, this means operations are completed in the following order:

3 * 2 : subtraction.
1 + 3 : Because the leftmost operator is applied first for operations with equal precedence.
4 – 6 : This operation is completed upon the results of the prior operations.

Integer arithmetic works as expected. But can you use the + operator for other types as well?

It turns out you can! Try it for yourself by adding this line to your playground:

You might expect this to add each element of the same position together. Instead, you’ll see something like this:

In this case, Swift interprets the + as an append instruction. But what if you did want to add each element by position? This is known as vector addition .

Well, you could add a custom function to do this. Give it a try by adding the following to your playground:

Here you define a global function that takes two integer arrays as input, checks that they have the same length, sums the values of each vector element and stores the resulting values in a new array.

Now add the following to confirm that your new function works:

You’ll see the following in the console:

It works! But rather than having to call a function do this, wouldn’t it be nice to use the + operator instead?

With Swift, this is possible—with the power of operator overloading !

Operator overloading allows you to change the way existing operators work with specific structures or classes. This is exactly what you need – you’d like to change the way the + operator works with Int arrays!

Because operator overloading is global to the playground scope, start with a new playground sheet to avoid impacting your earlier examples. Then add the following to your playground:

You’ve just defined a global function called + that takes two Int arrays as input and returns a single Int array. Here’s a breakdown of how it works:

Note there’s nothing fancy about this function definition. It’s a normal function definition except you use + for the name!
Here you create an empty Int array.
This sample will only work with input arrays of the same length, and this assert enforces that.
You then enumerate through the left array, and sum each value with the corresponding value in the right array at the same position.

Test this function by adding the following to your playground:

Finally—the expected results of your vector addition operator! You will see the following in the console:

Of course, operator overloading isn’t all fun and games. It would be fairly confusing to someone jumping into your code if they were expecting the default behavior. For that matter, there’s nothing to stop you from overriding the + operator to, for example, perform subtraction on integers—the risks are obvious!

Remember the operator overloading mantra: with great power comes great responsibility.

Typically, you’ll use overloading to extend an operation to a new object while maintaining the original semantics, rather than defining different (and confusing) behavior.

In this example, the behavior override does maintain semantics; vector addition is still a form of addition. But you may still want the ability to append arrays, and you want to avoid confusing yourself months down the road when you’ve forgotten you overrode the default behavior for Int arrays.

Fortunately, Swift lets you create your own custom operators.

All videos. All books. One low price.

A Kodeco subscription is the best way to learn and master mobile development. Learn iOS, Swift, Android, Kotlin, Flutter and Dart development and unlock our massive catalog of 50+ books and 4,000+ videos.

This page requires JavaScript.

Please turn on JavaScript in your browser and refresh the page to view its content.

Operator Overloading in Swift

In Swift, operator overloading provides a powerful mechanism for extending the functionality of built-in operators to work with custom types. By defining custom implementations for operators like + , - , * , and more, developers can imbue their own types with expressive and intuitive behavior, enhancing code readability and maintainability. In this guide, we'll explore the concept of operator overloading in Swift, understand its syntax and conventions, and delve into practical examples showcasing its versatility and utility.

Introduction to Operator Overloading

Operator overloading allows developers to redefine the behavior of existing operators for their custom types. This means that operators such as + , - , * , and others can be used with user-defined classes and structures, enabling intuitive and concise syntax for performing operations specific to those types.

Syntax of Operator Overloading

In Swift, operator overloading is achieved by defining global functions with the operator keyword followed by the operator to be overloaded. Let's look at a simple example of overloading the addition operator + for a custom Vector type:

In this example, we define a custom Vector structure and then extend it to provide a custom implementation of the addition operator + . This implementation allows us to add two Vector instances together using the familiar + syntax.

Using Operator Overloading

Once operators are overloaded for custom types, they can be used just like built-in operators. Let's see how we can use the custom + operator with our Vector type:

In this example, we create two Vector instances and add them together using the overloaded + operator, resulting in a new Vector instance with the summed components.

Precedence and Associativity

When overloading operators, it's important to consider precedence and associativity to ensure that the behavior is consistent with other operators in Swift. Precedence determines the order in which operators are evaluated in an expression, while associativity determines the grouping of operators with the same precedence. Swift provides default precedence and associativity for many operators, but custom operators can specify their own precedence and associativity using operator declarations.

Practical Examples of Operator Overloading

Operator overloading can be used in a wide range of scenarios to enhance code readability and expressiveness. Some practical examples include:

Overloading arithmetic operators for custom numeric types like matrices or complex numbers.
Overloading comparison operators ( == , != , < , > , etc.) for custom types to define custom equality or ordering criteria.
Overloading bitwise operators ( & , | , << , >> , etc.) for custom bit manipulation operations.

Operator Overloading in Swift Programming

Operator overloading in Swift provides developers with a powerful tool for extending the functionality of built-in operators to work with custom types. By defining custom implementations for operators, developers can create more expressive, intuitive, and concise code, enhancing the readability and maintainability of their Swift codebases. Whether it's arithmetic operations, comparison operations, or bitwise operations, operator overloading allows Swift developers to unleash the full potential of their custom types. Happy coding!

Apple releases new AI models: OpenELM and CoreNet

Apple just introduced eight new language models called OpenELM. What's cool about them is that they can run directly on your device, like your iPhone or MacBook, instead of needing to connect to the internet. Four of these models were trained using a special tool called CoreNet, made

Introduction to SwiftData: Data Management in Swift

In the realm of iOS and macOS app development, efficient data management is crucial. From storing user preferences to managing complex relational data, developers rely on frameworks and libraries to streamline these tasks. One such solution gaining traction in the Swift community is SwiftData. In this article, we'll

Static Properties and Methods in Swift

When building software applications, especially in Swift, a programming language developed by Apple, it's essential to understand concepts like static properties and methods. They provide a powerful way to organize code and manage shared resources across instances of a class or struct. In this article, we'll

Initializer and Deinitializer in Swift: Instance Lifecycle

In Swift, initializers and deinitializers are essential components for managing the lifecycle of instances of classes, structs, and enumerations. They are responsible for initializing and deinitializing the properties and resources associated with an instance. Let's explore each of them in detail: Initializers: Initializers are special methods that are

Beginning iOS Programming with Swift
Intermediate iOS Programming with Swift
Mastering SwiftUI
Mastering Machine Learning with Core ML and Python
Swift Course
All Tutorials
App Marketing
App Showcase
App Template
Write for Us

An Introduction to Operator Overloading in Swift

Cosmin pupăză.

29th Mar '16

Operator overloading is one of the most powerful features of any computer programming language, so Apple decided to make it available for development in Swift. However, with great power comes great responsibility. You can easily implement really weird scenarios with it, such as making the subtraction operator add numbers or the division one multiply them, but that is definitely not what you want to do with it.

OK, enough talking – let’s see what operator overloading is all about.

The Challenge

Your task for this tutorial is an easy one: extend the multiplication operator’s standard functionality for numbers so that it works for strings as well. You are going to use the string concatenation operator under the hood, since you can imagine the whole thing like this:

Before diving into coding, think how you would solve the problem and break it into steps. This is how I would do it:

Create the result variable and assign its initial value – the default string.
Loop through the numbers from 2 to the number of concatenations and do only one thing for each iteration – add the string to the result.
Print the result to the console.

That’s it for the algorithm – let’s move on to the implementation.

Basic Operator Overloading

Fire up Xcode and open a playground. Delete everything from it and add the multiplication operator function’s prototype:

The function has two parameters – the left hand side operand of type String and the right hand side operand of type Int – and returns the multiplication result as String .

There are three things you should do inside the function’s body. First of all, create the result variable and assign its initial value – the function’s String argument – it is variable because you are going to change its value soon:

Next loop through the numbers from 2 to the function’s Int argument with the for in control flow statement and the closed range operator:

Note: You implement the wildcard pattern matching with the underscore since you ignore the sequence values – read more about loops here .

There is only one thing you should do in the loop – update the result with the string value:

Note: You could also do it like this – the initial approach is shorter because it uses the addition assignment operator:

Finally, return the result:

Now let’s use the operator:

That’s it! There is only one problem – you can only use the operator to multiply strings. How about other value types? Let’s fix this with generic operators.

Generic Operators

Generic types don’t work with operators by default, so you need a protocol for that. Add its prototype to the playground:

Now add the addition assignment operator function’s prototype to the protocol:

The function has both the left hand side and right hand side operands of type Self – this is just a fancy way of saying that they are of any type which implements the protocol. The left hand side operand is marked as inout , since its value is modified and returned from the function.

Alternatively, you can define the addition operator function’s prototype:

The function has both the left hand side and right hand side operands of type Self and returns the addition result as a value of type Self . In this case, you do not need to use inout parameters anymore.

Next, create extensions for the String , Int , Double and Float types that implement the Type protocol:

Note: The implementation of the extensions are empty because you don’t want to add anything to the default types. You simply make them in order to conform to the protocol.

Now add the multiplication operator function’s prototype to the playground file:

The function takes in two parameters – the left hand side operand of type T and the right hand side operand of type Int – and returns the multiplication result as a value of type T . You use a type constraint to make the generic type T conform to the Type protocol, so it now understands the addition assignment operator.

Note: You can define the type constraint with the where keyword instead – the initial approach is shorter though:

The function’s implementation is exactly the same as in the previous case:

Note: You can use the addition operator instead – make sure to add its function prototype to the protocol in this case.

Now let’s see the generic operator in action:

That’s it! There is only one problem: you are using the standard multiplication operator. That’s a bit confusing. It would better if we can change it to other operators. Okay, let’s see how we can fix this with custom operators.

Custom operators

Add this line to the playground file to get started:

Here’s what’s going on here, step-by-step:

The custom multiplication operator’s name is ** .
Its type is infix since it is a binary operator with two operands.
It evaluates from left to right, so it has a left associativity.
Its precedence is 150 – the same as the standard multiplication operator’s one, since it is a high priority operator.

Note: You can read more about operator precedence and associativity here .

The custom operator function’s prototype is similar to the standard one – just its name is different:

The function’s implementation is exactly the same as before:

Here’s the custom operator in action:

That’s it! There is only one problem – the operator’s compound version is not defined yet, so let’s fix this in the next section.

Compound Operators

The compound operator’s type, precedence and associativity is exactly the same as in the previous case – only its name is different:

Next add the compound operator function’s prototype to the playground:

The function doesn’t have a return type, since its left hand side operand is marked as inout .

There is only one thing you should do in the function’s body – use the custom operator defined earlier to return the multiplication result:

That’s it – it can’t get any simpler than that!

Operator overloading, used with caution, can be extremely powerful – I hope you find a way to use it in your own projects.

For reference, you can download the Playground file on GitHub . I have tested the code on Xcode 7.3 and Swift 2.2.

What do you think about this tutorial and operator overloading? Please leave me comment and share your thought.

Cosmin Pupăză blogs about Swift and iOS development at cosminpupaza.wordpress.com and on the Swift tutorial teams at raywenderlich.com and appcoda.com. When not coding, he plays the guitar or studies WW2 history. You can contact him at [email protected] , on Facebook, Twitter and Google+.

How to draw lines and create pie charts using swiftui, building an interactive voice app using custom siri shortcuts in ios 12, using asyncimage in swiftui for loading images asynchronously.

Great tutorial! As you pointed out, operator overloading is a powerful tool that could be abused to create code that’s clever but hard to follow. Lately I’ve been bitten by the functional bug, which makes me allergic to for loops. Here is an alternative implementation that’s a little less imperative:

protocol Type { func +(lhs: Self, rhs: Self) -> Self }

extension String: Type {} extension Int: Type {} extension Double: Type {} extension Float: Type {}

infix operator ** {associativity left precedence 150}

func **(lhs: T, rhs: Int) -> T { let items = Array(count: rhs-1, repeatedValue: lhs) return items.reduce(lhs){$0 + $1} }

Good point – I like your implementation! I am a big functional programming fan as well – you can check out my imperative vs functional programming techniques tutorial series on my blog: https://cosminpupaza.wordpress.com/tutorials/ . The imperative approach adds boilerplate code, but it’s more suitable for beginners than its functional counterpart, which is more abstract and hard to understand, so that’s why I’ve chosen this approach for the tutorial. Cheers! 🙂

Cancel Reply

Save my name, email, and website in this browser for the next time I comment.

Advisory boards aren’t only for executives. Join the LogRocket Content Advisory Board today →

Product Management
Solve User-Reported Issues
Find Issues Faster
Optimize Conversion and Adoption
Start Monitoring for Free

Creating custom operators in Swift

What is an operator in swift, types of operators in swift, operator notation, operator precedence and associativity in swift, common operators in swift, defining a custom operator in swift, setting precedence of custom swift operators, specifying the notation of a custom operator in swift.

Operators are one of the basic constructs of any programming language. They are represented as symbols and have various associated properties, and understanding them is crucial to mastering any programming language.

In this article, we’ll look at some of the operators that Swift ships with and also create our own operators.

Before we begin looking at the different operators that Swift provides us with and creating custom operators, let’s understand a few basic terms related to them. Here’s an example:

Here, we can see a few variables and constants being defined, along with a few symbols (e.g., = and + ). Let’s define two terms here:

Operators: any symbol that is used to perform a logical, computational, or assignment operation. = is used to assign and + is used to add in the above example and are therefore operators
Operands: variables on which operations are performed, e.g., on line 1 we have a as an operand, and on line 3, we have a and b as two operands on which the + operator is being applied

There are three different types of operators, which are defined by the number of operands they work on.

Unary operators: operators that work on only one operand (e.g., = and ! )
Binary operators: work on two operands, such as + , - , * , etc.
Ternary operator: works on three operands, e.g., ?:

Notation defines the position of the operator when used with the operands. There are again three types:

Infix : when the operators are used in between operands. Binary and ternary operators are always infixed
Prefix : when the operators are used before an operand, e.g., ++ , -- , and !
Postfix : when the operators are used after an operand, e.g., …

When working with operators in Swift, you should also know the priority order in which the operator is executed. Operator precedence only matters for infix operators, as they work on multiple operands.

For example, if an expression has multiple operators in it, Swift needs to know which operator needs to be executed first.

In the above example, * has more precedence compared to + , which is why 6*2 is executed before 4+6 .

In case you have two operators with the same precedence being used in an expression, they’ll fall back on their associativity. Associativity defines the direction in which the expression will start resolving in case the precedence of the operators are the same.

Associativity is of two types:

left : this means that the expression to the left will be resolved first
right : this means the expression to the right will be resolved first

For example, we have the following statement:

Because both + and - have the same precedence, Swift falls back to the associativity of the operators. + and - have associativity of left , so we resolve the expression from the left so that + is evaluated first.

Here’s a table of the precedence order that Swift follows. The table lists the precedence in the order of decreasing priority.

Now that we know the basics of what Swift operators are and how they are used, let’s look at popular operators that ship with Swift.

Over 200k developers use LogRocket to create better digital experiences

The most common operators that Swift ships with fall under the following categories:

1. Assignment operator

Assignment operators are used to assign values to a constant or variable. The symbol is = .

2. Arithmetic operators

These operators are used to perform basic arithmetic operations, such as + , - , * , / , and % .

3. Logical operators

Logical operators are used to combine two conditions to give a single boolean value output, e.g., ! , && , and || .

4. Comparison operators

These operators are used to compare numbers and give out a true or false output: > , < , == , >= , <= , and != .

5. Ternary operator

This operator is a shorthand operator for writing if-else conditions. Even though it does the same job, it is not a good idea to consider it a replacement for if-else conditions because it hampers readability.

Therefore, when you have different code blocks to run for different conditions, it’s better to use if-else blocks. For shorter, simpler cases, use the ternary operator. The operator, ?: , is used like this:

6. Nil coalescing operator

This is a shorthand operator to return default values in case a particular variable is nil. The operator symbol is ?? and commonly used like this:

7. Range operators

These operators are used to define ranges, e.g., … and ..< . They are mainly used with array/strings to extract sub arrays/strings.

For a list of all the basic operators and their descriptions, read the Swift documentation .

Now that we’ve seen the operators that Swift ships with, let’s create our own operators. Custom operators are generally defined for three purposes:

To define a completely new operator because you think the symbol’s meaning can express what the operator will do better than a function with a name can
To define an operator that exists for basic data types like numbers or strings but does not exist for classes or structs that have been defined by you
You want to override an operator that already exists for your classes and structs, but you need it to behave differently

Let’s look at all three purposes with examples.

Creating a new operator with a new symbol

Let’s say you want to define an operator with the △ symbol that calculates the hypotenuse of a right angle triangle given its two sides.

Creating an operator for a custom class or struct

We know that the + operator is used to add two numbers, but let’s say we wanted to add two instances of our struct called Velocity , which is a two-dimensional entity:

If we were to run the following command, you’d get a compiler error:

In this case, it makes sense to define a + operator that takes care of adding two Velocity instances:

Now the earlier statement will execute properly.

Overriding a Swift operator that already exists for a class/struct

Let’s say you have a struct that is used to define an item in a supermarket.

When we need to compare two items, such that if two items have the same itemName , itemType , and itemPrice , we need to consider them equal regardless of what their id is.

If you run the following piece of code, you’ll see that the two variables are not equal:

The reason for this is that instances detergentA and detergentB have different ids . In this case, we need to override the == operator and custom logic to determine equality.

Now that we know the different scenarios in which we define custom operators, let’s define our custom operator.

A custom operator is defined just like a function is defined in Swift. There are two types of operators you can define:

Global operator

Operator specific to a class/struct

The definition looks like the following:

There are different types of parameters you can define based on whether it is an infix or a prefix / postfix operator.

If it’s an infix operator, you can have two parameters, and, when it’s a prefix / postfix operator, you can have a single parameter.

With global operators, we first define the operator with the notation keyword ( infix , prefix or postfix ) and the operator keyword, like this:

Here’s an example:

Operator for class/struct

When we want to define an operator for a class or a struct, we need to define the operator function as a static function. The notation parameter is optional in case the operator is an infix operator (i.e., you have two parameters in the function signature), else you need to specify prefix or postfix :

Given that we’ve already looked at defining basic custom operators like + and == , let’s review some examples of how you can define custom compound operators or operators that mutate the parameters themselves.

We’ll do this by defining a custom compound arithmetic operator for the Velocity struct from earlier:

Now let’s execute the following statement:

Now, we’ll specify the notation of a custom operator.

In order to define the notation of a custom operator, you have three keywords for the corresponding notation:

When defining a global operator, you need to first define the operator’s notation, then define its functions. Note that this is not a compulsory step, but it’s necessary if you want to define global operators or hope to assign a precedence to it (which we’ll discuss in the next section).

Let’s look at the hypotenuse operator again, which is being defined as a global operator. You can see that we first define the operator with the notation and the symbol, then implement its logic:

When defining an operator for your own class/struct, you can directly use the notation keyword with the method definition. For example, let’s define a negation operator for Velocity as well, which negates both the xVelocity and yVelocity properties. This operator is going to be defined as a prefix operator:

You can also define the precedence of your operator using the precedence keywords, as mentioned in the precedence table above. This is usually done in the definition step:

This way, the compiler knows which operator needs to be executed first. In case no precedence is specified, it defaults to DefaultPrecedence , which is higher than TernaryPrecedence .

This brings us to the conclusion of what operators are in Swift and how you can create your own. Although they are pretty simple to use, understanding them is important because they are one of the most foundational constructs of any programming language.

You should be familiar with basic operators, as you will be using them frequently in your code, and, when it comes to custom operators, define them only if the symbol’s original meaning makes sense for you.

Get set up with LogRocket's modern error tracking in minutes:

Visit https://logrocket.com/signup/ to get an app ID

Install LogRocket via npm or script tag. LogRocket.init() must be called client-side, not server-side

Stop guessing about your digital experience with LogRocket

Using Pavex for Rust web development

The Pavex Rust web framework is an exciting project that provides high performance, great usability, and speed.

Using the ResizeObserver API in React for responsive designs

With ResizeObserver, you can build aesthetic React apps with responsive components that look and behave as you intend on any device.

Creating JavaScript tables using Tabulator

Explore React Tabulator to create interactive JavaScript tables, easily integrating pagination, search functionality, and bulk data submission.

How to create heatmaps in JavaScript: The Heat.js library

This tutorial will explore the application of heatmaps in JavaScript projects, focusing on how to use the Heat.js library to generate them.

Operator Overloading — Tailor Swift To Your Needs

Last updated on August 12, 2020

Sorry, but I have been waiting for months to make this pun. So today, we are going to talk about Operator overloading in Swift. This tool is very useful, but quite dangerous as well. The “With great power comes great responsibility,” quote is very appropriate for operator overloading. It can make your code a lot more concise, making even a function call seem like a 3-hour long lecture. But with that, you can also make the code nigh-unreadable to anybody that is new to your code.

Be very careful with this tool, and use it where it make sense, such as how “adding” two Swift Strings together makes a new string with one string first, then the other afterwards. You can make the addition operator print to the screen, make a network request, play music, or whatever else you could write a function for, but doing any of those would be a terrible idea in production code. You should do only what is necessary for the operator and nothing else. If you need different things like those, make an appropriately named function that makes it obvious that it will make a network request.

Whenever you think of whether to use operator overloading, you have to ponder whether it helps your code anymore than a simple function call. The function call may be longer, but it is a whole lot more expressive as to what it does (if named appropriately). If it looks like you are adding, subtracting, checking equality, or whatever else the built-in operators do though, and you do it enough in your code, Swift’s operator overloading may be the right tool for the job.

Operator Overloading

You should only use operator overloading in a way that is consistent with how the operator is normally used in Swift. Here is an example I thought of that could make sense, though there are still some pitfalls with it. Let’s say we want to find the amount of time between two Date objects. It would make sense to get that via “laterDate – initialDate” right? So let’s do that:

In this case, I chose the Calendar.Components of year, month, day, hour, minute, and second as the components to use in this subtraction. Herein lies ones of the pitfalls. There are several other Components I could choose. If I just wanted to know the weeks between something, I could put that in instead for this. Nonetheless, using these units give us what we would want in most calendrical calculations. The next line just creates the DateComponents object using components:from:to: from the currentCalendar. We’re taking advantage of the fact that a single line of code that returns something can be used without explicitly writing return, because it is pretty clear to the compiler that a function that returns a date components being the only thing called in a function that also returns DateComponents would simply want to forward that return.

An operator used between two values is called an infix operator. There are two other overloadable types of operators known as prefix and postfix , like the old ++i and i++ operators of yore.

As you can see from the top, this is just a function in Swift, but instead of a text name, we have a symbol as the name. We specify the types of inputs for the left and right parts of the expression, and then specify the return type, which for this calculation should be an DateComponents object. Now we can use it like this:

There was a bit of setup there, but most of it should be pretty easy to understand. We first create an initial date, which has the value of the moment the Date object was created. Then there’s an DateComponents object that has its year, month, and minute values set. Then the laterDate constant is made, using Calendar’s dateByAddingComponents method, so that makes a value 1 year, 5 months, and 42 minutes in the future. Then we actually test our new capability for the ” – ” operator. When we look at the components of the result of our subtraction, you can see it has the correct value for the year, month, and minute value for exactly how far in the future it was.

I think that this function is a marginally okay use of operator overloading. It is using the subtraction operator how it is normally used in math. However, it hides several assumptions. I already mentioned that it uses certain Calendar.Components, but not all of them. Secondly, it uses Calendar’s current variable. I think this makes sense, but it is nonetheless hidden.

If we just use the normal function call that is behind our overloaded operator, you can clearly see what calendar it is using and which flags you want. That is why I only say that this is a marginally okay use of operator overloading. It makes sense, but it hides those assumptions from the reader, making them have to look up the operator overloading function to see what assumptions are made.

The Equatable Protocol

There are a few places in Swift where operator overloading is actually encouraged. If you want to be able to compare your custom class with the ” == ” operator, you will have to overload it. If you are going to implement this, your class should probably adopt the Equatable protocol. The Equatable protocol is used often with Generic functions (you can read more about them here: Generic Functions in Swift ), when it will need to check for equality inside. If you do, you only need to implement the ” == ” operator, you get the != for free (since it is basically just negating the ” == ” operator’s answer.

The way you overload the ” == ” operator is the same as with any other infix operator, like what we did above with the ” – ” operator. Let’s make a custom type and overload the ” == ” operator below:

Now we can compare Temperature instances with the ” == ” operator. When an operator is overloaded, it must be marked as static. Actually, if I had made this a struct or enum, I wouldn’t even need the initializer or the operator overloading! If the parts in it are hashable or equatable, structs and enums can generate those methods themselves, without me needing to explicitly write them. The same is not extended to classes, and really, this type should’ve been a struct, but I wanted to show the behavior for a type that didn’t automatically get those methods when they adopt the protocol.

Another place where operator overloading in Swift is encouraged is with the Comparable protocol. To conform to the Comparable protocol you must implement an operator function for the ” < ” operator, as well as conform to the Equatable protocol. With you implementing == and > operators, the compiler can figure out the !=, <, <=, and >= operators for you. You can see an example of this in my previous post Generic Functions in Swift . It also has another example of overloading the ” == ” operator.

I debated showing the Date subtraction example above, due to how it hides many assumptions about the code being called. I decided to share it though, because it also highlights what you have to think about when deciding to use operator overloading in Swift. If you are doing subtraction of dates a lot in your code, always with the same unitFlags, overloading the subtraction operator could make your code a lot more readable.

There are a few operators that you cannot overload, most notably the assignment operator ” = ” (just one equal sign). Even if you could, I’m not sure I would want to know the chaos that would be wrought by doing so, considering how much the assignment operator is used. You can read more about the operators you can’t overload at Tammo Freese ‘s article Facets of Swift, Part 5: Custom Operators .

Much like Custom Subscripts in Swift , this tool is very useful, but very dangerous. Use it wisely .

In updating this post, there are two very welcome updates to Swift that made the code for the “-” operator’s overload much nicer. Firstly, that you can use the most common Calendar.Components with their common names (.Year, .Month, etc.) instead of the longer original ones ( . YearCalendarUnit, .Month CalendarUnit, etc.). Secondly, the code used to use the OR operator ” | ” to combine the unit flags. Now, Swift lets you give it a Swift Set type for options of that sort, which itself can be created with a Swift Array literal.

I hope you found this article helpful. If you did, please don’t hesitate to share this post on Twitter or your social media of choice. The blog is still pretty new, and every share helps. Of course, if you have any questions, don’t hesitate to contact me on Twitter @CodingExplorer , and I’ll see what I can do. Thanks!

The Swift Programming Language – Apple Inc.
Facets of Swift, Part 5: Custom Operators — Swift Programming — Medium
Terms Of Use
Privacy Policy
Affiliate Disclaimer

Subscribe to the Coding Explorer Newsletter

Swift Tutorial
Swift - Home
Swift - Overview
Swift - Environment
Swift - Basic Syntax
Swift - Variables
Swift - Constants
Swift - Literals
Swift - Comments
Swift Operators
Swift - Operators
Swift - Arithmetic Operators
Swift - Comparison Operators
Swift - Logical Operators

Swift - Assignment Operators

Swift - Bitwise Operators
Swift - Misc Operators
Swift Advanced Operators
Swift - Operator Overloading
Swift Customized Operators
Swift - Advanced Operators
Swift - Arithmetic Overflow Operators
Swift - Identity Operators
Swift - Range Operators
Swift Data Types
Swift - Data Types
Swift - Integers
Swift - Floating-Point Numbers
Swift - Double
Swift - Boolean
Swift - Strings
Swift - Characters
Swift - Type Aliases
Swift - Optionals
Swift - Tuples
Swift - Assertions and Precondition
Swift Control Flow
Swift - Decision Making
Swift - if statement
Swift - if...else if...else Statement
Swift - if-else Statement
Swift - nested if statements
Swift - switch statement
Swift - Loops
Swift - for in loop
Swift - While loop
Swift - repeat...while loop
Swift - continue statement
Swift - break statement
Swift - fall through statement
Swift Collections
Swift - Arrays
Swift - Sets
Swift - Dictionaries
Swift Functions
Swift - Functions
Swift - Nested Functions
Swift - Function Overloading
Swift - Recursion
Swift - Higher-Order Functions
Swift Closures
Swift - Closures
Swift-Escaping and Non-escaping closure
Swift - Auto Closures
Swift - Enumerations
Swift - Structures
Swift - Classes
Swift - Properties
Swift - Methods
Swift - Subscripts
Swift - Inheritance
Swift-Overriding
Swift - Initialization
Swift - Deinitialization
Swift Advanced
Swift - ARC Overview
Swift - Optional Chaining
Swift - Error handling
Swift - Concurrency
Swift - Type Casting
Swift - Nested Types
Swift - Extensions
Swift - Protocols
Swift - Generics
Swift - Access Control
Swift Miscellaneous
Swift - Function vs Method
Swift - SwiftyJSON
Swift - Singleton class
Swift Random Numbers
Swift Opaque and Boxed Type
Swift Useful Resources
Swift - Compile Online
Swift - Quick Guide
Swift - Useful Resources
Swift - Discussion
Selected Reading
UPSC IAS Exams Notes
Developer's Best Practices
Questions and Answers
Effective Resume Writing
HR Interview Questions
Computer Glossary

Assignment Operators are the special operators. They are used to assign or update values to a variable or constant. In the assignment operators, the right-hand side of the assignment operator is the value and the left-hand side of the assignment operator should be the variable to which the value will be assigned.

The data type of both sides should be the same, if they are different we will get an error. The associativity of assignment operators is from right to left. Swift supports two types of assignment operators −

Simple Assignment Operator − It is the most commonly used operator in Swift. It is used to assign value to a variable or constant.

Compound Assignment Operators − They are the combination of assignment operator (=) with other operators like +, *, /, etc.

The following table shows all the assignment operators supported by Swift −

Assignment Operator in Swift

An assignment operator "=" is the most straightforward and commonly used operator in Swift. It is used to assign value to a constant or variable. The left-hand side of the assignment operator contains the variable name and the right-hand side contains the value.

While using the assignment operator always remember the data type of both the operands should be the same.

Following is the syntax of the assignment operator −

Swift program to assign a string to a variable.

Add and Assignment Operator in Swift

An Add and Assignment Operator "+=" is used to perform addition between the left variable and right variable and then assign the result to the left variable. Suppose we have two variables A = 10 and B = 20. A += B => A = 10 + 20 => A = 30.

Following is the syntax of the add and assignment operator −

Swift program to find the sum of two variables using add and assignment operator "+=".

Subtract and Assignment Operator in Swift

A Subtract and Assignment Operator "-=" is used to perform a subtraction between the left variable and the right variable and then assign the result to the left variable. Suppose we have two variables A = 10 and B = 20. A -= B => A = 10 - 20 => A = -10.

Following is the syntax of the subtract and assignment operator −

Swift program to subtract two variables using subtract and assignment operator "-=".

Multiply and Assignment Operator in Swift

A Multiply and Assignment Operator "*=" is used to perform a multiplication between the left operand and the right operand and then assign the result to the left operand. Suppose we have two variables A = 10 and B = 20. A *= B => A = 10 * 20 => A = 200.

Following is the syntax of the multiply and assignment operator −

Swift program to find the product of two variables using multiply and assignment operator "*=".

Divide and Assignment Operator in Swift

A Divide and Assignment Operator "/=" is used to divide the left operand by the right operand and then assign the result to the left operand. Suppose we have two variables A = 20 and B = 5. A /= B => A = 20 / 5 => A = 4.

Following is the syntax of the divide and assignment operator −

Swift program to find the divide two variables using divide and assignment operator "/=".

Modulo and Assignment Operator in Swift

A Modulo and Assignment Operator "%=" is used to calculate the modulus or remainder of two operands and assign the result to the left operand. For example, we have two variables A = 20 and B = 5. A %= B => A = 20 & 5 => A = 0.

Following is the syntax of the modulo and assignment operator −

Swift program to find the modulus of two variables using modulo and assignment operator "%=".

Bitwise AND and Assignment Operator in Swift

A Bitwise AND and Assignment Operator "%=" is used to perform AND operation between two variables or operands and assign the final result to the left variable. For example, we have two variables A = 9 and B = 10. A &= B => A = 9 & 10 => A = 8.

Following is the syntax of the bitwise AND and assignment operator −

Swift program to bitwise AND in between two variables using bitwise AND and assignment operator "&=".

Bitwise Inclusive OR and Assignment Operator in Swift

A Bitwise Inclusive OR and Assignment Operator "^=" is used to perform OR operation between two variables or operands and assign the final result to the left-hand side variable.

For example, we have two variables A = 9 and B = 10. A ^= B => A = 9 ^ 10 => A = 3.

Following is the syntax of the bitwise inclusive OR and assignment operator −

Swift program to bitwise OR in between two variables using bitwise OR and assignment operator "^=".

Bitwise Exclusive OR and Assignment Operator in Swift

A Bitwise Exclusive OR and Assignment Operator "|=" is used to perform exclusive OR operation between two variables or operands and assign the final result to the left-hand side variable.

For example, we have two variables A = 10 and B = 10. A |= B => A = 9 | 10 => A = 10.

Following is the syntax of the bitwise exclusive OR and assignment operator –

Swift program to bitwise OR in between two variables using bitwise OR and assignment operator "|=".

Left Shift and Assignment Operator in Swift

A Left Shift and Assignment Operator "<<=" is used to shift the bits of the given operand on the left side according to the given positions and assign the final result to the left-hand side variable.

Following is the syntax of the left shift and assignment operator −

Swift program to shift the bits of the given value on the left side using the left shift and assignment operator "<<=".

Right Shift and Assignment Operator in Swift

A Right Shift and Assignment Operator ">>=" is used to shift the bits of the given operand on the right side according to the given positions and assign the final result to the left-hand side variable.

Following is the syntax of the right shift and assignment operator −

Swift program to shift the bits of the given value on the right side by 4 positions using the right shift and assignment operator ">>=".

To Continue Learning Please Login

IMAGES

Compound assignment operators
Assignment operator tutorial (Swift Programming Language Reference App
How to create custom operators and do operators overloading in Swift
Swift Programming Tutorial
[Solved] Correctly overload assignment operator for
Overloading Assignment Operator

VIDEO

Swift operator of an excavator (HITACHI EX200)
Relational Operator Overloading in C++ [Hindi]
☹️ Operator overload my dump truck. #hauling #construction #dirt #dumptruck
OOP244ZAA
OverloadAssignment
OOP244NAA

COMMENTS

how to overload an assignment operator in swift
It is not possible to overload the default assignment operator (=). Only the compound assignment operators can be overloaded. Similarly, the ternary conditional operator (a ? b : c) cannot be overloaded. If that doesn't convince you, just change the operator to +=: func +=(left: inout CGFloat, right: Float) {. left += CGFloat(right) }
Advanced Operators
Swift's operator precedences and associativity rules are simpler and more predictable than those found in C and Objective-C. However, this means that they aren't exactly the same as in C-based languages. ... It isn't possible to overload the default assignment operator (=). Only the compound assignment operators can be overloaded ...
Overloading & Creating New Operators In Swift 5
This same restriction applies to the default assignment operator (=) and the compound assignment operator ( +=). Otherwise, all operators that begin with /, ... Firstly, overloading operators in Swift should be done in a way that is consistent with how the operator is normally used. A new developer should be able to reason about the expected ...
How do you overload an operator in swift?
Basically, I'm looking to overload the "+" operator so that it knows which "version" of the "+" to use depending of the type. swift; operator-overloading; operators; Share. ... how to overload an assignment operator in swift. 1. Declare overloaded += operator as mutating? 2. Swift ambiguous overloaded + operator.
How to create custom operators and do operators overloading in Swift
Not every type of operator can be overload. There are four restrictions that I know of: You can't overload and create a custom ternary operator. You can't overload the default assignment operator (=). You can overload other binary operators, including compound assignment operators such as a += 2. Only a subset of the ASCII characters are supported.
Overloading assignment operator
Overloading assignment operator. Evolution Discussion. Don_Wills (Don Wills) December 6, 2015, 1:44pm 1. The ability to overload operators is very useful. However, that utility is diminished without the ability to overload the simple assignment operator ( = ). I vaguely recall reading somewhere that there is a reason for this having to do with ...
Operator Overloading in Swift Tutorial
Enter the following in your playground to confirm Swift operators follow these same rules: var sumWithMultiplication = 1 + 3 - 3 * 2. You'll see the following result: -2. In cases where arithmetic operators have the same precedence, Swift evaluates the operators from left to right.
Basic Operators
Basic Operators. Perform operations like assignment, arithmetic, and comparison. An operator is a special symbol or phrase that you use to check, change, or combine values. For example, the addition operator ( +) adds two numbers, as in let i = 1 + 2, and the logical AND operator ( &&) combines two Boolean values, as in if enteredDoorCode ...
Operator overloading
Operator overloading. Swift supports operator overloading, which is a fancy way of saying that what an operator does depends on the values you use it with. For example, + sums integers like this: let meaningOfLife = 42 let doubleMeaning = 42 + 42. But + also joins strings, like this:
Operator Overloading in Swift
In Swift, operator overloading is achieved by defining global functions with the operator keyword followed by the operator to be overloaded. Let's look at a simple example of overloading the addition operator + for a custom Vector type: struct Vector { var x, y: Double } extension Vector { static func + (left: Vector, right: Vector) -> Vector ...
Operator Overloading in Swift with Examples
There is only one thing you should do in the loop - update the result with the string value: 1. result += lhs. Note: You could also do it like this - the initial approach is shorter because it uses the addition assignment operator: 1. result = result + lhs. Finally, return the result:
Why does Swift need operator overloading?
Updated for Xcode 15. Operator overloading allows the same operator - +, *, /, and so on - to do different things depending on what data you use it with. This allows us to use these symbols in various places where they would make sense: we can add two integers using +, we can append one string to another using +, we can join two arrays ...
Creating custom operators in Swift
Common operators in Swift. The most common operators that Swift ships with fall under the following categories: 1. Assignment operator. Assignment operators are used to assign values to a constant or variable. The symbol is =. 2. Arithmetic operators. These operators are used to perform basic arithmetic operations, such as +, -, *, /, and %. 3.
How to use operator overloading
Operator overloading is the practice of adding new operators and modifying existing ones to do different things. Operators are those little symbols like +, *, and /, and Swift uses them in a variety of ways depending on context - a string plus another string equals a combined string, for example, whereas an integer plus another integer equals a summed integer.
Operator Overloading
Another place where operator overloading in Swift is encouraged is with the Comparable protocol. To conform to the Comparable protocol you must implement an operator function for the " < " operator, as well as conform to the Equatable protocol. ... There are a few operators that you cannot overload, most notably the assignment operator ...
Why does Swift have compound assignment operators?
Swift also allows us to write score += 5 to get the same result, but why? Well, it isn't for performance reasons - under the hood, Swift turns score += 5 into score = score + 5 just as if we had written it. Instead, they are just available as a shorthand: a simpler way to write the same thing. This means less typing for us, less code to ...
Swift
Simple Assignment Operator − It is the most commonly used operator in Swift. It is used to assign value to a variable or constant. Compound Assignment Operators − They are the combination of assignment operator (=) with other operators like +, *, /, etc. The following table shows all the assignment operators supported by Swift − ...
Compound assignment operators
Swift has shorthand operators that combine one operator with an assignment, so you can change a variable in place. These look like the existing operators you know - +, -, *, and /, but they have an = on the end because they assign the result back to whatever variable you were using. For example, if someone scored 95 in an exam but needs to be ...
How can I get access or overridden the = operator in Swift?
4. You can not override the assignment operator (=), from the Swift Programming Language book. NOTE It isn't possible to overload the default assignment operator (=). Only the compound assignment operators can be overloaded. Similarly, the ternary conditional operator (a ? b : c) can't be overloaded.
Can't overload "." operator in swift
1. I think you might misunderstand the documentation. It is not possible to overload the default assignment operator (=). Only the compound assignment operators can be overloaded. Similarly, the ternary conditional operator (a ? b : c) cannot be overloaded. . is obviously not a compound assignment operator, it's a member selection operator.