swift overloading assignment operator

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 !

Further Reading

Want to take a deeper dive into operator overloading?

Check out these great resources:

• https://www.codingexplorer.com/custom-operators-swift/
• https://sarunw.com/posts/how-to-create-custom-operators-and-operators-overloading-in-swift/
• https://jayeshkawli.ghost.io/custom-operators-in-swift/

Subscribe to Digital Bunker

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

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.

Offline Transcription: Fast, privacy-focus way to transcribe audio, video, and podcast files. No data leaves your Mac.

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.

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. ↩︎

You may also like

• Swift Ternary operator (?:) 09 Feb 2023
• What does the ?? operator mean in Swift 30 Sep 2021
• Where is my getter/setter in Swift? 05 Jun 2014
• Sign in with Apple Tutorial, Part 4: Web and Other Platforms 22 Jan 2020
• 3 lesser-known ways of using Swift enums 14 Sep 2020
• How to convert Radians to Degrees in Swift 14 Aug 2023

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

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.

You’ve made it this far. Let’s build your first application

DhiWise is free to get started with.

Design to code

• Figma plugin
• Documentation
• DhiWise University
• DhiWise vs Anima
• DhiWise vs Appsmith
• DhiWise vs FlutterFlow
• DhiWise vs Monday Hero
• DhiWise vs Retool
• DhiWise vs Supernova
• DhiWise vs Amplication
• DhiWise vs Bubble
• DhiWise vs Figma Dev Mode
• Terms of Service
• Privacy Policy

Insights into Swift Operator Overloading: Enhancing Code Expression

Nidhi Sorathiya

Frequently asked questions, is there operator overloading in swift, what is overloading and overriding in swift, how to overload the default assignment operator (=) in swift, what does the === operator do in swift, what is a custom operator in swift.

Swift operator overloading allows developers to redefine how operators behave with various data types, offering flexibility and expressiveness in code.

We’ll delve into the mechanics of operator overloading, covering existing operators and the creation of custom ones. This power feature enables writing clean, intuitive code that can be tailored to specific programming needs, making Swift a dynamic tool for developers. Join us to unlock the potential of operators in Swift and enhance your coding skills.

Fundamentals of Swift Operator Overloading

In Swift, operator overloading is the process where you provide a custom implementation of an existing operator, such as the addition operator (+), or present an entirely new operator, to work with the types you define. This process not only increases the readability and conciseness of your code but also enables the performance of complex operations in a simplified manner.

Operator overloading in Swift uses specific keywords and syntax to redefine the operator's functionality. When you overload an operator, you tell the compiler how to use that operator with your custom types. The overloading operators must be marked with the static keyword and can be defined within class, struct, or enum types to perform operations that involve their instances.

Swift provides a comprehensive set of operators, which are categorized as unary, binary, and ternary:

• Unary operators operate on a single target. These include unary prefix operators, such as the logical NOT operator (!), and unary postfix operators, like the increment operator (++) that Swift deprecated in favor of the += 1 operation.

• Binary operators work with two values and include common operators like the addition and subtraction operators (+ and ``).

• The ternary conditional operator is a unique operator in Swift that works with three targets. The ternary conditional operator (?:) is the only ternary operator in Swift.

Key benefits of using operator overloading include:

• Improving code readability by allowing complex operations to be expressed succinctly

• Adding custom behavior to existing operators, tailoring them to work with your custom types

• Facilitating the implementation of domain-specific languages within your applications

While redefining operators might seem straightforward, developers should employ operator overloading judiciously. Overuse or inappropriate application of operator overloading can lead to code that's hard to understand and maintain. Therefore, it is essential to adhere to logical and conventional meanings of operators while engaging in operator overloading to maintain code clarity.

Exploring Operators in Swift

Before delving into the intricacies of Swift operator overloading, it's crucial to recognize the fundamental role of operators in the Swift programming language. Operators are special symbols or phrases that you use to check, change, or combine values. Swift supports most standard arithmetic operators and improves upon them with enhanced functionality such as overflow operators and compound assignment operators.

The arithmetic operators (addition +, subtraction -, multiplication *, and division /) are familiar to most programmers and are often the first that come to mind. Additionally, Swift includes a range of comparison operators such as ==, !=, >, <, >=, and <= that compare two values and return a Bool. Beyond these common operators, Swift provides operators that aren't as universally known or used, such as the nil coalescing operator (??) and range operators (..< and ...).

Understanding how these operators function is the prerequisite for comprehending operator overloading. The operators in Swift are generally categorized into:

Unary operators (a): An operator that prefixes (!b) or postfixes (i++) a single operand.

Binary operators (a + b): An operator that is placed between two operands and inflicts some form of computation or logical operation.

Ternary operators (a ? b : c): An operator that works with three parts, the most famous example being the ternary conditional operator which evaluates a condition to return one of two values.

Swift emphasizes safety and performance, and the design of its operator system follows the same philosophy. A well-defined precedence and associativity for each operator ensures that complex expressions can be evaluated predictably without the need for excessive parentheses.

The Syntax for Swift Operator Overloading

Swift operator overloading requires developers to become familiar with a syntax specifically designed for this feature. Overloading an operator involves creating a function with a special name, that name being the operator we wish to overload, and implementing our custom behavior within it. These functions need to be marked as static and placed within the appropriate scope—whether that's a class, struct, or enum definition—since they pertain to the type itself rather than its instances.

Overloading Existing Operators

To overload an existing operator, you declare and implement a static method with the name of the operator as the function's name. It’s defined using the operator keyword, followed by the operator itself within a pair of parentheses. For example, overloading the addition operator for a custom Vector type would look like this:

Creating Swift Custom Operators

When defining custom operators, first declare the operator using the prefix, infix, or postfix keywords to specify the type of operator you're creating. Next, you need to define its functionality similarly to how you overload an existing operator, but with the new operator's symbol. Custom operators can include characters like /, =, -, +, !, *, %, <, >, &, |, ^, ?, and ~.

Here's an example of declaring and implementing a custom infix operator ** for exponentiation:

In the example, we also define a precedence group, another important aspect of infix operators. This defines how your custom infix operator interacts with others regarding operator precedence and associativity rules.

Overall, when overloading operators, you must collaborate with Swift's type system to ensure that the compiler interprets your overloads correctly. It’s necessary to specify the types of the operands and the return type accurately to avoid any ambiguity. Whether you're overloading operators for existing types or your custom types, Swift’s structure for operator overloading demands precision and foresight, ensuring your custom operators function seamlessly in various contexts.

Dive into Custom Operators

Swift goes a step beyond enabling the overloading of existing operators by allowing developers to define custom operators. This means you can create an operator symbolically represented in a way that makes sense for your code’s context. These custom operators can then be overloaded with specific functionality related to your data types.

What Are Swift Custom Operators?

Custom operators are new symbols that you introduce as operators in your code. These can serve to make expressions more readable and concise, particularly when you’re performing operations that are unique to your program's domain. Swift custom operators can be defined with the prefix, infix, or postfix notation, depending on how they are used relative to their operands.

Declaring and Implementing Custom Operators in Swift

To declare a custom operator, you use the operator keyword followed by the operator symbol and a prefix, infix, or postfix modifier, depending on how the operator should be used. Once declared, you must also define the operator's functionality by implementing a function with the same symbol, appropriately marked with the static keyword as it relates to the type itself.

In the code snippet above, we’ve created a new prefix operator +++ that increments an integer by 2.

Practical Examples of Custom Operators Usage

Using custom operators can significantly cut down boilerplate code and provide a level of abstraction similar to that of functions or methods. Suppose you’re working on a graphics-related application where manipulating pixel data is common. A custom operator for combining color values could streamline the process:

This mixture operator <+> succinctly expresses the idea of combining two colors, something that might otherwise require a more verbose function or method call.

Custom operators are a powerful feature in Swift, allowing us to write code that's more aligned with the domain we're working in. However, they should be used judiciously to ensure that code remains approachable and intuitive for other developers.

In our next sections, we will dive deeper into the overloading of specific types of operators and discuss their importance and implications by exploring prefix, infix, and ternary conditional operator overloading in Swift.

Defining Prefix and Postfix Operators

Swift’s prefix and postfix operators function with only a single operand and are known for their clarity and efficiency when implemented correctly. The prefix operator appears before its operand, while the postfix operator follows it. Consider the unary minus (-) as a prefix or the increment (++) as a postfix in other programming languages.

Understanding Prefix Operator Overloading

Let's look at an example of how to overload a prefix operator in Swift. A common scenario might involve negating some property of a custom type:

In this instance, we define and implement the unary minus operator for a custom Currency type to convey the concept of debt.

Case Study: Implementing a Prefix Operator

To further illustrate, consider a graphics application where you might want to invert colors. A prefix operator could be an ideal way to express this action:

Here, the ~~ operator has been created to cleanly signify the inversion of a color.

Implementing Infix Operators

Infix operators are those that are written between their two operands, such as the multiplication (*) and division (/) operators. New infix operators must provide precedence and associativity to dictate how they interact with other infix operators.

The Role of Infix Operator Overloading in Swift

The true power of Swift comes into play when you combine custom types with infix operator overloading. This can create notations that are highly expressive and domain-specific, which improves both code readability and functionality.

For instance, let's say you have a custom-type Fraction that represents a mathematical fraction:

The custom infix operator %% can be used to add two Fraction instances together with appropriate logic inside the implementation.

Rules for Infix Operator's Precedence and Associativity

When creating new infix operators, you must specify their precedence and associativity:

Here, the *** operator is given the same precedence as standard multiplication, ensuring expressions involving both are evaluated in the expected order.

Precedence and Associativity in Infix Operators

To manage the complexity of expressions with multiple operators, Swift uses precedence and associativity rules. When creating custom infix operators, it's essential to define where they stand in the operator hierarchy to ensure the correct order of operations.

Establishing Precedence for Infix Operators

Precedence in Swift dictates the order in which operations are performed in a compound expression. Every infix operator belongs to a precedence group, which determines this order. When you create a custom infix operator, you should assign it to a precedence group to define how it interacts with other infix operators.

Here's an example of establishing a custom infix operator for vector cross-product with its precedence:

In the example above, the new operator >< for cross-product takes its place in the precedence hierarchy, ensuring it evaluates correctly in mixed expressions.

Understanding Precedence and Associativity Rules

Operator precedence dictates which operator is applied first in an expression, while associativity decides the grouping of operators with the same precedence.

For example:

In expressions with operators of the same precedence group, associativity becomes important:

Overloading the Ternary Conditional Operator

Swift only includes one ternary operator: the ternary conditional operator ? :, which is used to choose between two expressions based on a given condition. Because of its unique nature and established behavior, the ternary conditional operator is not overloadable in Swift. This restriction is intentional to preserve the readability and predictability of ternary conditionals—constructs that developers rely upon to be consistent in their function.

Can You Overload the Ternary Conditional Operator?

Currently, overloading the ternary conditional operator is not supported in Swift. Attempting to do so would complicate the language's grammar and introduce ambiguity, making code harder to understand and maintain.

Why Overloading the Ternary Conditional Operator is Rare

Unlike infix, prefix, and postfix operators, the ternary conditional operator has a fixed and well-understood behavior, tightly integrated within the language's syntax. Swift's decision to make it non-overloadable preserves the clear and concise semantics that ternary conditionals are known for.

Operator overloading enhances Swift's customizability and expressive power, but with great power comes great responsibility. It's crucial to use custom operators sparingly and thoughtfully to keep code understandable and prevent confusion. With a robust understanding of precedence, associativity, and restraint, developers can use Swift operator overloading to create powerful and expressive syntax tailored specifically to their domains.

Advanced Swift Operator Overloading Techniques

Overloading operators for custom types can give you powerful ways to express the operations that those types can undergo. As you work with complex data structures or mathematical concepts, you will discover that the ability to provide natural expressions for operations can make your code not only more elegant but also more closely aligned with the domain you're working with.

Overloading Operators for Custom Types

Swift operator overload provides an opportunity to define the behavior of standard operators for your custom types or to create entirely new operators. When adding operator overloading to custom types, consider the types of operations that are integral to the type's function.

Let's take an example where we develop a Matrix type in a linear algebra library:

By overloading the multiplication (*) operator, we can provide a matrix multiplication operation directly on Matrix instances, making the library more intuitive.

Ensuring Type Safety with Operator Overloading

Swift’s type system plays a crucial role in operator overloading as it helps maintain type safety. It’s important to ensure that the types your operators work with are handled correctly:

In the code above, we use Swift's guard statement to ensure that we only add matrices of the same dimensions, preserving type safety and reducing potential run-time errors.

Operator overloading in Swift also includes the ability to specify the result type of an overloaded operator, allowing for more complex transformations, as long as they adhere to the rules of the language's type system.

Best Practices for Swift Operator Overloading

Using operator overloading in Swift can make your code more intuitive and concise. However, with such power comes the responsibility to use it wisely. Adhering to best practices ensures that the code is not only performant and reliable but also maintainable and easy to understand.

When to Overload Operators: Practical Guidelines

Overload operators when it can simplify code without sacrificing clarity. Avoid overloading operators in a way that could confuse someone reading your code—operators should do what is expected of them. For example, it makes sense for the + operator to represent addition or concatenation but using it for subtraction would defy convention and lead to confusion.

Adhere to the following guidelines:

• Overload operators when you have a clear and natural meaning for them.

• Consider the mathematical properties of operators (such as commutativity and distributivity) to retain consistency of operations.

• Document your overloaded operators well, explaining how and why they're used.

Pitfalls to Avoid with Swift Operator Overloading

Avoid these common pitfalls when working with Swift operator overloading:

• Overcomplicating expressions by using too many custom operators.

• Violating the principle of least astonishment—don't give operators unexpected behaviors.

• Overloading too many operators for a single type leads to complex and unintelligible code.

Striking the right balance requires a thoughtful approach to design and a thorough understanding of how operator overloading affects code readability and maintainability.

Swift operator overloading is a powerful feature that, when used correctly, can make your code more expressive and tailor it to the problem at hand. We've explored the syntax and semantics of overloading existing operators and creating new custom operators, as well as practices to keep in mind to maintain clean and understandable code.

Incorporate these techniques rudely in your Swift projects and witness the transformation in how you conceptualize and implement logic around data types and operations. Happy coding!

Short on time? Speed things up with DhiWise!!

Tired of manually designing screens, coding on weekends, and technical debt? Let DhiWise handle it for you!

You can build an e-commerce store, healthcare app, portfolio, blogging website, social media or admin panel right away. Use our library of 40+ pre-built free templates to create your first application using DhiWise.

Operator Overloading in Swift

Apple developer.

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!

mutating Structs and @Observable Class - Swift

In Swift, you can use both mutating methods in structs and ObservableObject classes to manage state, but they serve different purposes and are used in different contexts. Structs with mutating methods provide a powerful way to work with value types while still allowing for controlled mutability. They are ideal for

AppStorage vs UserDefaults - Storing Data in Swift

Both AppStorage and UserDefaults are used in Swift to store user preferences or small amounts of data, but they serve different purposes and are used in slightly different contexts. 1. AppStorage * Introduced in: SwiftUI * Purpose: AppStorage is a property wrapper that integrates with UserDefaults but is designed to work seamlessly

How does "body: some View" work in SwiftUI?

In SwiftUI, the body: some View syntax is a key part of defining custom views. This syntax leverages the concept of opaque return types introduced in Swift 5.1, which allows the function to specify that it returns some type that conforms to the View protocol, without specifying the exact

Guard with Optionals in Swift

In Swift, guard statements are commonly used with optionals to handle early exits from a function or block of code if certain conditions are not met. The guard statement provides a clean and readable way to unwrap optionals and handle potential failure cases without deeply nesting your code. Using guard

This page requires JavaScript.

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

• 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

Operator Overloading in Swift

Operator overloading is a powerful technique in Swift programming. Operator overloading allows us to change the working of the existing operators like +, -, /, *, %, etc. with the customized code.

It makes code more expressive and readable. To overload an operator, we have to define the behaviour of that operator using the " static func " keyword.

Following is the syntax for operator overloading −

Swift program to overload + operator to calculate the sum of two complex numbers.

Swift program to overload custom prefix operator.

Limitation of Operator Overloading in Swift

The following are the limitations of operator overloading −

• In Swift, you can overload limited operators like arithmetic and customized operators.
• While overloading operators, you are not allowed to change the precedence or associativity of the operators.
• Swift does not support short-circuiting behaviour for overloading logical operators.
• Do not overuse operator overloading because it makes your code difficult to read and understand.

Difference Between Operator Function and Normal Functions

The following are the major differences between the operator functions and normal functions −

TEAM LICENSES: Save money and learn new skills through a Hacking with Swift+ team license >>

Why does Swift need operator overloading?

Paul Hudson    @twostraws    May 28th 2020

Updated for Xcode 16

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 using +, and so on.

Of course, this doesn’t mean we can use all the operators in every place: we can subtract one integer from another, but what would it mean to subtract one string from another? Would it subtract from the start or the end? Would it subtract all instances of the string or just one?

When your skills grow you’ll find you can create your own custom operators if you want to, and even modify Swift’s existing operators.

SPONSORED Have you ever missed a pull request update? Meet PR Focus: a native macOS dashboard that quietly keeps you up-to-date on PRs that matter. Watch PRs across GitHub repositories and never miss an important update again.

Sponsor Hacking with Swift and reach the world's largest Swift community!

Was this page useful? Let us know!

Average rating: 5.0/5

You are not logged in

Link copied to your pasteboard.

Coding Explorer Blog

Exploring how to code for iOS in Swift and Objective-C

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

C++ Const Overloading

Introduction

In C++ programming, when we implement the methods for classes, we usually add const specifier to make sure that the members of the class instance will not be modified by the method. However, it is also valid that we do const overloading for the same method, i.e., a class has methods that have the exact same method name and arguments, and one of them has a const specifier.

In this blog post, I would like to talk about the const overloading for C++ class methods.

In this example, I implemented a simple Vector class mimicking the std::vector class. We could see that operator[] overloading methods have two versions, T& operator[](int n) and const T& operator[](int n) const . The data methods also have two versions, T* data() and const T* data() const . The (second) const specifier ensures that calling the method will not modify the instance members. Because the each of the member method has an implicit input pointer this , the const specifier can also be understood as making the input pointer this from a pointer into a pointer to const object. For example, the input pointer Vector* this will become Vector const* this if the member method has const specifier.

Given a class which has const overloading for certain method func() , if the instance of the class is const , calling the method func() will invoke func() const , and if the instance of the class is not const , calling the method func() will invoke the func() without the const specifier.

To compile the program, please run the following command in the terminal.

The expected output of the program would be as follows.

What if the class does not have const overloading? There would be problems. For example, let’s remove the const overloadings ( const T& operator[](int n) const and const T* data() const ) from the Vector class. The compiler threw errors against us complaining that “‘const Vector ’ as ‘this’ argument discards qualifiers”.

This basically means that for a const class instance, it will look for methods with const specifiers when the methods are called. However, there is only one method without the const specifier declared and implemented, passing this const instance to the method without const specifier caused the problem.

If a class only has const methods, this is fine. A non-const class instance could call const methods.

A const class method could return non-const values. For example, the following data() method returns const T* typed pointer. This means the returned pointer is const and we cannot modify the variable via dereferencing the pointer.

However, if the data() method returns T* typed pointer, i.e., the implementation is

We could modify the variable via dereferencing the pointer! Although this is syntactically correct, sometimes the behavior is not what we really want. Given a const class instance, why would we ever want the instance to give us something that could modify its own content?

Conclusions

For some custom classes that we know we would create const instances or pass the instance by const values or references, const overloading is necessary.

https://leimao.github.io/blog/CPP-Const-Overloading/

Licensed under

Like this article support the author with, advertisement.

• 1 Introduction
• 4 Conclusions

Secured Web Fingerprint Transmission

As an FBI-approved Channeler, National Credit Reporting (NCR) can assist cleared companies in scanning fingerprint cards into the required digitized format that will allow for uploading files to the Secured Web Fingerprint Transmission (SWFT) website.

Companies that have been provided security clearance by the United States Government for access to classified information are considered "cleared companies." Security clearances can be issued by different government agencies, including the Department of Defense (DOD), Department of Homeland Security (DHS), Department of Energy (DOE), Department of Justice (DOJ), and Central Intelligence Agency (CIA).

Those companies that are referred to as "cleared companies" are listed in the Industrial Security Facilities Database. The companies submit electronic fingerprint files to the Defense Manpower Data Center (DMDC) for National Industrial Security Program (NISP) applicants. For applicants requiring a background investigation for a personnel security clearance, the DMDC provides the SWFT website, enabling industry users to submit electronic fingerprints and demographic information.

Cleared companies will be able to outsource to National Credit Reporting the performance of collecting fingerprint cards and converting it into an electronic fingerprint file format, which meets the Office of Personnel Management (OPM) and Federal Bureau of Investigations (FBI) standards.

DSS SWFT Processing Instructions

Step 1 – Account Set Up

To establish services or ask questions, please contact: Cynthia Clark 1 800 441-1661 x109 [email protected]

Step 2 – Request Electronic File

Log into our secure website to enter the applicant's demographic and PII informaiton, and then print a Fingerprint Custody Control Form.

Step 3 – Obtaining Ink rolled or Digital Fingerprints

Obtain two (2) sets of fingerprints via ink rolled or digital print out at a fingerprinting location .

Step 4 – Mail Documents

• Coversheet request form with barcode
• Custody Control Form
• Two completed ink or digital FD258 fingerprint cards

Mail documents to: National Credit Reporting Attn: DSS/SWFT Request 6830 Via Del Oro, Suite 105 San Jose, CA 95119

Step 5 – Processing and Retrieving EFT file

Upon receipt, fingerprints will be converted to an FBI- OPM/DSS SWFT compliant EFT file. An electronic notification e-mail is sent to notify the EFT file is ready to securely download. The FSO logs into secure.nbinformation.com to download the EFT file.

Step 6 – Upload EFT to SWFT or Multi uploader

• INDUSTRY OVERVIEW
• FEDERALLY ASSISTED HOUSING
• TRIBAL ORGANIZATIONS
• ATTORNEY REQUESTS

CUSTOMER SERVICE 800.441.1661 [email protected]

Reasons to check my FBI Criminal Report

• Work or Student Visa
• Foreign Travel or Work
• Personal Review
• Adoption Requirements
• Attorney Requests
• Challenge Errors
• Court Related Matters

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Can't overload "." operator in swift

Even though the swift documentation says that we can overload the . symbol I can't seem to do so without the compiler complaining.

Here is what I'm doing:

Has anyone successfully done this in swift?

• 2 i read that differently you can build your own operator using the following set of symbols / = - + * % < > ! & | ^ . ~ thus you could define <-> or ..... –  Christian Dietrich Commented Jun 18, 2014 at 22:25

2 Answers 2

You can use the . character in a custom operator , but you can't create an operator that's the . character alone — it looks like that token is a more basic part of the grammar. (Actually, it looks like there are more restrictions on . than you see in the grammar part of the language guide , because you can create the extended-silence operator ...... , but not the happy operator ^.^ .)

(Think about it this way: if you tried to use . to define the dot product of two vectors, you'd have a hard time using it to address members of those vectors.)

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.

However, you can

declare and implement your own custom operators in addition to the standard operators provided by Swift. Custom operators can be defined only with the characters / = - + * % < > ! & | ^ . ~.

• mathematical operators (+, -, etc), prefix operators, postfix operators, etc are all not compound assignment operators. you are looking at the wrong part of the documentation. see the last section of the documentation you linked –  pseudonym117 Commented Oct 10, 2014 at 15:27
• @pseudonym117 The question was asking if . can be overloaded which is not allowed but it can be used as a part of custom operators. That's what my answer was trying to say. –  Aaron He Commented Oct 10, 2014 at 21:10

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged swift or ask your own question .

• The Overflow Blog
• Where does Postgres fit in a world of GenAI and vector databases?
• Mobile Observability: monitoring performance through cracked screens, old...
• Featured on Meta
• Announcing a change to the data-dump process
• Bringing clarity to status tag usage on meta sites
• What does a new user need in a homepage experience on Stack Overflow?
• Staging Ground Reviewer Motivation
• Feedback requested: How do you use tag hover descriptions for curating and do...

Hot Network Questions

• How is it possible to know a proposed perpetual motion machine won't work without even looking at it?
• Image Intelligence concerning alien structures on the moon
• Writing an i with a line over it instead of an i with a dot and a line over it
• Which hash algorithms support binary input of arbitrary bit length?
• Disable other-half popup when view splitting
• How can I automatically save my renders with incremental filenames in Blender?
• Is 3 Ohm resistance value of a PCB fuse reasonable?
• What does "seeing from one end of the world to the other" mean?
• High voltage, low current connectors
• Why did the Fallschirmjäger have such terrible parachutes?
• Parody of Fables About Authenticity
• Suitable Category in which Orbit-Stabilizer Theorem Arises Naturally as Canonical Decomposition
• How to disable Google Lens in search when using Google Chrome?
• Has a tire ever exploded inside the Wheel Well?
• Why does flow separation cause an increase in pressure drag?
• How do eradicated diseases make a comeback?
• What is the highest apogee of a satellite in Earth orbit?
• Is this screw inside a 2-prong receptacle a possible ground?
• TikZ -- Best strategy to choose points for the Hobby algorithm
• Reusing own code at work without losing licence
• Is there a nonlinear resistor with a zero or infinite differential resistance?
• How do we reconcile the story of the woman caught in adultery in John 8 and the man stoned for picking up sticks on Sabbath in Numbers 15?
• Historical U.S. political party "realignments"?
• Whence “uniform distribution”?