Cyclops X patch release 1

Cyclops X patch release 1 (10.0.1)

Cyclops X

Cyclops X (cyclops 10) unifies cyclops-react and the cyclops integration modules on the cyclops versioning scheme. The goal of this project is remove a whole class of runtime errors from application code by providing much stricter APIs that prevent exceptional states from arising. A secondary goal is to modularize cyclops into a series of smaller more focused projects so that functionality is easy to find and developers only take what they need.

What’s new Cyclops X

-> Enhancements over cyclops-react 2

• Fast purely functional datastructures (Vector, Seq / List, LazySeq / LazyList, NonEmptyList, HashSet, TreeSet, TrieSet, HashMap, LinkedMap, MultiMap, TreeMap, BankersQueue, LazyString, Discrete Interval Encoded Tree, Zipper, Range, Tree, DifferenceList, HList, Dependent Map )
• Structural Pattern Matching API (deconstruct algebraic product and sum types)
• Improved type safety via the removal of unsafe APIs
  -- E.g. Unlike Optional, Option has no get method (which could throw a null pointer)
  -- New data structures do not support operations that would throw exceptions (you can't call head on an empty list for example)
• Eager and Lazy alternatives for most datastructures (Option is eager, Maybe is lazy + reactive)
• Improved naming of types (Function1-8 rather than Fn1-8, Either not Xor)
• Group id is changed to com.oath.cyclops
• Versioning between cyclops-react and cyclops is merged on cyclops versioning scheme (version 10 = Cyclops X)
• Light weight dependencies : reactive-streams API & Agrona
• JVM polyglot higher kinder types support via KindedJ

What’s new Cyclops X patch release 1

• Views respect the semantics of the JDK Collection interfaces as defined in the Javadoc (i.e. UnsupportedOperationExceptions are thrown for add / remove etc).

Changelog

Check out the features delivered and bugs fixed -

github 10.0.1 issues & PRs

Dependency changes

None this time

Modules

• cyclops - Persistent data structures and control types
• cyclops-futurestream - Parrallel asynchronous streaming
• cyclops-reactive-collections - Fast, non-blocking, asynchronous extensions for JDK and Persistent Collections
• cyclops-anyM - Higher kinded abstractions for working with any Java Monad type.
• cyclops-pure - Higher kinded type classes for pure functional programming in Java
• cyclops-reactor-integration - Reactive collections and AnyM integrations with Reactor.
• cyclops-rxjava2-integration - Reactive collections and AnyM integrations with Rx Java 2.
• cyclops-jackson-integration - Jackson databindings for Cyclops persistent data structures and control types.

Get cyclops X

Gradle

Cyclops

compile 'com.oath.cyclops:cyclops:10.0.1’

Cyclops AnyM

compile 'com.oath.cyclops:cyclops-anym:10.0.1’

Cyclops Futurestream

compile 'com.oath.cyclops:cyclops-futurestream:10.0.1’

Cyclops Pure

compile 'com.oath.cyclops:cyclops-pure:10.0.1’

Cyclops Reactive Collections

compile 'com.oath.cyclops:cyclops-reactive-collections:10.0.1’

Cyclops Reactor Integration

   compile 'com.oath.cyclops:cyclops-reactor-integration:10.0.1'

Cyclops RxJava2 Integration

   compile 'com.oath.cyclops:cyclops-rx2-integration:10.0.1'

Cyclops Jackson Integration

   compile 'com.oath.cyclops:cyclops-jackson-integration:10.0.1'

Maven

Cyclops

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops</artifactId>
    <version>10.0.1</version>
</dependency>

Cyclops AnyM

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.1</version>
</dependency>

Cyclops Futurestream

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.1</version>
</dependency>

Cyclops Pure

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-pure</artifactId>
    <version>10.0.1</version>
</dependency>

Cyclops Reactive Collections

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-reactive-collections</artifactId>
    <version>10.0.1</version>
</dependency>

Cyclops Reactor Integration

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-reactor-integration</artifactId>
    <version>10.0.1</version>
</dependency>

Cyclops RxJava2 Integration

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-rx2-integration</artifactId>
    <version>10.0.1</version>
</dependency>

Cyclops Jackson Integration

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-jackson-integration</artifactId>
    <version>10.0.1</version>
</dependency>

License

cyclops-react is licensed under the Apache 2.0 license.

http://www.apache.org/licenses/LICENSE-2.0#

Cyclops X FINAL : Release version of Cyclops 10!

Cyclops X FINAL (10.0.0-FINAL)

Cyclops X

Cyclops X (cyclops 10) unifies cyclops-react and the cyclops integration modules on the cyclops versioning scheme. The goal of this project is remove a whole class of runtime errors from application code by providing much stricter APIs that prevent exceptional states from arising. A secondary goal is to modularize cyclops into a series of smaller more focused projects so that functionality is easy to find and developers only take what they need.

What’s new Cyclops X

-> Enhancements over cyclops-react 2

• Fast purely functional datastructures (Vector, Seq / List, LazySeq / LazyList, NonEmptyList, HashSet, TreeSet, TrieSet, HashMap, LinkedMap, MultiMap, TreeMap, BankersQueue, LazyString, Discrete Interval Encoded Tree, Zipper, Range, Tree, DifferenceList, HList, Dependent Map )
• Structural Pattern Matching API (deconstruct algebraic product and sum types)
• Improved type safety via the removal of unsafe APIs
  -- E.g. Unlike Optional, Option has no get method (which could throw a null pointer)
  -- New data structures do not support operations that would throw exceptions (you can't call head on an empty list for example)
• Eager and Lazy alternatives for most datastructures (Option is eager, Maybe is lazy + reactive)
• Improved naming of types (Function1-8 rather than Fn1-8, Either not Xor)
• Group id is changed to com.oath.cyclops
• Versioning between cyclops-react and cyclops is merged on cyclops versioning scheme (version 10 = Cyclops X)
• Light weight dependencies : reactive-streams API & Agrona
• JVM polyglot higher kinder types support via KindedJ

What’s new Cyclops X FINAL Release

• API enhancement : remove limit / skip overloads (remains on ReactiveSeq for Stream compatibility)
• Recursion and concurrent Evaluation enhancements to Eval
• Performance enhancements : core operations improved for Vector, Seq, LazySeq
• Make illegal states unrepresentable : LazySeq is 100% lazy
• IO enhancements : synchronous IO and FutureStream based concurrent IO

API enhancement : remove limit / skip overloads

• take / drop are used everywhere
• only ReactiveSeq retains limit / skip as defined in the Stream API

Recursion and concurrent Evaluation enhancements to Eval

• Eval zipping should focus on supporting interleaving the execution of Evals

The zip method on Eval can used to Evaluate multiple lazy code blocks concurrently, and only accepts another Eval, Trampoline or Supplier as a parameter.

public void interleave(){

        Eval<Integer> algorithm1 = loop(50000,Eval.now(5));
        Eval<Integer> algorithm2 = loop2(50000,Eval.now(5));

        //interleaved execution via Zip!
        Tuple2<Integer, Integer> result = algorithm1.zip(algorithm2,Tuple::tuple).get();

        System.out.println(result);
}

Eval<Integer> loop2(int times,Eval<Integer> sum){
        System.out.println("Loop-B " + times + " : " + sum);
        if(times==0)
            return sum;
        else
            return sum.flatMap(s->loop2(times-1,Eval.now(s+times)));
}

Eval<Integer> loop(int times,Eval<Integer> sum){
        System.out.println("Loop-A " + times + " : " + sum);
        if(times==0)
            return sum;
        else
            return sum.flatMap(s->loop(times-1,Eval.now(s+times)));
}
Producing output showing executing of interleaved lazy calls
Loop-B 15746 : Always[1126048874]
Loop-A 15745 : Always[1126064620]
Loop-B 15745 : Always[1126064620]
Loop-A 15744 : Always[1126080365]
Loop-B 15744 : Always[1126080365]
Loop-A 15743 : Always[1126096109]
Loop-B 15743 : Always[1126096109]
Loop-A 15742 : Always[1126111852]
Loop-B 15742 : Always[1126111852]
Loop-A 15741 : Always[1126127594]

Support Tail-recursion on methods that return a Supplier

Ensure a clean Eval can be created from a Supplier that supports tail-recursion on methods with JDK Friendly method signatures.

Supplier<Integer> loopSupplier(int times, int sum)
Then using Eval, this call shouldn't blow the stack
Supplier<Integer> algorithm1 = loopSupplier(50000,5);
System.out.println(algorithm1.get());
Provide a method to create an Eval from a Supplier
Supplier<Integer> loopSupplier(int times, int sum){
        if(times==0)
            return ()->sum;
        else
            return eval(()->sum).flatMap(s->Evala.eval(loopSupplier(times-1,s+times)));
}

Performance enhancements : core operations improved for Vector, Seq, LazySeq

Significant performance enhancements for append, get, setAt / update for core collections. E.g. Comparison with Vavr (post enhancements - Vavr was faster before) for Vector storing Strings

• Append 10,000 Strings 50th percentile (ms/ops) :

1. Vector (Vavr) : 0.222
2. Vector (Cyclops) : 0.041
   https://github.com/aol/cyclops-react/blob/master/cyclops/src/jmh/java/cyclops/DataAppend.java

Make illegal states unrepresentable

** Make LazySeq totally lazy, solves numerous runtime errors and infinite loop issues
e.g. in Scala

Stream.continually(1)
	    .filter(i=>false)
            .take(0)
            .isEmpty //infinite loop that never finishes!

But Cyclops

LazySeq.generate(()->1)
	      .filter(I->false)
              .take(0)
              .isEmpty() //true! 

IO enhancements : synchronous IO and FutureStream based concurrent IO

• Synchronous IO
  For purely synchronous IO this model of execution will give better performance

IO.sync(this::readData)
  .map(this::process)
  .map(this::save)
  .run()

• FutureStream based IO for blocking concurrent operations

FutureStreamIO.of(Executors.newCachedThreadPool(), this::readUserDataFromCache, this::readUserDataFromDisk, this::readUserDataFromDB)
                .map(this::process)
                .map(this::save)
                .run()

Changelog

Check out the features delivered and bugs fixed -

github 10.0.0-FINAL issues & PRs

Dependency changes

Reactive Streams to 1.0.2

Modules

• cyclops - Persistent data structures and control types
• cyclops-futurestream - Parrallel asynchronous streaming
• cyclops-reactive-collections - Fast, non-blocking, asynchronous extensions for JDK and Persistent Collections
• cyclops-anyM - Higher kinded abstractions for working with any Java Monad type.
• cyclops-pure - Higher kinded type classes for pure functional programming in Java
• cyclops-reactor-integration - Reactive collections and AnyM integrations with Reactor.
• cyclops-rxjava2-integration - Reactive collections and AnyM integrations with Rx Java 2.
• cyclops-jackson-integration - Jackson databindings for Cyclops persistent data structures and control types.

Get cyclops X

Gradle

Cyclops

compile 'com.oath.cyclops:cyclops:10.0.0-FINAL’

Cyclops AnyM

compile 'com.oath.cyclops:cyclops-anym:10.0.0-FINAL’

Cyclops Futurestream

compile 'com.oath.cyclops:cyclops-futurestream:10.0.0-FINAL’

Cyclops Pure

compile 'com.oath.cyclops:cyclops-pure:10.0.0-FINAL’

Cyclops Reactive Collections

compile 'com.oath.cyclops:cyclops-reactive-collections:10.0.0-FINAL’

Cyclops Reactor Integration

   compile 'com.oath.cyclops:cyclops-reactor-integration:10.0.0-FINAL'

Cyclops RxJava2 Integration

   compile 'com.oath.cyclops:cyclops-rx2-integration:10.0.0-FINAL'

Cyclops Jackson Integration

   compile 'com.oath.cyclops:cyclops-jackson-integration:10.0.0-FINAL'

Maven

Cyclops

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops</artifactId>
    <version>10.0.0-FINAL</version>
</dependency>

Cyclops AnyM

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-FINAL</version>
</dependency>

Cyclops Futurestream

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-FINAL</version>
</dependency>

Cyclops Pure

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-pure</artifactId>
    <version>10.0.0-FINAL</version>
</dependency>

Cyclops Reactive Collections

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-reactive-collections</artifactId>
    <version>10.0.0-FINAL</version>
</dependency>

Cyclops Reactor Integration

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-reactor-integration</artifactId>
    <version>10.0.0-FINAL</version>
</dependency>

Cyclops RxJava2 Integration

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-rx2-integration</artifactId>
    <version>10.0.0-FINAL</version>
</dependency>

Cyclops Jackson Integration

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-jackson-integration</artifactId>
    <version>10.0.0-FINAL</version>
</dependency>

License

cyclops-react is licensed ...

Cyclops X Release Candidate 1 : List improvements & API simplification

Release Candidate 1 of Cyclops X

List improvements

• DifferenceList implements ImmutableList
• lazyFoldRight added to LazySeq
• Vector.size bug after take / drop fixes
• splitAt / partition /span operators on Reactive Collections
• NonEmptyList conversions

Make illegal states unrepresentable

• atPercentile returns an Option (when out of range percentiles are passed as input, Option.none is returned).

Bug fixes

• atPercentile bug fixes

API & usability enhancements

• Eq, Ord and NaturalTransformation should move to cyclops.function
• Rename Function0..8 lift() to lazyLift
• Move Comparators to cyclops.companion
• Rename visit in LazySeq to foldLazySeq (similar in BankersQueue and Seq)

lazyFoldRight

There adds the ability to short circuit a la Haskell (see http://voidmainargs.blogspot.com/2011/08/folding-stream-with-scala.html)

foldr (||) False (repeat True)
True

The following code runs forever

LazySeq.generate(()->true)
       .foldRight(false,(a, b)->a ? true : b);

But this does not

LazySeq.generate(()->true)
       .lazyFoldRight(false,(a, b)->a ? true : b.get());
//true

Cyclops X

Cyclops X (cyclops 10) unifies cyclops-react and the cyclops integration modules on the cyclops versioning scheme. The goal of this project is remove a whole class of runtime errors from application code by providing much stricter APIs that prevent exceptional states from arising. A secondary goal is to modularize cyclops into a series of smaller more focused projects so that functionality is easy to find and developers only take what they need.

What’s new Cyclops X

-> Enhancements over cyclops-react 2

• Fast purely functional datastructures (Vector, Seq / List, LazySeq / LazyList, NonEmptyList, HashSet, TreeSet, TrieSet, HashMap, LinkedMap, MultiMap, TreeMap, BankersQueue, LazyString, Discrete Interval Encoded Tree, Zipper, Range, Tree, DifferenceList, HList, Dependent Map )
• Structural Pattern Matching API (deconstruct algebraic product and sum types)
• Improved type safety via the removal of unsafe APIs
  -- E.g. Unlike Optional, Option has no get method (which could throw a null pointer)
  -- New data structures do not support operations that would throw exceptions (you can't call head on an empty list for example)
• Eager and Lazy alternatives for most datastructures (Option is eager, Maybe is lazy + reactive)
• Improved naming of types (Function1-8 rather than Fn1-8, Either not Xor)
• Group id is changed to com.oath.cyclops
• Versioning between cyclops-react and cyclops is merged on cyclops versioning scheme (version 10 = Cyclops X)
• Light weight dependencies : reactive-streams API & Agrona
• JVM polyglot higher kinder types support via KindedJ

What’s new Cyclops X Release Candidate 1

• List enhancements
• API simplification
• bug fixes

Changelog

Check out the features delivered and bugs fixed -

github 10.0.0-RC1 issues & PRs

Dependency changes

Agrona to 0.9.21
RxJava 2 to 2.1.16

Modules

• cyclops - Persistent data structures and control types
• cyclops-futurestream - Parrallel asynchronous streaming
• cyclops-reactive-collections - Fast, non-blocking, asynchronous extensions for JDK and Persistent Collections
• cyclops-anyM - Higher kinded abstractions for working with any Java Monad type.
• cyclops-pure - Higher kinded type classes for pure functional programming in Java
• cyclops-reactor-integration - Reactive collections and AnyM integrations with Reactor.
• cyclops-rxjava2-integration - Reactive collections and AnyM integrations with Rx Java 2.
• cyclops-jackson-integration - Jackson databindings for Cyclops persistent data structures and control types.

Get cyclops X

Gradle

Cyclops

compile 'com.oath.cyclops:cyclops:10.0.0-RC1’

Cyclops AnyM

compile 'com.oath.cyclops:cyclops-anym:10.0.0-RC1’

Cyclops Futurestream

compile 'com.oath.cyclops:cyclops-futurestream:10.0.0-RC1’

Cyclops Pure

compile 'com.oath.cyclops:cyclops-pure:10.0.0-RC1’

Cyclops Reactive Collections

compile 'com.oath.cyclops:cyclops-reactive-collections:10.0.0-RC1’

Cyclops Reactor Integration

   compile 'com.oath.cyclops:cyclops-reactor-integration:10.0.0-RC1'

Cyclops RxJava2 Integration

   compile 'com.oath.cyclops:cyclops-rx2-integration:10.0.0-RC1'

Cyclops Jackson Integration

   compile 'com.oath.cyclops:cyclops-jackson-integration:10.0.0-RC1'

Maven

Cyclops

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops</artifactId>
    <version>10.0.0-RC1</version>
</dependency>

Cyclops AnyM

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-RC1</version>
</dependency>

Cyclops Futurestream

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-RC1</version>
</dependency>

Cyclops Pure

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-pure</artifactId>
    <version>10.0.0-RC1</version>
</dependency>

Cyclops Reactive Collections

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-reactive-collections</artifactId>
    <version>10.0.0-RC1</version>
</dependency>

Cyclops Reactor Integration

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-reactor-integration</artifactId>
    <version>10.0.0-RC1</version>
</dependency>

Cyclops RxJava2 Integration

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-rx2-integration</artifactId>
    <version>10.0.0-RC1</version>
</dependency>

Cyclops Jackson Integration

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-jackson-integration</artifactId>
    <version>10.0.0-RC1</version>
</dependency>

License

cyclops-react is licensed under the Apache 2.0 license.

http://www.apache.org/licenses/LICENSE-2.0#

Cyclops X Milestone 8 : Effect management with reactive-streams

Milestone 8 of Cyclops X

Make illegal states unrepresentable

• retry methods now only available on reactive-types where error handling is expected
• recover methods now only available on types where errors can be caught and recovered
• Semigroup for NonEmptyList concatenation
• Validated control type to represent valid and error states

API Simplification

• Streamable implements Stream
• Streamable moved to cyclops.companion
• mapReduce renamed foldMap
• visit renamed fold
• foldLeft favoured over reduce, reduce moved from non-stream types
• Improved pattern matching API
• endsWithIterable and startsWithIterable become endsWith and startsWith

Handling effects with Reactive Streams

• IO monad interface (cyclops.reactive)
• reactive-streams based implementations of IO (cyclops ReactiveSeq, RxJava2 Flowable, Reactor Flux, generic higher kinded implementation in cyclops-pure based around Monad type class)
• Managed monad interface - for managing resources (see https://www.iravid.com/posts/resource-management.html)
• reactive streams based implementations of Managed (cyclops ReactiveSeq, RxJava2 Flowable, Reactor Flux, generic higher kinded implementation in cyclops-pure based around Monad type class)

Managed monad

 SessionFactory factory;
 Try<String, Throwable> res = Managed.of(factory::openSession)
                                     .with(Session::beginTransaction)
                                     .map((session, tx) ->
                                           deleteFromMyTable(session)
                                                 .bipeek(success -> tx.commit(),error -> tx.rollback())
                                         )
                                     .foldRun(Try::flatten);

public Try<String,Throwable> deleteFromMyTable(Session s);

Using Reactor with cyclops IO Monad

Autoclosing a resource

FluxIO.of(()->10)
      .bracket(i-> new CloseableResource())
      .map(resource->process(resource))
      .run();

Cyclops X

Cyclops X (cyclops 10) unifies cyclops-react and the cyclops integration modules on the cyclops versioning scheme. The goal of this project is remove a whole class of runtime errors from application code by providing much stricter APIs that prevent exceptional states from arising. A secondary goal is to modularize cyclops into a series of smaller more focused projects so that functionality is easy to find and developers only take what they need.

What’s new Cyclops X

-> Enhancements over cyclops-react 2

• Fast purely functional datastructures (Vector, Seq / List, LazySeq / LazyList, NonEmptyList, HashSet, TreeSet, TrieSet, HashMap, LinkedMap, MultiMap, TreeMap, BankersQueue, LazyString, Discrete Interval Encoded Tree, Zipper, Range, Tree, DifferenceList, HList, Dependent Map )
• Structural Pattern Matching API (deconstruct algebraic product and sum types)
• Improved type safety via the removal of unsafe APIs
  -- E.g. Unlike Optional, Option has no get method (which could throw a null pointer)
  -- New data structures do not support operations that would throw exceptions (you can't call head on an empty list for example)
• Eager and Lazy alternatives for most datastructures (Option is eager, Maybe is lazy + reactive)
• Improved naming of types (Function1-8 rather than Fn1-8, Either not Xor)
• Group id is changed to com.oath.cyclops
• Versioning between cyclops-react and cyclops is merged on cyclops versioning scheme (version 10 = Cyclops X)
• Light weight dependencies : reactive-streams API & Agrona
• JVM polyglot higher kinder types support via KindedJ

What’s new Cyclops X Milestone 8

• Improved safety / removal of unsafe apis
• API simplification
• promotion of cyclops-jackson-integration to core module
• effect handling with reactive-streams

Changelog

Check out the features delivered and bugs fixed -

github 10.0.0-M8 issues & PRs

Dependency changes

None this release

Modules

• cyclops - Persistent data structures and control types
• cyclops-futurestream - Parrallel asynchronous streaming
• cyclops-reactive-collections - Fast, non-blocking, asynchronous extensions for JDK and Persistent Collections
• cyclops-anyM - Higher kinded abstractions for working with any Java Monad type.
• cyclops-pure - Higher kinded type classes for pure functional programming in Java
• cyclops-reactor-integration - Reactive collections and AnyM integrations with Reactor.
• cyclops-rxjava2-integration - Reactive collections and AnyM integrations with Rx Java 2.
• cyclops-jackson-integration - Jackson databindings for Cyclops persistent data structures and control types.

Get cyclops X

Gradle

Cyclops

compile 'com.oath.cyclops:cyclops:10.0.0-M8’

Cyclops AnyM

compile 'com.oath.cyclops:cyclops-anym:10.0.0-M8’

Cyclops Futurestream

compile 'com.oath.cyclops:cyclops-futurestream:10.0.0-M8’

Cyclops Pure

compile 'com.oath.cyclops:cyclops-pure:10.0.0-M8’

Cyclops Reactive Collections

compile 'com.oath.cyclops:cyclops-reactive-collections:10.0.0-M8’

Cyclops Reactor Integration

   compile 'com.oath.cyclops:cyclops-reactor-integration:10.0.0-M8'

Cyclops RxJava2 Integration

   compile 'com.oath.cyclops:cyclops-rx2-integration:10.0.0-M8'

Cyclops Jackson Integration

   compile 'com.oath.cyclops:cyclops-jackson-integration:10.0.0-M8'

Maven

Cyclops

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops</artifactId>
    <version>10.0.0-M8</version>
</dependency>

Cyclops AnyM

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-M8</version>
</dependency>

Cyclops Futurestream

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-M8</version>
</dependency>

Cyclops Pure

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-pure</artifactId>
    <version>10.0.0-M8</version>
</dependency>

Cyclops Reactive Collections

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-reactive-collections</artifactId>
    <version>10.0.0-M8</version>
</dependency>

Cyclops Reactor Integration

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-reactor-integration</artifactId>
    <version>10.0.0-M8</version>
</dependency>

Cyclops RxJava2 Integration

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-rx2-integration</artifactId>
    <version>10.0.0-M8</version>
</dependency>

Cyclops Jackson Integration

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-jackson-integration</artifactId>
    <version>10.0.0-M8</version>
</dependency>

License

cyclops-react is licensed under the Apache 2.0 license.

http://www.apache.org/licenses/LICENSE-2.0#

Cyclops X Milestone 7 : JSON Serialization / Deserialization

Milestone 7 of Cyclops X

cyclops-jackson-integration is a brand new Cyclops module that provides Jackson JSON serialisation and deserialisation for cyclops persistent collections and control types. Milestone 7 also bring the cyclops-vavr-integration module up-to-date (providing integration with cyclops-reactive-collections for Vavr persistent collections, and cyclops AnyM(onad) integration for Vavr monadic types).

Other improvements in this release include

• A better Eval implementation (under the hood changes making use of Cyclops’ Trampoline implementation).
• Fixes to method and package names
• Enhancments to cyclops Tuples (new concat methods)

Jackson serialisation and derserialization

import com.oath.cyclops.jackson.CyclopsModule;
import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper mapper = new ObjectMapper();

mapper.registerModule(new CyclopsModule());

Serializing and deserializing a Cyclops Vector programmatically

String json = JacksonUtil.serializeToJson(Vector.of(1,2,3));

Vector<Integer> s = JacksonUtil.convertFromJson(json,Vector.class);
//[1,2,3]

Cyclops X

Cyclops X (cyclops 10) unifies cyclops-react and the cyclops integration modules on the cyclops versioning scheme. The goal of this project is remove a whole class of runtime errors from application code by providing much stricter APIs that prevent exceptional states from arising. A secondary goal is to modularize cyclops into a series of smaller more focused projects so that functionality is easy to find and developers only take what they need.

What’s new Cyclops X

-> Enhancements over cyclops-react 2

• Fast purely functional datastructures (Vector, Seq / List, LazySeq / LazyList, NonEmptyList, HashSet, TreeSet, TrieSet, HashMap, LinkedMap, MultiMap, TreeMap, BankersQueue, LazyString, Discrete Interval Encoded Tree, Zipper, Range, Tree, DifferenceList, HList, Dependent Map )
• Structural Pattern Matching API (deconstruct algebraic product and sum types)
• Improved type safety via the removal of unsafe APIs
  -- E.g. Unlike Optional, Option has no get method (which could throw a null pointer)
  -- New data structures do not support operations that would throw exceptions (you can't call head on an empty list for example)
• Eager and Lazy alternatives for most datastructures (Option is eager, Maybe is lazy + reactive)
• Improved naming of types (Function1-8 rather than Fn1-8, Either not Xor)
• Group id is changed to com.oath.cyclops
• Versioning between cyclops-react and cyclops is merged on cyclops versioning scheme (version 10 = Cyclops X)
• Light weight dependencies : reactive-streams API & Agrona

What’s new Cyclops X Milestone 5

• Pure functional programming Module
• flatMap and map Operators on Trampoline
• reactive-streams based IO Monad
• Safe PartialFunction API

Changelog

Check out the features delivered and bugs fixed -

github 10.0.0-M7 issues & PRs

Dependency changes

None this release

Modules

• cyclops - Persistent data structures and control types
• cyclops-futurestream - Parrallel asynchronous streaming
• cyclops-reactive-collections - Fast, non-blocking, asynchronous extensions for JDK and Persistent Collections
• cyclops-anyM - Higher kinded abstractions for working with any Java Monad type.
• cyclops-pure - Higher kinded type classes for pure functional programming in Java
• cyclops-reactor-integration - Reactive collections and AnyM integrations with Reactor.
• cyclops-rxjava2-integration - Reactive collections and AnyM integrations with Rx Java 2.
• cyclops-rxjava-integration - Reactive collections and AnyM integrations with Rx Java.
• cyclops-vavr-integration - Reactive collections and AnyM integrations with Vavr.
• cyclops-jackson-integration - Jackson databindings for Cyclops persistent data structures and control types.

Get cyclops X

Gradle

Cyclops

compile 'com.oath.cyclops:cyclops:10.0.0-M7’

Cyclops AnyM

compile 'com.oath.cyclops:cyclops-anym:10.0.0-M7’

Cyclops Futurestream

compile 'com.oath.cyclops:cyclops-futurestream:10.0.0-M7’

Cyclops Pure

compile 'com.oath.cyclops:cyclops-pure:10.0.0-M7’

Cyclops Reactive Collections

compile 'com.oath.cyclops:cyclops-reactive-collections:10.0.0-M7’

Cyclops Reactor Integration

   compile 'com.oath.cyclops:cyclops-reactor-integration:10.0.0-M7'

Cyclops RxJava2 Integration

   compile 'com.oath.cyclops:cyclops-rx2-integration:10.0.0-M7'

Cyclops RxJava Integration

   compile 'com.oath.cyclops:cyclops-rx-integration:10.0.0-M7'

Cyclops Vavr Integration

   compile 'com.oath.cyclops:cyclops-vavr-integration:10.0.0-M7'

Cyclops Jackson Integration

   compile 'com.oath.cyclops:cyclops-jackson-integration:10.0.0-M7'

Maven

Cyclops

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops</artifactId>
    <version>10.0.0-M7</version>
</dependency>

Cyclops AnyM

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-M7</version>
</dependency>

Cyclops Futurestream

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-M7</version>
</dependency>

Cyclops Pure

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-pure</artifactId>
    <version>10.0.0-M7</version>
</dependency>

Cyclops Reactive Collections

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-reactive-collections</artifactId>
    <version>10.0.0-M7</version>
</dependency>

Cyclops Reactor Integration

    com.oath.cyclops
    cyclops-reactor-integration
    10.0.0-M7

Cyclops RxJava2 Integration

    com.oath.cyclops
    cyclops-rx2-integration
    10.0.0-M7

Cyclops RxJava Integration

   
    com.oath.cyclops
    cyclops-rx-integration
    10.0.0-M7

Cyclops Vavr Integration

    com.oath.cyclops
    cyclops-vavr-integration
    10.0.0-M7

Cyclops Jackson Integration

    com.oath.cyclops
    cyclops-jackson-integration
    10.0.0-M7

Documentation

• OSCON 2016 Slides
• user-guide : work in progress
• simple-react wiki
• old cyclops wiki
• javadoc

Articles

• Reactive programming with Java 8 and simple-react: The Tutorial
• JDK Collection eXtensions
• Awesome Fluent Functions
• Straightforward Structural Pattern Matching
• Performant Functional Try
• Articles on medium
• Introducting the Cyclops Monad API
• Easier Try with Cyclops
• 4 flavors of Java 8 Functions
• Memoise Functions in Java 8
• Strategy Pattern in Java 8
• Functional Feature Toggling
• Dependency injection using the Reader Monad in Java8
• Scheduling a Stream
• [Neophytes guide to Java 8 : Welcome to th...

Cyclops X Milestone 6 : Reactive Collections

Milestone 6 of Cyclops X

Cyclops-reactive-collections is the last module to be created for Cyclops X (released in Milestone 6). Cyclops lazy and reactive extended collection types move out of the core into their own module, where they can be configured to run powered by Cyclops’ ReactiveSeq or by asynchronous streams in RxJava/2 or Pivotal’s Reactor.

Cyclops Reactive Collections are a suite of extensions for JDK and Persistent Collection types that support a large range of operators as well as (smart) lazy execution of chained operators to drive performance and asynchronous data flows through those operators.

As well as providing configuration options for the reactive engine powering the collections, it is possible to configure the collection types used. E.g. we can switch between Cyclops persistent collections or Vavr persistent collections.

The core of cyclops has been refactored to use Cyclops’ own eager persistent data structures (such as Vector, Seq and LazySeq).

Other improvements in this release include

• Integration with KindedJ which provides a standard interface for simulated Higher Kinded types on the JVM (also used in the Arrow library for Kotlin)
• A much enhanced LazyString implementation
• More consistent naming of grouped and append method suites
• cyclops-pure refactored to use cyclops persistent data types rather than extended collections
• AnyM based monad transformers for core Cyclops Data types (OptionT, VectorT, LazySeqT, SeqT)

Enhanced performance via laziness

Chaining combinator operations on traditional functional datastructures such as the core persistent data structures provided in cyclops.data (or in Vavr or the Scala SDK) results in traversing the datastructure multiple times, once per combinator operation.

E.g. to transform and filter a Cyclops Vector we could write code like the following

Vector.of(1,2,3)
      .map(i->i*100)
      .filter(i->i<200);

Each of the chained operations will traverse the Vector, once for map and once for filter.

With Cyclops Reactive Collections VectorX the code remains very similar, the underlying datastructure remains identical, but the performance is much improved

VectorX.of(1,2,3)
       .map(i->i*100)
       .filter(i->i<200);

VectorX in contrast to a raw Vector traverses the underlying data structure just once.

Performance improvement for Vavr's Vector when used with Cyclops VectorX

Lower score is better

• Raw Vavr Vector is on the Right.
• Vavr Vector with Cyclops VectorX is on the left.

Reactive Collections!

In the example below we asynchronously populate an Xtended list using an asynchronously executing ReactiveSeq. Additional reactive operations can be performed on the List asynchronously.
The ListX only blocks on first access to the data.

AtomicBoolean complete = new AtomicBoolean(false);


ReactiveSeq<Integer> async =  Spouts.async(ReactiveSeq.of(1,2,3),Executors.newFixedThreadPool(1));

ListX<Integer> asyncList = ListX.listX(async)
                                   .map(i->i+1);

System.out.println("Blocked? " + complete.get());

System.out.println("First value is "  + asyncList.get(0));

System.out.println("Completed? " + complete.get());

Which will print

Blocked? false
First value is 101
Completed? true

Available data structures

cyclops.collections (mutable / immutable)

type	description	characteristics
ListX	Functional extensions for working with Lists	Optionally Reactive or Coreactive, Lazy, mutable, immutable, 3rd party support, Higher kinded
DequeX	Functional extensions for working with Deques	Optionally Reactive or Coreactive, Lazy, mutable, immutable, 3rd party support, Higher kinded
QueueX	Functional extensions for working with Queues	Optionally Reactive or Coreactive, Lazy, mutable, immutable, 3rd party support, Higher kinded
SetX	Functional extensions for working with Sets	Optionally Reactive or Coreactive, Lazy , mutable, immutable, 3rd party support
SortedSetX	Functional extensions for working with SortedSets	Optionally Reactive or Coreactive, Lazy, mutable, immutable
MapX	Functional extensions for working with Maps	Eager, mutable, immutable

cyclops.collections.persistent

type	description	characteristics
LinkedListX	Functional extensions for working with persistent Lists	Optionally Reactive or Coreactive, Lazy, persistent, 3rd party support, Higher kinded
VectorX	Functional extensions for working with persistent Vectors	Optionally Reactive or Coreactive, Lazy, persistent, 3rd party support, Higher kinded
PersistentSetX	Functional extensions for working with persistent Sets	Optionally Reactive or Coreactive, Lazy, persistent, 3rd party support
OrderedSetX	Functional extensions for working with persistent Ordered Sets	Optionally Reactive or Coreactive, Lazy, persistent, 3rd party support
PersistentQueueX	Functional extensions for working with persistent Queues	Optionally Reactive or Coreactive, Lazy, persistent, 3rd party support, Higher kinded
BagX	Functional extensions for working with persistent Bags (set like collections that allow duplicates)	Optionally Reactive or Coreactive,Lazy, persistent, 3rd party support

Examples

Lazy execution using extended Collections

Eval<Integer> lazyResult = ListX.of(1,2,3,4)
                                 .map(i->i*10)
                                 .foldLazy(s->s
                                 .reduce( 50,(acc,next) -> acc+next));

Articles

• JDK Collection eXtensions
• Faster Purely Data Structures For Java

Cyclops X

Cyclops X (cyclops 10) unifies cyclops-react and the cyclops integration modules on the cyclops versioning scheme. The goal of this project is remove a whole class of runtime errors from application code by providing much stricter APIs that prevent exceptional states from arising. A secondary goal is to modularize cyclops into a series of smaller more focused projects so that functionality is easy to find and developers only take what they need.

What’s new Cyclops X

-> Enhancements over cyclops-react 2

• Fast purely functional datastructures (Vector, Seq / List, LazySeq / LazyList, NonEmptyList, HashSet, TreeSet, TrieSet, HashMap, LinkedMap, MultiMap, TreeMap, BankersQueue, LazyString, Discrete Interval Encoded Tree, Zipper, Range, Tree, DifferenceList, HList, Dependent Map )
• Structural Pattern Matching API (deconstruct algebraic product and sum types)
• Improved type safety via the removal of unsafe APIs
  -- E.g. Unlike Optional, Option has no get method (which could throw a null pointer)
  -- New data structures do not support operations that would throw exceptions (you can't call head on an empty list for example)
• Eager and Lazy alternatives for most datastructures (Option is eager, Maybe is lazy + reactive)
• Improved naming of types (Function1-8 rather than Fn1-8, Either not Xor)
• Group id is changed to com.oath.cyclops
• Versioning between cyclops-react and cyclops is merged on cyclops versioning scheme (version 10 = Cyclops X)
• Light weight dependencies : reactive-streams API & Agrona

What’s new Cyclops X Milestone 5

• Pure functional programming Module
• flatMap and map Operators on Trampoline
• reactive-streams based IO Monad
• Safe PartialFunction API

Changelog

Check out the features delivered and bugs fixed -

github 10.0.0-M6 issues & PRs

Dependency changes

Cyclops no longer depends on pCollections or jOOλ

Get cyclops X

Gradle

Cyclops

compile 'com.oath.cyclops:cyclops:10.0.0-M6’

Cyclops AnyM

compile 'com.oath.cyclops:cyclops-anym:10.0.0-M6’

Cyclops Futurestream

compile 'com.oath.cyclops:cyclops-futurestream:10.0.0-M6’

Cyclops Pure

compile 'com.oath.cyclops:cyclops-pure:10.0.0-M6’

Cyclops Reactive Collections

compile 'com.oath.cyclops:cyclops-reactive-collections:10.0.0-M6’

Maven

Cyclops

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops</artifactId>
    <version>10.0.0-M6</version>
</dependency>

Cyclops AnyM

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-M6</version>
</dependency>

Cyclops Futurestream

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-M6</version>
</dependency>

Cyclops Pure

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-pure</artifactId>
    <version>10.0.0-M6</version>
</dependency>

Cyclops Reactive Collections

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-reactive-collections</artifactId>
    <versi...

10.0.0-M5 : Cyclops Pure module and reactive-streams based IO Monad

Milestone 5 of Cyclops X

M5 of Cyclops X introduces another new module cyclops-pure. Cyclops Pure provides additional control structures, typeclass definitions and instances for pure category theoritic functional programming in Java. Cyclops Pure simulates Higher Kinded Types using Witness Types (see Simulating Higher Kinded Types in Java ).

Cyclops X

Cyclops X (cyclops 10) unifies cyclops-react and the cyclops integration modules on the cyclops versioning scheme. The goal of this project is remove a whole class of runtime errors from application code by providing much stricter APIs that prevent exceptional states from arising. A secondary goal is to modularize cyclops into a series of smaller more focused projects so that functionality is easy to find and developers only take what they need.

What’s new Cyclops X

-> Enhancements over cyclops-react 2

• Fast purely functional datastructures (Vector, Seq / List, LazySeq / LazyList, NonEmptyList, HashSet, TreeSet, TrieSet, HashMap, LinkedMap, MultiMap, TreeMap, BankersQueue, LazyString, Discrete Interval Encoded Tree, Zipper, Range, Tree, DifferenceList, HList, Dependent Map )
• Structural Pattern Matching API (deconstruct algebraic product and sum types)
• Improved type safety via the removal of unsafe APIs
  -- E.g. Unlike Optional, Option has no get method (which could throw a null pointer)
  -- New data structures do not support operations that would throw exceptions (you can't call head on an empty list for example)
• Eager and Lazy alternatives for most datastructures (Option is eager, Maybe is lazy + reactive)
• Improved naming of types (Function1-8 rather than Fn1-8, Either not Xor)
• Group id is changed to com.oath.cyclops
• Versioning between cyclops-react and cyclops is merged on cyclops versioning scheme (version 10 = Cyclops X)
• Light weight dependencies : reactive-streams API & Agrona

What’s new Cyclops X Milestone 5

• Pure functional programming Module
• flatMap and map Operators on Trampoline
• reactive-streams based IO Monad
• Safe PartialFunction API

Changelog

Check out the features delivered and bugs fixed -

github 10.0.0-M5 issues & PRs

Dependency changes

Cyclops no longer depends on pCollections or jOOλ

Get cyclops X

Gradle

Cyclops

compile 'com.oath.cyclops:cyclops:10.0.0-M5’

Cyclops AnyM

compile 'com.oath.cyclops:cyclops-anym:10.0.0-M5’

Cyclops Futurestream

compile 'com.oath.cyclops:cyclops-futurestream:10.0.0-M5’

Cyclops Pure

compile 'com.oath.cyclops:cyclops-pure:10.0.0-M5’

Maven

Cyclops

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops</artifactId>
    <version>10.0.0-M5</version>
</dependency>

Cyclops AnyM

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-M5</version>
</dependency>

Cyclops Futurestream

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-M5</version>
</dependency>

Cyclops Pure

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-pure</artifactId>
    <version>10.0.0-M5</version>
</dependency>

Documentation

• OSCON 2016 Slides
• user-guide : work in progress
• simple-react wiki
• old cyclops wiki
• javadoc

Articles

• Reactive programming with Java 8 and simple-react: The Tutorial
• JDK Collection eXtensions
• Awesome Fluent Functions
• Straightforward Structural Pattern Matching
• Performant Functional Try
• Articles on medium
• Introducting the Cyclops Monad API
• Easier Try with Cyclops
• 4 flavors of Java 8 Functions
• Memoise Functions in Java 8
• Strategy Pattern in Java 8
• Functional Feature Toggling
• Dependency injection using the Reader Monad in Java8
• Scheduling a Stream
• Neophytes guide to Java 8 : Welcome to the Future
• Deterministic and Non-Deterministic Finite State Machines with Cyclops

Old simple-react landing page

License

cyclops-react is licensed under the Apache 2.0 license.

http://www.apache.org/licenses/LICENSE-2.0#

10.0.0-M4 : FutureStream module and improved type safety.

Milestone 4 of Cyclops X

M4 of Cyclops X introduces another new module cyclops-futurestream. Cyclops Futurestream provides support for asynchronous / parallel Streaming implemented as a Stream of Future based tasks. For developers familar with Java 8 Streams, this is a pretty easy to use API that can very performantly handle blocking I/O based tasks (such as block operations on resources from file, or remote systems / dbs).

Cyclops X

Cyclops X (cyclops 10) unifies cyclops-react and the cyclops integration modules on the cyclops versioning scheme. The goal of this project is remove a whole class of runtime errors from application code by providing much stricter APIs that prevent exceptional states from arising. A secondary goal is to modularize cyclops into a series of smaller more focused projects so that functionality is easy to find and developers only take what they need.

What’s new Cyclops X

-> Enhancements over cyclops-react 2

• Fast purely functional datastructures (Vector, Seq / List, LazySeq / LazyList, NonEmptyList, HashSet, TreeSet, TrieSet, HashMap, LinkedMap, MultiMap, TreeMap, BankersQueue, LazyString, Discrete Interval Encoded Tree, Zipper, Range, Tree, DifferenceList, HList, Dependent Map )
• Structural Pattern Matching API (deconstruct algebraic product and sum types)
• Improved type safety via the removal of unsafe APIs
  -- E.g. Unlike Optional, Option has no get method (which could throw a null pointer)
  -- New data structures do not support operations that would throw exceptions (you can't call head on an empty list for example)
• Eager and Lazy alternatives for most datastructures (Option is eager, Maybe is lazy + reactive)
• Improved naming of types (Function1-8 rather than Fn1-8, Either not Xor)
• Group id is changed to com.oath.cyclops
• Versioning between cyclops-react and cyclops is merged on cyclops versioning scheme (version 10 = Cyclops X)
• Light weight dependencies : reactive-streams API & Agrona

What’s new Cyclops X Milestone 4

• Futurestream Module
• mapOrCatch / flatMapOrCatch operators added to Try
• Transform method added to TupleN
• Naming convention improvements : flatMapI / flatMapIterable to become concatMap. flatMapP / flatMapPublisher to become mergeMap
• Performance improvements on Map / filter operations in Seq
• Cyclops Try type safety and usability enhancements
• Zippable type simplified
• indexOf / lastIndexOf fold operator added

Changelog

Check out the features delivered and bugs fixed -

github 10.0.0-M4 issues & PRs

Dependency changes

Cyclops no longer depends on pCollections or jOOλ

Get cyclops X

Gradle

Cyclops

compile 'com.oath.cyclops:cyclops:10.0.0-M4’

Cyclops AnyM

compile 'com.oath.cyclops:cyclops-anym:10.0.0-M4’

Cyclops Futurestream

compile 'com.oath.cyclops:cyclops-futurestream:10.0.0-M4’

Maven

Cyclops

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops</artifactId>
    <version>10.0.0-M4</version>
</dependency>

Cyclops AnyM

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-M4</version>
</dependency>

Cyclops Futurestream

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-M4</version>
</dependency>

Documentation

• OSCON 2016 Slides
• user-guide : work in progress
• simple-react wiki
• old cyclops wiki
• javadoc

Articles

• Reactive programming with Java 8 and simple-react: The Tutorial
• JDK Collection eXtensions
• Awesome Fluent Functions
• Straightforward Structural Pattern Matching
• Performant Functional Try
• Articles on medium
• Introducting the Cyclops Monad API
• Easier Try with Cyclops
• 4 flavors of Java 8 Functions
• Memoise Functions in Java 8
• Strategy Pattern in Java 8
• Functional Feature Toggling
• Dependency injection using the Reader Monad in Java8
• Scheduling a Stream
• Neophytes guide to Java 8 : Welcome to the Future
• Deterministic and Non-Deterministic Finite State Machines with Cyclops

Old simple-react landing page

License

cyclops-react is licensed under the Apache 2.0 license.

http://www.apache.org/licenses/LICENSE-2.0#

Cyclops X - Milestone 3

Milestone three of Cyclops X

M3 of Cyclops X introduces a new module cyclops-anym. All of the classes supporting higher kinded Monad abstraction AnyM have been moved to this module.

Cyclops X

Cyclops X (cyclops 10) unifies cyclops-react and the cyclops integration modules on the cyclops versioning scheme. The goal of this project is remove a whole class of runtime errors from application code by providing much stricter APIs that prevent exceptional states from arising. A secondary goal is to modularize cyclops into a series of smaller more focused projects so that functionality is easy to find and developers only take what they need.

What’s new Cyclops X

-> Enhancements over cyclops-react 2

• Fast purely functional datastructures (Vector, Seq / List, LazySeq / LazyList, NonEmptyList, HashSet, TreeSet, TrieSet, HashMap, LinkedMap, MultiMap, TreeMap, BankersQueue, LazyString, Discrete Interval Encoded Tree, Zipper, Range, Tree, DifferenceList, HList, Dependent Map )
• Structural Pattern Matching API (deconstruct algebraic product and sum types)
• Improved type safety via the removal of unsafe APIs
  -- E.g. Unlike Optional, Option has no get method (which could throw a null pointer)
  -- New data structures do not support operations that would throw exceptions (you can't call head on an empty list for example)
• Eager and Lazy alternatives for most datastructures (Option is eager, Maybe is lazy + reactive)
• Improved naming of types (Function1-8 rather than Fn1-8, Either not Xor)
• Group id is changed to com.oath.cyclops
• Versioning between cyclops-react and cyclops is merged on cyclops versioning scheme (version 10 = Cyclops X)
• Light weight dependencies : reactive-streams API & Agrona

What’s new Cyclops X Milestone 3

• AnyM Module
• Bug in Hash Array Mapped Trie fixed

Changelog

Check out the features delivered and bugs fixed -

github 10.0.0-M4 issues & PRs

Dependency changes

Cyclops no longer depends on pCollections or jOOλ

Get cyclops X

Gradle

Cyclops

compile 'com.oath.cyclops:cyclops:10.0.0-M3’

Cyclops AnyM

compile 'com.oath.cyclops:cyclops-anym:10.0.0-M3’

Maven

Cyclops

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops</artifactId>
    <version>10.0.0-M3</version>
</dependency>

Cyclops AnyM

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops-anym</artifactId>
    <version>10.0.0-M3</version>
</dependency>

Documentation

• OSCON 2016 Slides
• user-guide : work in progress
• simple-react wiki
• old cyclops wiki
• javadoc

Articles

• Reactive programming with Java 8 and simple-react: The Tutorial
• JDK Collection eXtensions
• Awesome Fluent Functions
• Straightforward Structural Pattern Matching
• Performant Functional Try
• Articles on medium
• Introducting the Cyclops Monad API
• Easier Try with Cyclops
• 4 flavors of Java 8 Functions
• Memoise Functions in Java 8
• Strategy Pattern in Java 8
• Functional Feature Toggling
• Dependency injection using the Reader Monad in Java8
• Scheduling a Stream
• Neophytes guide to Java 8 : Welcome to the Future
• Deterministic and Non-Deterministic Finite State Machines with Cyclops

Old simple-react landing page

License

cyclops-react is licensed under the Apache 2.0 license.

http://www.apache.org/licenses/LICENSE-2.0#

Cyclops X - Milestone 2

Milestone two of Cyclops X

Cyclops X (cyclops 10) unifies cyclops-react and the cyclops integration modules on the cyclops versioning scheme. The goal of this project is remove a whole class of runtime errors from application code by providing much stricter APIs that prevent exceptional states from arising. A secondary goal is to modularize cyclops into a series of smaller more focused projects so that functionality is easy to find and developers only take what they need.

What’s new Cyclops X

-> Enhancements over cyclops-react 2

• Fast purely functional datastructures (Vector, Seq / List, LazySeq / LazyList, NonEmptyList, HashSet, TreeSet, TrieSet, HashMap, LinkedMap, MultiMap, TreeMap, BankersQueue, LazyString, Discrete Interval Encoded Tree, Zipper, Range, Tree, DifferenceList, HList, Dependent Map )
• Structural Pattern Matching API (deconstruct algebraic product and sum types)
• Improved type safety via the removal of unsafe APIs
  -- E.g. Unlike Optional, Option has no get method (which could throw a null pointer)
  -- New data structures do not support operations that would throw exceptions (you can't call head on an empty list for example)
• Eager and Lazy alternatives for most datastructures (Option is eager, Maybe is lazy + reactive)
• Improved naming of types (Function1-8 rather than Fn1-8, Either not Xor)
• Group id is changed to com.oath.cyclops
• Versioning between cyclops-react and cyclops is merged on cyclops versioning scheme (version 10 = Cyclops X)
• Light weight dependencies : reactive-streams API & Agrona

What’s new Cyclops X Milestone 2

• JDK Collection Views on Immutable Data Structures
• LazySeq map / flatMap / filter lazy bug fix
• HashMappedArrayTrie minus bug fix

Changelog

Check out the features delivered and bugs fixed -

github 10.0.0-M2 issues & PRs

Dependency changes

Cyclops no longer depends on pCollections or jOOλ

Get cyclops X

Gradle

compile 'com.oath.cyclops:cyclops:10.0.0-M2’

Maven

<dependency>
    <groupId>com.oath.cyclops</groupId>
    <artifactId>cyclops</artifactId>
    <version>10.0.0-M2</version>
</dependency>

Documentation

• OSCON 2016 Slides
• user-guide : work in progress
• simple-react wiki
• old cyclops wiki
• javadoc

Articles

• Reactive programming with Java 8 and simple-react: The Tutorial
• JDK Collection eXtensions
• Awesome Fluent Functions
• Straightforward Structural Pattern Matching
• Performant Functional Try
• Articles on medium
• Introducting the Cyclops Monad API
• Easier Try with Cyclops
• 4 flavors of Java 8 Functions
• Memoise Functions in Java 8
• Strategy Pattern in Java 8
• Functional Feature Toggling
• Dependency injection using the Reader Monad in Java8
• Scheduling a Stream
• Neophytes guide to Java 8 : Welcome to the Future
• Deterministic and Non-Deterministic Finite State Machines with Cyclops

Old simple-react landing page

License

cyclops-react is licensed under the Apache 2.0 license.

http://www.apache.org/licenses/LICENSE-2.0#