miha-x64 / lychee Goto Github PK

While committing a transaction, properties should update their values at most once, delivering the latest, consistent changes.

• Android bindings
• JavaFX bindings

addLifecycledChangeListener, lifecycledClearEachAnd etc for LifecycleOwner

val prop = propertyOf(127)
prop.compareAndSet(127, 128) // true
prop.compareAndSet(128, 127) // false

References for boxed 128s differ.

On unsuccessful CAS, a property may internally check whether compared values are boxed primitives which are equal, and repeat attempt.

How this works.
Comparison to fx.Property, Android.util.Property, io.reactivex.BehaviorSubject.
No binary compatibility? Inline, flyweights.
Automatic disposal. When properties are eligible for GC.

@see https://github.com/ReactiveX/RxJava/pull/3979/files
of course, this fix is inappropriate. Gonna pessimize perf only on those problematic devices.

onChange: (old: T, new: T, diff: D) -> Unit

Potential deadlock. Remove RW lock on subscription at all.

Must clear Threads, which are keys of ConcurrentHashMap with Executors.

Property must be held by source only when it is being observed.
This will prevent memory leaks.

Stdlib is required by the compiler, so it should be compileOnly.

getValue() + addChangeListener and addChangeListener are both not sequantially-correct under contention

• Prototype, SQLite, observability
• SQL templates
• Create trigger-based observability which will work for external INSERT/UPDATE/DELETE statements and for multi-node applications with a shared database
• Support mutating SQL templates
• deprecate DAOs and Records

When a propertyOf(some colour) changes its value, makes sense to add a way of animating it smoothly on bound views.

How to add to my gradle dependencies?
Thanks!

With existing type system, union can be expressed as a Partial with only one field set.
The only drawback is that serialization format may require unions to be handled differently, see https://serde.rs/enum-representations.html

During binding, one passes a category, e. g. DATA, UI, DEFAULT. Then it becomes easy to dispose some category of binding, even automatically, e. g. prop.unsubscribeAll(UI).

Change listener may want to do some clean-up when it gets unsubscribed.
Its type, (old: T, new: T) -> Unit, may be replaced with something like

interface PropertyChangeListener<in T> : (old: T, new: T) -> Unit {
    fun unsubscribed()
}

Convenience constructor should be added:

inline fun <T> PropertyChangeListener(crossinline onChange: (old: T, new: T) -> Unit) = ...

PropertyChangeListener name looks too long, suggestions are appreciated.

Add something like suspend fun forEachValue(suspend func: (T) -> Unit), suspend fun nextValue(): T etc, see Channels

something similar to https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS4zLjMxIiwiY29kZSI6ImltcG9ydCBrb3RsaW4ucmVmbGVjdC5LQ2xhc3NcblxuaW50ZXJmYWNlIENvbXBvbmVudFxuXG4vLyB0aGUgd2F5IHRvIHByb2R1Y2UgY29tcG9uZW50c1xudHlwZWFsaWFzIENvbXBvbmVudEZhY3RvcnkgPSAoKSAtPiBDb21wb25lbnRcblxuZGF0YSBjbGFzcyBMYWJlbCh2YWwgdGV4dDogU3RyaW5nKTogQ29tcG9uZW50IHtcbiAgICAvLyBmYWN0b3J5IGNvbXBhbmlvbiAoZm9yIHRoZSBjYXNlIHlvdSBuZWVkIGNvbnN0cnVjdG9yIHdpdGggYXJndW1lbnRzKVxuICAgIGNvbXBhbmlvbiBvYmplY3QgRmFjdG9yeTogQ29tcG9uZW50RmFjdG9yeSB7XG4gICAgICAgIG92ZXJyaWRlIGZ1biBpbnZva2UoKSA9IExhYmVsKFwiRGVmYXVsdCB0ZXh0XCIpXG4gICAgfVxufVxuXG4vLyBjbGFzcyB3aXRoIG5vLWFyZyBjb25zdHJ1Y3RvclxuY2xhc3MgSW1hZ2U6IENvbXBvbmVudFxuXG5mdW4gbWFpbigpIHtcbiAgICAvLyBzYW1wbGUgb2YgbWFwIGFzc29jaWF0aW5nIGNsYXNzIHRvIGl0J3MgZmFjdG9yeVxuICAgIC8qdmFsIGZhY3RvcmllczogTWFwPEtDbGFzczxvdXQgQ29tcG9uZW50PiwgQ29tcG9uZW50RmFjdG9yeT4gPSBtYXBPZihcbiAgICAgICAgTGFiZWw6OmNsYXNzIHRvIExhYmVsLkZhY3RvcnksXG4gICAgICAgIEltYWdlOjpjbGFzcyB0byA6OkltYWdlXG4gICAgKSovXG4gICAgXG4gICAgLy8gbGlzdCBvZiBmYWN0b3JpZXNcbiAgICB2YWwgY29tcG9uZW50czogTGlzdDxDb21wb25lbnRGYWN0b3J5PiA9IGxpc3RPZihcbiAgICAgICAgTGFiZWwuRmFjdG9yeSxcbiAgICAgICAgOjpJbWFnZSAvLyBjb25zdHJ1Y3RvciByZWZlcmVuY2UgYXMgb2JqZWN0IGZhY3RvcnlcbiAgICApXG4gICAgY29tcG9uZW50cy5mb3JFYWNoIFxuICAgIFx0Ly8gY29uc3RydWN0aW5nIHRoZSBvYmplY3QgdmlhIGZhY3RvcnkgaW52b2NhdGlvblxuICAgICAgICB2YWwgY29tcG9uZW50ID0gaXQoKVxuICAgICAgICBwcmludGxuKGNvbXBvbmVudClcbiAgICB9XG59IiwicGxhdGZvcm0iOiJqYXZhIiwiYXJncyI6IiJ9 for structs

It may be called Task, this won't interfere with most known implementations.

Anatomy of a Task.
type State = Initial | Executing | Failed | Canceled | Success | Terminally failed

Executing may have retry: Int which is 0 for first time and increments with next retries.
Failed: the task still may be retried.
Canceled: All subscribers were unsubscribed. Restarts when gets observed.
Terminally failed: number of retries exceeded.

isTerminal:
task.filter { it.isTerminal } may have type State = Success | Terminally failed.

Retry may be triggered explicitly or?..

...to produce less IO.

UiBridge must be called ViewModel. Presenters should go away.

view.getWindowToken() != null is isAttachedToWindow on older versions, can use it

Add a way to subscribe on a certain thread. For mapper properties, add a way to compute on another thread. Along with #15, this may work like

// list: DiffProperty<List<Item>, SomeDiffMeta>
list.mapWithDiff(
    computeOn = someBackgroundScheduler,
    notifyOn = mainThread
) { items, meta ->
    items to DiffUtil.doStuff(items, meta)
}

Develop a property which decorates existing property and delegates equality checking. Standard delegates should be identity, equals, arraysEqual, arraysDeepEqual.

A zero-cost wrapper which acts like Property<T> | T.

// pseudokode, won't kompile
inline class PropertyOrValue<T> {
    private val _value: Any? // = Property<T> | T
    constructor(value: T) {
        this._value = // guard against the (rare) case when value is also a property:
            if (value is Property<*>) immutablePropertyOf(value)
            else value
    }
    constructor(property: Property<T>) {
        this._value = property
    }
    val value: T
        get() = (if (_value is Property<*>) _value.value else _value) as T
    // TODO: addChangeListener(On), removeChangeListener
}

Use-cases:

• universal [library] components which accept some Properties may accept PropertyOfValue instead, allowing caller to avoid wrapping value into ImmutableProperty
• Android resources: (typedValue.changingConfigurations & activityInfo.configChanges) == 0 implies Value, else Property (not sure how popular this case is, taking into account that resources are good at storing strings, but other resource types — animations and animators, drawables, colours and colour state lists, layouts, menus, styles, fonts, scalars and scalar arrays — are mostly useless)

e. g.

val smth: Whatever.() -> Unit = {
    +someStringProp
    +someIntProp
    +someParcelableProp // (?)
}

toParcel(smth)
fromParcel(smth)
toByteArray(smth)
toByteArray(smth)

Persistent ViewModels may be very useful.

mutableProp.casValue(expect, new): Boolean
mutableProp.updateValue { ... } // using CAS, inline

booleanMutableProp.takeEvery(true) {
    "value was switched to true but we've switched back to false and called this code"
} // using CAS to switch
booleanMutableProp.set(): Boolean
booleanMutableProp.reset(): Boolean

Also, group extensions better.

Listeners are [A, B].

1. A gets notified and removes B. B must not be notified then, even within this single iteration.
2. A changes observable's value. Updates must be sequentially-consistent, e. g.
   • notify A
   • A wants to change value? we're notifying now, defer it
   • notify B
   • execute deferred change:
   • change value
   • notify A
   • notify B

Use volatile fields with Updater instead of using AtomicReference. This removes extra wrapper per property.

pom.xml should have dependency on Kotlin

Thread 1 adds/removes first/last listener to such property causing observed state change and (un)subscription from/to sample property
Thread 2 binds the same property to another one causing re-subscription

Currently notification occurs on the thread where value has been changed. It's OK for single-threadd properties, but may be really sad for concurrent properties, especially when you don't know that a property is concurrent.
This behaviour should be consistent across implementations.

Remove List, Enum, EnumSet support from PropertyIo; introduce interface Converter<T> { fun read(DataInput): T; fun write(DataInput, T) }; add List, Enum, EnumSet, ByteString support as extensions.

Maybe move this to another artifact.