Is there a good way to use `try catch` in init blocks to ini kotlinlang #announcements

01/03/2019, 7:03 AM

Is there a good way to use

try/catch

in init blocks to initialize immutable (i.e.

val

) class properties? Right now I use

class Foo(val a: Int) {
val b: Int
init {
  var bb: Int
  try {
    bb = complicated(a)
  catch (e: Excepetion) {
    bb = fallback()
  }
  b = bb!!
}

01/03/2019, 7:16 AM

class Foo(val a: Int) {
  val b: Int
  init {
    b = try {
      complicated(a)
    } catch (e: Exception) {
    fallback()
  }
}

class Foo(val a: Int) {
  val b: Int = try {
    complicated(a)
  } catch (e: Exception) {
    fallback()
  }
}

and if you don't need a outside of initialization, you can

class Foo(a: Int)

01/03/2019, 7:01 PM

great. Any idea what to do if I have 2 values to compute from within the same

try

val (b, c) = try {...}

but that produces a syntax error.

val p = try {...}; val b = p.first; val c = p.second

works but looks ugly

01/03/2019, 7:05 PM

I mean, there’s a couple things you could do here

if you wrote the type that

is, you can define

.component1()

.component2()

such that they return first and second, respectively

then you can use the destructuring syntax

if you don’t, you could return a

Pair

from the try/catch though it’s not the most intuitive

val (a, b) = try {
    mightThrow()
  } catch (_: Exception) {
    default()
  }
}

fun mightThrow() = 1 to 2
fun default() = 3 to 4

01/03/2019, 7:51 PM

I tried that (my

try

did return a

Pair

) but Intellj showed a syntax error for this when I used this approach for class properties. It did work for local values in functions

01/03/2019, 7:52 PM

ahh, I see, yes, I don’t think you’re allowed to destructure into properties

01/03/2019, 8:03 PM

I ended up with

class foo() {
    private fun mightThrow() = 1 to 2
    private fun default() = 3 to 4

    val a: Int
    val b: Int

    init {
        val p = try {
            mightThrow()
        } catch (_: Exception) {
            default()
        }
        a = p.first
        b = p.second
    }
}