A modern programming language that makes developers happier.

kotlinlang

I have a `List&lt;String&gt;` and a function `f: String -&gt; T?`  and would like to apply `f` to each element `s`  of the list in order until `f(s)` is non-null, returning that `f(s)`. If `f(s)` is null for all values, `null` should be returned. Here’s an ugly implementation:
```fun g(list: List&lt;String&gt;): String? =
    if (list.isEmpty()) {
        null
    } else {
        f(list.first()) ?: g(list.subList(1, list.size))
    }```
Can someone suggest a more elegant way?

Here’s the code, if you’d like to play with it. <https://pl.kotl.in/mByy6tkph>

Yours is functional.

This is what I would do 
```
list.firstOrNull{ f(it) != null }
```

Codefoematter doesnt seem to work on phone

Actually <@URN6NJNBS>, that isn’t working for me. `firstOrNull` expects a predicate. My function `f` is not a predicate.

This works but repeats a calculation:
```list.firstOrNull { f(it) != null }?.let { f(it) }```

why not just `list.firstOrNull  { f(it) != null }` ?

Thanks <@U014LBU1WP2> but I need the return value from `f`.

ah, I understand now.

honestly I think a for-loop might be the most readable option :smile:

I was afraid of that. As you may have been able to tell from my original code, I think like a Scheme programmer.

```for (s : list){
  val result = f(s)
  if (result == null) continue
  return result
}```

I did SML way back in school, your code is familiar :wink:

Thanks! Would this work?
```for( s : list){
  val result = f(s)
  if (result != null) {
    return result
  }
}```

yeah totally; my last job was big on “early return” to avoid nesting logic, but your above code is synonymous

```for (s in list) return f(s) ?: continue
```
(Haven't tested it, and arguably far from readable)

I had to add a `return null` after the for loop.

```list.asSequence().map(f).firstOrNull { it != null }```
I think this dtrt too. tmtowtdi :slightly_smiling_face:

```list.mapNotNull(::f).firstOrNull()```
(sorry I went to bed)

<@URN6NJNBS> has a nice solution. This is equivalent to
```fun g(list: List&lt;String&gt;) = list.mapNotNull { str -&gt; f(str) }.firstOrNull()```


It will evaluate f against the whole list, though, rather than stopping after the first non-null

Yes, as Steve has done. <https://kotlinlang.slack.com/archives/C0922A726/p1590028211398000?thread_ts=1590013332.391300&amp;cid=C0922A726>

I tried using <@U8F19U0TD>’s elegant version but couldn’t because `g` is a suspend function (something I didn’t mention). I ended up sticking with <@U10EJRH2L>’s version. Thanks everyone! That was fun, and I learned from it.