is there any way to get a reference to a property?...

# announcements

[tschuchort]

is there any way to get a reference to a property? I can do this:
fun <T> foo(t: T, setProp: T.(Int) -> Unit, getProp: T.() -> Int) = t.apply { setProp(getProp() + 1) }
but what I want to do is:
fun <T> foo(t: T, prop: Property<T,Int>) = t.apply { prop += 1 }

[diesieben07]

val prop: K(Mutable)Property1<MyClass, Int> = MyClass::property should do what you want.

[tschuchort]

the problem is that I have to write prop.set(t, prop.get(t) + 1) then which defeats the purpose of making the syntax nicer.

[tschuchort]

tbh I doubt it's even possible but maybe some Kotlin guru here has an idea

[diesieben07]

The best I got is this, if you can use a property without a receiver (e.g. with a bound reference):

operator fun <R> KProperty0<R>.getValue(receiver: Nothing?, p: KProperty<*>) = get()
operator fun <R> KMutableProperty0<R>.setValue(receiver: Nothing?, p: KProperty<*>, value: R) = set(value)

fun foo(property: KMutableProperty0<Int>) {
    val prop by property
}

[diesieben07]

Unfortunately there is no API to turn a KProperty1<T, R> and a receiver value T into a KProperty0<R> yet.

[tschuchort]

I guess I'll have to stay with regular functions then, but thanks anyway

[diesieben07]

Well, you can still use KProperty1, makes it easier for the caller of your function

[tschuchort]

yeah but at the expense of readability of my function, which is already quite complex and the call site will just be copy&paste boilerplate, where bugs are unlikely

[diesieben07]

Up to you 🤷

[tschuchort]

My use case is that I have a function that returns an observable of anonymous functions which should mutate some state. But I want the function to work with different state classes, so I have to glue them together somehow

[tschuchort]

currently I pass getters and setters for all the required fields as function parameters, but I'm looking for other solutions

[diesieben07]

I think using a KProperty would be cleaner overall, but I can see why you don't want to do it.

[tschuchort]

the functions look like this:

fun <S : State, V : View<S>, T> handlePagination(loadNextPage: () -> Single<List<T>>,
                                                 endReachedSignal: Observable<*>,
                                                 getCurrentState: () -> S,
                                                 getList: S.() -> List<T>,
                                                 setList: S.(List<T>) -> Any?,
                                                 setLoading: S.(Boolean) -> Any?,
                                                 showPagingFailed: V.() -> Any?)
        : Observable<ProgramUpdate<S, V>> {

    fun load() = just(StateChange<S, V> { setLoading(true) })
            .then(loadNextPage().retryDelayed(delay = 1000, times = 5)
                          .map<ProgramUpdate<S,V>> { nextPageItems ->
                              StateChange {
                                  setList(getList() + nextPageItems)
                              }
                          }
                          .onErrorReturn {
                              Timber.e(it)
                              ViewAction(showPagingFailed)
                          }
            )
            .then(StateChange<S, V> { setLoading(false) })

    fun initList() =
            if (getCurrentState().getList().isEmpty())
                load()
            else
                never()

    return merge(endReachedSignal.dropMap { load() }, initList())
}

so you can see why I want to make them simpler