Swift 2: is there a short syntax to conditionally set a non-optional variable from an optional variable?

Question

Sometimes I find myself writing swift 2 code like this:

class Test {
    var optionalInt: Int?
    var nonOptionalInt: Int = 0
    func test() {
        if let i = optionalInt {
            nonOptionalInt = i
        }
        // do more stuff
    }
}

where the problematic part is this:

if let i = optionalInt {
    nonOptionalInt = i
}

In words: if optionalInt has a value, assign it to the variable nonOptionalInt, else do nothing.

Is there an equivalent way in swift 2 to express this in a elegant single line without adding an intermediate variable with if let i?

Edit

after contemplating the first answers...

Obviously there is an equivalent way

if optionalInt != nil {
    nonOptionalInt = optionalInt!
}

Ternary operators ? : are not equivalent as they may trigger a didSet which the original code does not (good if this is a intended side effect)

The most elegant answer so far appears to be

nonOptionalInt = optionalInt ?? nonOptionalInt

it may also trigger a didSet like the ternary operator and therefore is not equivalent (also good if this is intended).

I think my wish to Apple would be something like

nonOptionalInt = optionalInt ??

or

nonOptionalInt ??= optionalInt

Unfortunately there is no swifter way which is semantically the same — Qbyte, Aug 16 '15 at 13:26

fqdn · Accepted Answer · 2015-08-16T17:15:22.840

What you are looking for is the nil coalescing operator.

You would use it like so in this case:

nonOptionalInt = optionalInt ?? nonOptionalInt

EDIT

re: your last edit to your question:

"I think my wish to Apple would be something like nonOptionalInt ??= optionalInt"

...why wish when you can build it? :)

I haven't thought about it enough to decide whether I would recommend something like this for the general case, but if it helps in your situation you can create a ??= operator that does what you ask like this:

infix operator ??= {}

func ??= <T>(inout lhs: T, rhs: T?) -> Void {
  guard let value = rhs else { return }
  lhs = value
}

then, to see it in action:

let optionalNil: String? = nil,
  optionalValue: String? = "optionalValue",
  implicitlyUnwrappedNil: String! = nil,
  implicitlyUnwrappedValue: String! = "implicitlyUnwrappedValue"
var a = "a", b = "b", c = "c", d = "d"

a ??= optionalNil               // "a"
b ??= optionalValue             // "optionalValue"
c ??= implicitlyUnwrappedNil    // "c"
d ??= implicitlyUnwrappedValue  // "implicitlyUnwrappedValue"

(note that you would add this definition at top-level scope, outside of the definition of any class, struct, or other type)

Looks a little more elegant to me than the code example in my question. It has a different semantics as it may trigger a didSet in the nil case that the original code doesn't. — Gerd Castan, Aug 16 '15 at 07:25

JGS · Answer 2 · 2019-06-30T13:52:49.290

6

Swift 4.0 Version build from the 2.0er answer

/// Optional Assignment, assigns if value exists
infix operator ?=: AssignmentPrecedence

func ?=<T>(lhs: inout T, rhs: T?)  {

    guard let value = rhs else { return }
    lhs = value
}

// Playground Test

var dummy = "old"
var opt :String?

dummy ?= opt // leaves old

opt = "new"
dummy ?= opt // value becomes new

edited Jun 30 '19 at 13:52

answered Sep 16 '17 at 13:16

JGS

99
1
5

Caleb · Answer 3 · 2015-08-16T00:34:39.947

Is there an equivalent way in swift 2 to express this in a elegant single line without adding an intermediate variable with if let i?

You can omit the intermediate value if you want to:

if optionalInt != nil {
    nonOptionalInt = optionalInt!
}

And you can obviously put that all on a single line if you want:

if optionalInt != nil { nonOptionalInt = optionalInt! }

But you can also use the ternary operator if you prefer:

nonOptionalInt = (optionalInt != nil) ? optionalInt! : 0

where the 0 is just a default value to use in the case where optionalInt == nil. If you don't want to change nonOptionalInt if optionalInt == nil then just use nonOptionalInt:

nonOptionalInt = (optionalInt != nil) ? optionalInt! : nonOptionalInt

Note that the ! in optionalInt! implicitly unwraps the optional value -- it's the way you tell the compiler that you know that optionalInt isn't nil so it's okay to assign to a non-optional variable.

Thanks for your effort. Yes, obviously one can write if statements in one line. Doesn't make it less complex. Using a ternary operator has a different semantics as it triggers a didSet which the original code does not. — Gerd Castan, Aug 16 '15 at 07:23

Swift 2: is there a short syntax to conditionally set a non-optional variable from an optional variable?

3 Answers3