RxPHP - Reactive extensions for PHP

  •        4

Reactive extensions for PHP. The reactive extensions for PHP are a set of libraries to compose asynchronous and event-based programs using observable collections and LINQ-style query operators in PHP.note: This repo is for v2.x, the latest version of RxPHP, not v1.x.

https://github.com/ReactiveX/RxPHP

Tags
Implementation
License
Platform

   




Related Projects

RxPY - Reactive Extensions for Python


Reactive Extensions for Python (RxPY) is a set of libraries for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in Python. Using Rx, developers represent asynchronous data streams with Observables, query asynchronous data streams using operators, and parameterize concurrency in data/event streams using Schedulers.Using Rx, you can represent multiple asynchronous data streams (that come from diverse sources, e.g., stock quote, Tweets, computer events, web service requests, etc.), and subscribe to the event stream using the Observer object. The Observable notifies the subscribed Observer instance whenever an event occurs.You can put various transformations in-between the source Observable and the consuming Observer as well.

RxCpp - Reactive Extensions for C++


The Reactive Extensions for C++ (RxCpp) is a library of algorithms for values-distributed-in-time. The Range-v3 library does the same for values-distributed-in-space.The ReactiveX Observable model allows you to treat streams of asynchronous events with the same sort of simple, composable operations that you use for collections of data items like arrays. It frees you from tangled webs of callbacks, and thereby makes your code more readable and less prone to bugs.

Monix - Asynchronous Programming for Scala and Scala.js


Monix is a high-performance Scala / Scala.js library for composing asynchronous and event-based programs, exposing high-level types, such as observable sequences that are exposed as asynchronous streams, expanding on the observer pattern, strongly inspired by ReactiveX and by Scalaz, but designed from the ground up for back-pressure and made to cleanly interact with Scala’s standard library, compatible out-of-the-box with the Reactive Streams protocol.

RxJavaFX - RxJava bindings for JavaFX


RxJavaFX is a lightweight library to convert JavaFX events into RxJava Observables/Flowables and vice versa. It also has a Scheduler to safely move emissions to the JavaFX Event Dispatch Thread.NOTE: To use with Kotlin, check out RxKotlinFX to leverage this library with extension functions and additional operators.

RxGo - Reactive Extensions for the Go language.


All contributions are welcome, both in development and documentation! Be sure you check out contributions and roadmap.ReactiveX, or Rx for short, is an API for programming with observable streams. This is a ReactiveX API for the Go language.


RxRuby - Reactive Extensions for Ruby


Reactive Programming is a hot topic as of late, especially with such things as the Reactive Manifesto. Applications' needs have changed over time, from simple polling for data to a full reactive system where data is pushed at you. Each time, we're adding more complexity, data, and asynchronous behavior to our applications. How do we manage it all? How do we scale it? By moving towards "Reactive Architectures" which are event-driven, resilient, and responsive. With the Reactive Extensions, you have all the tools you need to help build these systems.The Reactive Extensions for Ruby (RxRuby) is a set of libraries for composing asynchronous and event-based programs using observable sequences and fluent query operators that many of you already know in Ruby. Using RxRuby, developers represent asynchronous data streams with Observables, query asynchronous data streams using our many operators, and parameterize the concurrency in the asynchronous data streams using Schedulers. Simply put, RxRuby = Observables + Operators + Schedulers.

RxSwift - Reactive Programming in Swift


Rx is a generic abstraction of computation expressed through Observable<Element> interface.This is a Swift version of Rx.

Talkie - Simple slide presentation library. Responsive scaling & markdown ready.


The master branch is unstable because it makes comprehensive changes with v0.13. For v0.12 code, please refer to the v0.12.x branch. This library written in TypeScript & ReactiveX/rxjs: A reactive programming library for JavaScript.

reprint - A unified fingerprint library for android.


A simple, unified fingerprint authentication library for Android with RxJava extensions. See the sample app for a complete example.

web3j - Connect Java and Android apps to the Ethereum blockchain


web3j is a lightweight, reactive, type safe Java and Android library for integrating with clients (nodes) on the Ethereum network. This allows you to work with the Ethereum blockchain, without the additional overhead of having to write your own integration code for the platform.

rxmarbles - Interactive diagrams of Rx Observables


Interactive diagrams of Rx Observables

RxGroups - Easily group RxJava Observables together and tie them to your Android Activity lifecycle


RxGroups lets you group RxJava Observables together in groups and tie them to your Android lifecycle. This is especially useful when used with Retrofit.For simple scenarios you can probably just let the original request be cancelled and fire a new one. However it's easy to see how this becomes a problem in more complex situations.

Android-ReactiveLocation - Small library that wraps Google Play Service API in brilliant RxJava Observables reducing boilerplate to minimum


Small library that wraps Google Play Services API in brilliant RxJava Observables reducing boilerplate to minimum. Yep, Java 8 is not there yet (and on Android it will take a while) but there is absolutely no Google Play Services LocationClient callbacks hell and there is no clean-up you have to do.

continuation - A compiler for JavaScript asynchronous Continuation-Passing Style transformation


Continuation.js is a compiler for Continuation-Passing Style transformation, which simplifies asynchronous JavaScript programming. It translates slightly flavored JavaScript syntax into standard JavaScript, so it can be also called a "translator". Continuation.js introduces a virtual function cont, which allow you to write continuation-passing style code (or asynchronous callback style code) far easier. cont is not a actual function, but a mark with the same syntax to function calls in JavaScript. By using Continuation.js you can write asynchronous control flows like flat threaded code, and it compiles it into continuation-passing style code. The code above is flatted by using the virtual function cont. Control flow must "wait" for the return of asynchronous function call fs.readFile. Parameters in the argument list of cont will be set after it returns. "Return" here is a little confusing because in an asynchronous function "return" means callback function called, not "return" in the literal sense. An asynchronous function usually returns immediately (by encountering return statement or the end of the function scope) while the callback function could be called later. You can be understood as all the statements after cont until the end of the function are the callback function of the asynchronous function call. The code feels like threaded code, but it is still asynchronous while executing.

http.async.client - Asynchronous HTTP Client for Clojure


http.async.client is the Asynchronous HTTP Client for Clojure. It is promise-based and uses the Asynchronous Http Client for Java for the heavy lifting.

libuv - Cross platform Asynchronous I/O


libuv is a multi-platform support library with a focus on asynchronous I/O. It was primarily developed for use by Node.js, but it’s also used by Luvit, Julia, pyuv, and others. Its feature includes event loop backed by epoll, kqueue, IOCP, event ports. Asynchronous TCP and UDP sockets, Asynchronous DNS resolution, Thread pool, Signal handling and lot more.

fapws3 - Fast Asynchronous Python Web Server (based on libev)


FAPWS (Fast Asynchronous Python Web Server) is a fully WSGI compliant web server for the Python environment with 2 main objectives: keep it small and asynchronous. That way it will not heat your HW resources and will assure to not fall into C10K troubles. It can handle as much as concurrent request as your kernel can handle, Gzip support for on the fly compression and lot more.