manifold icon indicating copy to clipboard operation
manifold copied to clipboard

A compatibility layer for event-driven abstractions

Results 35 manifold issues
Sort by recently updated
recently updated
newest added

The idiomatic way to "cancel" deferred in Manifold is to put an error value in order to short-circuit all chained listeners. Recently we had quite a few questions around this...

feature request

i concatenated vectors from a stream using `(stream/transform (mapcat identity) s)` this seemed to cause a leak as described here: https://github.com/mpenet/alia/pull/115 investigation showed lots of our `EntityInstance` records from db...

cant replicate

Case in point: ```clj (require '[manifold.deferred :as md]) (let [d (md/deferred)] (-> d (md/timeout! 1000 :timeout) (md/chain println)) ;; Succeeding d with a deferred that never succeeds. (md/success! d (md/deferred)))...

a lot of the macros in manifold (e.g. `d/loop`, `d/let-flow`, `d/success-error-unrealized`, etc.) confuse the static analysis that clj-kondo uses to lint for things like unknown bindings and other such things....

The current implementation of alt' has a bug where it doesn't clean up previous listeners once one of the deferreds have resolved. This problem can be shown using the following...

waiting on user

Some functions, like `d/alt` are designed to handle deferrables as arguments. `let-flow` shouldn't wait on args to functions like these to have been resolved before invoking the function. With this...

Without this, the following code can randomly pick "cat" or "dog" (though "dog" is far more common, making this bug hard to detect or reproduce). ```clj @(let-flow [a "cat" a...

The `mapcat` function seems to choke if you pass in a mapping function that returns a stream instead of a sequence: ``` user> (s/stream->seq (s/mapcat (fn [x] (s/->source [x])) (s/->source...

feature request
good first issue

I'm trying to ensure that my chained callbacks are always run on a specific thread pool, so I'm using `d/onto` followed by `d/chain` to set up the callbacks. What I'm...

``` (def a (s/->source (java.util.concurrent.LinkedBlockingQueue. [1 2 3]))) (def b (s/batch 100 1 a)) (s/close! a) (s/description a) ;; {:type "java.util.concurrent.LinkedBlockingQueue", :buffer-size 0, :source? true} (s/description b) ;; {:pending-puts 1,...

bug