Swift ✉️ Memos

What are
Non-Copyable types?

Hi 👋

Non-Copyable structs and enums have been recently added to Swift.

They can be a bit complex to grasp, so let me walk you through it!

But first, I have a big thank you to a developer tool who's the sponsor of this email: Stream

Advertisement

Sponsors like Stream really help me grow my content creation, so if you have time please make sure to have a look at what they offer: it's a direct support to my content creation 🙂

Non-Copyable structs and enums is a very powerful feature, that lets you impose strong restrictions on how a value type is allowed to be handled.

But first, let's talk about how we've always handled value types in Swift.

From the moment that a value type has been stored in a variable or a constant, nothing prevents us from making copies of that value into other variables or constants:

Most of the time, this behaviour is exactly what we want.

But there could be situations where we'd like to impose that a value can never be copied.

For instance, this would make perfect sense if a value was meant to be used a single time only.

And this is when non-copyable types come into play!

This is the syntax to make a struct non-copyable:

It might look a bit weird, but what this syntax says is that it removes the implicit conformance to the protocol Copyable.

And as you can see, as soon as we've made our type non-copyable, it's no longer possible to make a copy of it and keep using both the copy and the original:

We're still allowed to assign the value to a different variable, but when we do so, it consumes the original variable, making it unusable past that point.

And what's really nice is that this behaviour can also be applied to the parameter of a function.

Let's say that we want a function that takes a Token as its argument, and we also want that once a Token has been passed to the function, it can no longer be used after that.

To implement this, we just need to mark the argument of the function with the new keyword consuming:

Now, once we've called the function and passed the value as its parameter, it becomes impossible to reuse that value later in the code:

And so we've effectively implemented a system where each Token can only be used once and the compiler will enforce this rule for us ✌️

That's all for this introduction to non-copyable types!

I hope that this feature now feels clearer and that the syntax ~Copyable feels less scary.

If you've ever used non-copyable types in your project, please let me know by answering this email: I'd be super curious to learn more about your use case!

That's all for this email, thanks for reading it!

If you've enjoyed it, feel free to forward it
to your friends and colleagues 🙌

I wish you an amazing week!

❤️

What are Non-Copyable types?

What are Non-Copyable types?

What are
Non-Copyable types?