Can we make useful streaming APIs that disallow deadlocks?

1. stately-streams

   1 1 0 3.5 Rust

   combine mutable state and asynchronous streams without deadlocks

   

   So a while back I got interested in how rust could provide parallel/concurrent APIs that prevent deadlocking shared state. I now created a Proof-of-Concept stream processing library that attempts to do that. The library makes prodigious use of heterogeneous lists from the frunk library. The basic idea is that you can build a graph by combining source streams as source nodes and mutexes for state, then you can add nodes which subscribe to subsets of the previous nodes using various combinators. You can either

2. CodeRabbit

   coderabbit.ai featured

   CodeRabbit: AI Code Reviews for Developers. Revolutionize your code reviews with AI. CodeRabbit offers PR summaries, code walkthroughs, 1-click suggestions, and AST-based analysis. Boost productivity and code quality across all major languages with each PR.

   

3. tlaplus

   2 40 2,417 9.4 Java

   TLC is a model checker for specifications written in TLA+. The TLA+Toolbox is an IDE for TLA+.

   

   I think that the traits in this library could be amenable to a proof of lock free behaviour at least for graphs composed entirely of Uniform flow nodes. but right now it's just a hunch. I a little while thinking about it over the last couple of weeks, but a proof, if forthcoming, will definitely be more complicated than I originally hoped. So to the second point of the post title/question does this really disallow deadlocks? I don't know. I think I'll definitely need some kind of proof assistant, and write now am thinking about TLA+, because of it's ability to reason about concurrent systems.

4. frunk

   3 7 1,338 3.9 Rust

   Funktional generic type-level programming in Rust: HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid and friends.

   

   So a while back I got interested in how rust could provide parallel/concurrent APIs that prevent deadlocking shared state. I now created a Proof-of-Concept stream processing library that attempts to do that. The library makes prodigious use of heterogeneous lists from the frunk library. The basic idea is that you can build a graph by combining source streams as source nodes and mutexes for state, then you can add nodes which subscribe to subsets of the previous nodes using various combinators. You can either

Suggest a related project