Hacker News Reader

Comment by melling | Hacker News Reader

This is practical. It's something you wish for within a couple hours of Swift.

let x : SomeThing

if condition {

   x = foo()

} else {

   x = bar()

}

use(x)

View on HN

so, in c++ you can do initialization of const value via lambda closures that are immediately evaluated:

    const int a = [=](){ 
        //do stuff here that returns an int:
        if (condition) { return foo(); } else { return bar(); }
    }();

Does this idiom work in swift?

    let x: String = {
       if 3 == 4 {
          return "Hello"
       } else {
          return "Goodbye"
       }
    }()

Although in this case, I'd just use ternary.

    let x = (3 == 4) ? "Hello" : "Goodbye"

short of having a language mechanism for doing an 'uninitialized' let, conditional operators could work:

let x : Something = condition ? foo() : bar()

but yeah, it would be nice to defer initialization of an immutable.

Let's hope you don't have a baz.

you can torture the logic further:

let x : Something = outer_conditional ? baz() : conditional ? foo() : bar()

I think this can look pretty nice, properly formatted:

    let x = conditional1 ? bar() :
            conditional2 ? baz() :
            conditional3 ? quux() :
            someDefault

often times you want to do more stuff in either case so ? does not always work. The if-else approach is more general.

You could also do this:

    let x: Something = {
      if condition {
        someSideEffect()
        return foo()
      } else {
        anotherSideEffect()
        return bar()
      }
    }()

But it's kind of ugly.

Sad that Swift doesn't use an expressive if, then you could just write:

    let x: Something = if condition {
        // do stuff
        foo()
    } else {
        // do other stuff
        bar()
    }

That's something I really miss in other languages—the ternary operator is just not good enough for when you have a condition like this. In lisp it's 3 lines which is just the right amount when in other languages you have 6 lines (and until now unnecessary mutability) or only one.

Note that it's no longer "would," this is a feature included in this beta. OP's code is now legal.

I wish the es6 const would allow this.

Reply on news.ycombinator.com