A Promise-like primitive which is lazy/cancelable, has typed errors, and emits synchronously instead of on the microtask queue. In a way LazyPromise is what you get if you take an Observable and make it impossible to misuse it for what the Signals were built to do.
Show HN: LazyPromise = Observable – Signals
1–10 of 11 posts
Re: Show HN: LazyPromise = Observable – Signals
#2Interesting, interesting. It would take me a few hours of playing with this mechanism to know what I think of it as a primitive, but for me this solution is relevant to a problem I really have so I might take a look. Right now I just write methods that sometimes return a promise and sometimes don't.
Re: Show HN: LazyPromise = Observable – Signals
#3> except you can optionally return a teardown function, for example:
Kind of reminds me of https://doc.rust-lang.org/rust-by-example/trait/drop.html
Re: Show HN: LazyPromise = Observable – Signals
#4Do you want monads? Because this is how you get monads.
Re: Show HN: LazyPromise = Observable – Signals
#5Interesting stuff!
The two separate failure channels turn me off. Is this practical or does it introduce unwanted complexity in most cases?
Also wondering what are the Signals that are mentioned.
Re: Show HN: LazyPromise = Observable – Signals
#6Quick question - would something like this cover the basic cancelable promise use case, or am I missing something important about what LazyPromise does differently?
function cancelablePromise() {
const promise = new Promise(resolve => setTimeout(resolve, 1000))
let cancel: () => void
const cancelPromise = new Promise((_, reject) => {
cancel = () => reject("promise canceled")
})
const wrappedPromise = Promise.race([promise, cancelPromise])
return {
promise: wrappedPromise,
cancel: cancel,
}
}Re: Show HN: LazyPromise = Observable – Signals
#7Observability is step one.
The hard part is what the system is allowed to do once you observe it.
Re: Show HN: LazyPromise = Observable – Signals
#8Interesting, interesting. It would take me a few hours of playing with this mechanism to know what I think of it as a primitive, but for me this solution is relevant to a problem I really have so I might take a look. Right now I just write methods that sometimes return a promise and sometimes don't.
Yes, do take a look, I've just added a `log` function that makes it easy to play around with lazy promises and see everything that's going on.
Re: Show HN: LazyPromise = Observable – Signals
#9Quick question - would something like this cover the basic cancelable promise use case, or am I missing something important about what LazyPromise does differently? function cancelablePromise() { const promise = new Promise(resolve => setTimeout(resolve, 1000)) let cancel: () => void const cancelPromise = new Promise((_, reject) => { cancel = () => reject("promise canceled") }) const wrappedPromise = Promise.race([pr…
Yeah, I think this will cover the basic use-case, although the way I'd approach this is by starting with AbortSignal API and then maybe creating a wrapper around it. In a way `eager` and `lazy` functions from LazyPromise library are such wrappers.
Re: Show HN: LazyPromise = Observable – Signals
#10Interesting stuff! The two separate failure channels turn me off. Is this practical or does it introduce unwanted complexity in most cases? Also wondering what are the Signals that are mentioned.
Author here. Good questions.
About the two error channels: what I tried to do is to make it really easy to not use typed errors when you don't need them. In that case your promise is typed as `LazyPromise`.
Signals is a reactive primitive that has been initially introduced in SolidJS framework and have then made their way to other frameworks like Angular.