cyclops-react - An advanced, but easy to use, platform for writing functional applications in Java 8

  •        108

Powerful Streams and functional data types for building modern Java 8 applications. We extend JDK interfaces where possible for maximum integration.ReactiveSeq extends JDK Stream and offers multiple modes of execution - synchonous, asynchronous, asynchronous with backpressure, parallel and more.

http://cyclops-react.io
https://github.com/aol/cyclops-react

Tags
Implementation
License
Platform

   




Related Projects

RxRuby - Reactive Extensions for Ruby

  •    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.

MobX - Simple, scalable state management.

  •    Javascript

MobX is a battle tested, simple and scalable state management library transparently applying functional reactive programming (TFRP). The Mobx design principle is very simple: Anything that can be derived from the application state, should be derived. Automatically. This includes the UI, data serialization, server communication, etc.

RxPY - Reactive Extensions for Python

  •    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.

refract - Harness the power of reactive programming to supercharge your components

  •    TypeScript

Handle your component effects and side-effects in a clear and declarative fashion by using asynchronous data streams (reactive programming). Component-based architecture and functional programming have become an increasingly popular approach for building UIs. They help make apps more predictable, more testable, and more maintainable.


spring-reactive-sample - Spring 5 Reactive playground

  •    Java

Reactive or Reactive Streams is a hot topic in these days, you can see it in blog entries, presentations, or some online course. Reactive Streams is an initiative to provide a standard for asynchronous stream processing with non-blocking back pressure.This encompasses efforts aimed at runtime environments (JVM and JavaScript) as well as network protocols.

reactive-streams-jvm - Reactive Streams Specification for the JVM

  •    Java

The purpose of Reactive Streams is to provide a standard for asynchronous stream processing with non-blocking backpressure. Handling streams of data—especially “live” data whose volume is not predetermined—requires special care in an asynchronous system. The most prominent issue is that resource consumption needs to be carefully controlled such that a fast data source does not overwhelm the stream destination. Asynchrony is needed in order to enable the parallel use of computing resources, on collaborating network hosts or multiple CPU cores within a single machine.

learn-fp - learn-by-doing course/tutorial for functional programming on scala

  •    Scala

This course/tutorial was created with purpose to better understand functional programming idioms using Scala language. It covers type classes, monoids, functors, applicatives, monads, traversable/foldable, monad transformers, free monad. Material is structured as set of stub/unimplemented functions/classes and tests for them. Your objective is to make all unit tests green. It is learn-by-doing course. NICTA course was a great and interesting challenge for me to do in Haskell. I think Scala community will benefit from the similar course.

alpakka - Alpakka is a Reactive Enterprise Integration library for Java and Scala, based on Reactive Streams and Akka

  •    Scala

Systems don't come alone. In the modern world of microservices and cloud deployment, new components must interact with legacy systems, making integration an important key to success. Reactive Streams give us a technology-independent tool to let these heterogeneous systems communicate without overwhelming each other. The Alpakka project is an open source initiative to implement stream-aware, reactive, integration pipelines for Java and Scala. It is built on top of Akka Streams, and has been designed from the ground up to understand streaming natively and provide a DSL for reactive and stream-oriented programming, with built-in support for backpressure. Akka Streams is a Reactive Streams and JDK 9+ java.util.concurrent.Flow-compliant implementation and therefore fully interoperable with other implementations.

alpakka-kafka - Alpakka Kafka connector - Alpakka is a Reactive Enterprise Integration library for Java and Scala, based on Reactive Streams and Akka

  •    Scala

Systems don't come alone. In the modern world of microservices and cloud deployment, new components must interact with legacy systems, making integration an important key to success. Reactive Streams give us a technology-independent tool to let these heterogeneous systems communicate without overwhelming each other. The Alpakka project is an open source initiative to implement stream-aware, reactive, integration pipelines for Java and Scala. It is built on top of Akka Streams, and has been designed from the ground up to understand streaming natively and provide a DSL for reactive and stream-oriented programming, with built-in support for backpressure. Akka Streams is a Reactive Streams and JDK 9+ java.util.concurrent.Flow-compliant implementation and therefore fully interoperable with other implementations.

Redisson - Redis based In-Memory Data Grid for Java

  •    Java

Redisson - distributed Java objects and services (Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, Map Reduce, Publish / Subscribe, Bloom filter, Spring Cache, Executor service, Tomcat Session Manager, Scheduler service, JCache API) on top of Redis server. Rich Redis client.

Monix - Asynchronous Programming for Scala and Scala.js

  •    Scala

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.

Project Reactor - Create efficient Reactive systems

  •    Java

Reactor is a fourth-generation Reactive library for building non-blocking applications on the JVM based on the Reactive Streams Specification. Reactor is a fully non-blocking foundation with efficient demand management. It directly interacts with Java functional API, Completable Future, Stream and Duration. Reactor Operators and Schedulers can sustain high throughput rates on the order of 10's of millions of messages per second.

TymeacRSE - Java Reactive Streams Push Engine

  •    Java

TymeacRSE is a Recursive Streams push engine for managing the publication and distribution of items to subscribers. An efficient push engine allowing (Reactive Stream) Publishers to generate asynchronous streams for routing to Subscribers. It provides an efficient multitasking service that allows many resource-intensive applications to coexist in a single microservice.

ReactiveObjC - The 2.x ReactiveCocoa Objective-C API: Streams of values over time

  •    Objective-C

ReactiveObjC (formally ReactiveCocoa or RAC) is an Objective-C framework inspired by Functional Reactive Programming. It provides APIs for composing and transforming streams of values. If you're already familiar with functional reactive programming or know the basic premise of ReactiveObjC, check out the other documentation in this folder for a framework overview and more in-depth information about how it all works in practice.

reactor-core - Non-Blocking Reactive Foundation for the JVM

  •    Java

Non-Blocking Reactive Streams Foundation for the JVM both implementing a Reactive Extensions inspired API and efficient event streaming support. Reactor 3 requires Java 8 or + to run.

Cyclejs - A functional and reactive JavaScript framework for predictable code

  •    Typescript

Functional enables “predictable” code, and Reactive enables “separated” code. Cycle.js apps are made of pure functions, which means you know they only take inputs and generate predictable outputs, without performing any I/O effects. The building blocks are reactive streams from libraries like xstream, RxJS or Most.js, which greatly simplify code related to events, asynchrony, and errors.

Vavr - Object-functional language extension to Java

  •    Java

Vavr is an object-functional language extension to Java 8, which aims to reduce the lines of code and increase code quality. It provides persistent collections, functional abstractions for error handling, concurrent programming, pattern matching and much more.