Proposing Observable.subscribeWith { ... }

[SalomonBrys]

I find the current subscriber syntax cumbersome. Here's an example:

myObservable.subscribe(subscriber<String>()
    .onNext { println(it) }
    .onError { it.printStackTrace() }
)

The problem I have is with subscriber<String>(). Because it creates a subscriber that is later modified with .onNext and .onError, the Kotlin compiler cannot infer it's type.
For subscriber<String>, this is not such an issue, but for subscriber<Map<String, User.Status>> this can quickly become cumbersome.

Beside, we could better use Kotlin's amazing type inference system and use a more "Kotlin-esque" way.

This PR introduces a new way of subscribing to an observable with this proposed API:

myObservable.subscribeWith {
    onNext { println(it) }
    onError { it.printStackTrace() }
}

The API is using Kotlin's type-safe builder pattern.

Let me know what you think ;)

[SalomonBrys]

Travis has failed because "The command "eval git clone --depth=50 git://github.com/ReactiveX/RxKotlin.git ReactiveX/RxKotlin" failed 3 times." but this PR does pass all unit tests

[cy6erGn0m]

You have to note that you generally don't need to create subscriber in this case. You can just do

observable.onError {.... } .subscribe { ... }

So you need this builder if you need to make subscriber and use it later and subscribe dynamically. In this case you will need to specify type anyway.
However I believe it could be good to see this declarative builder too

[SalomonBrys]

Unfortunately not.

That was indeed my first try, but when using .onError {} .subscribe {}, RxJava will throw a OnErrorNotImplementedException in case of error because onError does not catch the error (only runs in case of error).

The correct syntax would be:

observable
    .onErrorResumeNext {
        it.printStackTrace()
        /* Handle the error */
        emptyObservable()
    }
    .subscribe {
        /* Handle next value */
    }

That is why I propose the syntax exposed in this PR ;)

[cy6erGn0m]

With pull #16 subscribeWith could be implemented simply like this

public inline fun <T> Observable<T>.subscribeWith( body : FunctionSubscriber<T>.() -> FunctionSubscriber<T>) : Subscription {
    return subscribe(subscriber<T>().body())
}

[SalomonBrys]

@cy6erGn0m I don't think so since, even in #16, the setter function do not set the value of the current subscriber but create a new copied subscriber with the updated function

[cy6erGn0m]

@SalomonBrys I see, you will need dots in this case

[MarioAriasC]

#16 was merged. You need a rebase

[SalomonBrys]

Done ;) (I did a merge, not a rebase)

[SalomonBrys]

Hi there. Any news on this PR?

[MarioAriasC]

@cy6erGn0m any other comments on this PR?

A 👍 from me

[cy6erGn0m]

I think we can go with it. Lets merge it and release then