Where to draw the line with reactive programming

I have been using RxJava in my project for about a year now. With time, I grew to love it very much - now I'm thinking maybe too much...

Most methods I write now have some form of Rx in it, which is great! (until it's not). I now notice that some methods require a lot of work to combine the different observable producing methods. I get the feeling that although I understand what I write now, the next programmer will have a really hard time understanding my code.

Before I get to the bottom line let me give an example straight from my code in Kotlin (Don't dive too deep into it):

private fun <T : Entity> getCachedEntities(
      getManyFunc: () -> Observable<Timestamped<List<T>>>,
      getFromNetwork: () -> Observable<ListResult<T>>,
      getFunc: (String) -> Observable<Timestamped<T>>,
      insertFunc: (T) -> Unit,
      updateFunc: (T) -> Unit,
      deleteFunc: (String) -> Unit)
      = concat(
      getManyFunc().filter { isNew(it.timestampMillis) }
          .map { ListResult(it.value, "") },
      getFromNetwork().doOnNext {
        syncWithStorage(it.entities, getFunc, insertFunc, updateFunc, deleteFunc)
      }).first()
      .onErrorResumeNext { e ->  // If a network error occurred, return the cached data and the error
        concat(getManyFunc().map { ListResult(it.value, "") }, error(e))
      }

Briefly what this does is:

• Retrieve some timestamped data from storage
  • If data is not new, fetch data from network
    • Sync network data again with the storage (to update it)
  • If a network error occured, again retrieve the older data and the error

And here comes my actual question: Reactive programming offers some really powerful concepts. But as we know with great power comes great responsibility.

Where do we draw the line? Is it OK to fill our entire programs with awesome reactive oneliners or should we save it only for really mundane operations?

Obviously this is very subjective, but I hope someone with more experience can share his knowledge and pitfalls. Let me phrase it better

How do I design my code to be reactive yet easy to read?