RxJava2 объединяет наблюдаемые разных типов

Я немного новичок в RxJava. Я разбираюсь в этом, но есть один сценарий, который меня не совсем устраивает. Скажем, у меня есть пара Observables разных типов, которые предназначены для совместной работы. Например:

val list: Observable<List<MyClass>>
val indexIntoList: Observable<Int>

Итак, мне нужно наблюдать их как пару, чтобы наблюдатель отправлялся, когда либо list или indexIntoList получает обновление. Сейчас мое решение выглядит примерно так:

var lastListUsed: List<MyClass> = ArrayList()
var lastIndexUsed = -1
val syncObject = Object()

init {
    list.subscribe(object: Observer<List<MyClass>>{
        .
        .
        .
        override fun onNext(t: List<MyClass>)
        {
             FunctionOnMyClass(t, lastIndexUsed)
        }
    })

    indexIntoList.subscribe(object: Observer<Int>{
        .
        .
        .
        override fun onNext(t: Int)
        {
            FunctionOnMyClass(lastListUsed, t)
        }
    })
}

fun FunctionOnMyClass(list: List<MyClass>, index: Int)
{
    synchronized(syncObject)
    {
        lastListUsed = list
        lastIndexUsed = index
        .
        .
        .
    }
}

У меня возникла мысль сделать что-то вроде этого:

var lastMyClass = DefaultMyClass()

list.doOnNext{listVersion ->
    indexIntoMap.map{ index ->
          if (index in listVersion.indices)
              listVersion[index]
          else
              lastMyClass
     }.subscribe(object: Observer<MyClass>{
        .
        .
        .
        override fun onNext(t: MyClass)
        {
            lastMyClass = t
            .
            .
            .
        }
     })
}

Но если я правильно понимаю, чтобы использовать этот метод, мне пришлось бы размещать Disposable во внутреннем Observable каждый раз, когда обновляется внешний Observable. Я бы предпочел не делать этого. Есть ли предпочтительный способ справиться с этим сценарием? Должен ли я быть готов избавиться от Disposable при каждом обновлении внешнего Observable?