Observables instead of signals

[ChocolateLoverRaj]

I have an idea. Instead of "signals", what if there were "observables"?

What is an "observable"

I used to use React a lot, and one of the issues I had with React is managing complex data that can change with just useState and useEffect. One of the issues is handling Promises. Another issue is handling data that comes from IO API calls, such as requesting a camera and listening for events from a WebSocket. So I created a thing which I call an "observable". This is how I coded an observable in TypeScript:
https://github.com/ChocolateLoverRaj/observables/blob/15a4ac3ffc5ca22575980ee1a3e7b4af068a0f8c/lib/Observable.ts#L5-L8
With an observable, you can

• Get the current value of the underlying thing
• Add a callback when the value changes
• Remove a callback

Differences between an observable and a signal

• Observables can run side effects based on if they become observed or stop being observed
• Observables can be explicitly tracked instead of "magically" detecting when signals are tracked the way Leptos and Mobx does it.

Observables will remove the need for useEffect in React and create_effect in Leptos (I think)

Observables can run effects when they become observed. They can run cleanup functions when they stop being observed.

Implementing observables in Rust

I'm not sure about how to do this. Maybe have a Stream for when an observable updates and poll the stream if it's observed. I will have to learn more about how futures and polling works in Rust.

Observables demo

GitHub: https://github.com/ChocolateLoverRaj/observables
Demo: https://observables.netlify.app/

Why do I think observables have the potential to be better than Signals

• Easy to reuse common logic in multiple different components
• Can be used with any UI library, including Leptos or React or other React-like libraries
• Can be used outside of UI

Cool things I've done with "observables"

• Managing Promises in a flexible way.
• Loading a list of things asynchronously in batches and handling errors
• Making complex observables like a JS Set and Map. You can observe changes to specific keys instead of being notified of every change to the map.
• Handling saving data in the background
• Syncing data by saving data and getting updates from external sources

Things to think about / explore / consider

How to implement observables?

What is a Rust way of implementing observables? What are the different options? How do they compare in terms of safeness, performance, and ease of use?

Should observables be single-use?

When an observable is updated, should it be destroyed and recreated? Or should an observable continuously provide more updates?

How to deal with observables depending on other observables?

How to manage the memory dropping / not dropping of observables? How do you create observables that depend on a possibly temporary resource such as a camera input or BLE connection?

Explicitly tracked or automatically tracked?

One thing that I don't like about Mobx (and I think this applies to Leptos too) is that you don't explicitly observe changes to things. You just call a get() function in Leptos or access a getter in Mobx, which I think can be confusing. People can accidentally call the get() function outside of a function that is being automatically monitored about what it tracks and things will not be reactive.

[ChocolateLoverRaj]

This seems related and interesting: https://github.com/wishawa/async_ui?tab=readme-ov-file