Question: I'm using a method that gets JSON data from an API, in Java whenever I use `getJSONObject` I have to surround the method with a try/catch, since it detects that the method throws a `JSONException`, I want to be able to force the programmer to surround my function in Kotlin when it's used. 
The method on which I want to do this is the following:

```
@Throws(JSONException::class)
    fun parseHitEvents(jsonObject: JSONObject): MutableList<AlgoliaEvent> {
        val hits = jsonObject.optJSONArray("hits")

        val results = ArrayList<AlgoliaEvent>(hits.length()) // Initialize the array list to be of size hits.length

        hits?.forEach<JSONObject> { hit ->
            // Check that each hit is not null
            if (hit == null) return@forEach

            // Parse each hit with a correspond ConciseEvent object
            val event = jsonToObject<ConciseEvent>(hit).apply {
                // We need to get the values from AbstractQuery.LatLng and add them into each event object
                with(hit.getJSONObject("_geoloc")) {
                    _geoloc.lat = getDouble("lat")
                    _geoloc.lng = getDouble("lng")
                }

            // Add the main event in the list of events, so that we can send them as the return value
            results.add(AlgoliaEvent(HitEvent(event)))
        }

        return results
    }

```

However, when this method is being called in another file, I'm not being forced to surround the method in a try/catch.

Is there a way to do that, or is there a way to implement this kind of logic in a better way?

Answer: 
Kotlin does not have checked exceptions. `@Throws` only forces Java code to check for exceptions and has no effect on Kotlin code.

One alternative is using a sealed class that enables returning either the desired result or an error.

```
sealed class HitEventsResult {
    data class Success(val value: List<AlgoliaEvent>): HitEventsResult()
    data class Failure(val exception: JSONException): HitEventsResult()
}

```

```
fun parseHitEvents(jsonObject: JSONObject): HitEventsResult  {
    try {
        // your original code for getting the results...
        return HitEventsResult.Success(results)
    } catch (e: JSONException){
        return HitEventsResult.Failure(e)
    }
}

```

Then at the call site:

```
val hitEventsResult = parseHitEvents(jsonObject)
when (hitEventsResult){
    is Success -> TODO() // do something with result.value
    is Failure -> TODO()
}

```

or if you want to rethrow:

```
val hitEventsResult = parseHitEvents(jsonObject)
val hitEvents = when (hitEventsResult) {
    is Success -> result.value
    is Failure -> throw result.exception
}

```
In Kotlin, there's no checked exceptions ([Source](https://kotlinlang.org/docs/reference/exceptions.html#checked-exceptions)).

No exceptions have to be declared and you aren't forced to catch any exception.

To indicate that an exception can be or has to be catched, you can use the [@Throw tag](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.jvm/-throws/index.html) in the documentation