List<Integer> arrayList = new ArrayList<>();
arrayList.add(10);
arrayList.add(20);
arrayList.remove(10);

Vector<Integer> vector = Vector.of(10,20); //[10,20]
Vector<Integer> removed = vector.removeValue(10); //[20]

List<Integer> arrayList = new LinkedList<>();
arrayList.add(10);
arrayList.add(20);
arrayList.remove(10);

Seq<Integer> functionalLinkedList = Seq.of(10,20); //[10,20]
Seq<Integer> removed = functionalLinkedList.removeValue(10); //[20]

Stream<Integer> arrayList = Stream.of(1,2,3)
                                  .map(i->i*2);

LazySeq<Integer> arrayList = LazySeq.of(1,2,3)
                                    .map(i->i*2);

ReactiveSeq<Integer> arrayList = ReactiveSeq.of(1,2,3)
                                            .map(i->i*2);

Optional<Integer> opt = Optional.empty();
if(opt.isPresent())
   return opt.get();
else
   return 0;

...
//somewhere else
opt.get(); // Exception!

Option<Integer> opt = Option.none();

return opt.getOrElse(0);


Maybe<Integer> lazy = Maybe.fromLazyOption(()->Option.some(10));
//deferred Maybe[10]

Maybe<Integer> lazy = Maybe.fromLazyOption(()->Option.none());
//deferred Maybe[]

//reactive

Maybe<Integer> reactive = Maybe.fromFuture(future);
//async Maybe[future value]

CompletableMaybe<Integer> async = Maybe.maybe();
async.map(this::doWorkWhenDataArrives);
...
//on a separate thread
async.complete(value)

public String loadData(File f) throws IOException{

}


public Try<String,IOException> loadData(File f);

CompletableFuture<Result> future;
CompletableFuture<String> result = future.thenApply(this::process)
                                         .thenCompose(this::asyncProcess);


Future<Result> future;
Future<String> result = future.map(this::process)
                              .flatMap(this::asyncProcess);

Supplier<Integer> lazy = ()->calculateResult();

Eval<Integer> lazy = Eval.later(()->calculateResult()); //Memoizing / caching lazy call
Eval<String> chained = lazy.map(this::process)
                           .flatMap(this::lazyProcess);

Map<String,Integer> map = new j.u.HashMap<>();
map.put("key",10)
map.put("key2",200);
map.remove("key");

HashMap<String,Integer> map = cyclops.data.HashMap.of("key",10,"key2",200);
Immutable<String,Integer> removed = map.remove("key");

ReactiveSeq.range(0,1000)
           .map(this::processNext)
           .retry(this::mightFail)
           .forEach(System.out::println, System.err::println);

ReactiveSeq.range(0, 1000)
           .parallel(new ForkJoinPool(10),par -> par.map(this::parallelTransform))
           .map(this::sequentialTransform)
           .forEach(System.out::println,System.err::println,this::finished);

ReactiveSeq.of(1,2,3,4)
           .fanOut(s1->s1.filter(i->i%2==0).map(this::group1),
                   s2->s2.filter(i->i%2!=0).map(this::group2))
           .toListX();

ReactiveSeq.of(1,2,3,4)
           .parallelFanOutZipIn(s1->s1.filter(i->i%2==0).map(this::group1),
                                s2->s2.filter(i->i%2!=0).map(this::group2),(g1,g2)->process(g1,g2))
           .toListX();

Stream<Integer> stream = ReactiveSeq.range(0,1000)
                                    .map(i->i*2);

stream.forEach(System.out::println);
List<Integer> replayed = stream.collect(Collectors.toList());
stream.map(i->"hello  " + i)
      .forEach(System.out::println);

//Future
 Executor ex = Executors.newFixedThreadPool(1)
 Future<Integer> asyncResult = ReactiveSeq.of(1,2,3,4)
                                          .foldFuture(ex,s->s.reduce( 50,(acc,next) -> acc+next));

 asyncResult.peek(System.out::println)
            .map(this::processResult);

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

ReactiveSeq.generate(this::process)
           .map(data->data.isSuccess())
           .combine((a,b)-> a ? false : true, (a,b) -> a|b)
           .findFirst(); //terminating reduction on infinite data structure

Executor exec = Executors.newFixedThreadPool(1);
Either<Throwable,Integer> resultOrError =    Spouts.publishOn(ReactiveSeq.of(1,2,3,4,5),exec);
                                                   .combine((a, b) -> a < 5, Semigroups.intSum)
                                                   .findFirstOrError();

 Executor execA = Executors.newFixedThreadPool(1);
 Executor execB = Executors.newFixedThreadPool(1);
 Maybe<Integer> resultOrError =    Spouts.observeOn(ReactiveSeq.of(1,2,3,4,5),execA)
                                         .zip(Spouts.observeOn(ReactiveSeq.of(100,200),execB, (a,b)->a+b)
                                         .findOne();

ReactiveSeq.generate(suspend(times(10),s-> {
            System.out.println("Top level - should repeat after sequence completes!");
            return s.yield(1,
                           () -> s.yield(2),
                           () -> s.yield(3),
                           () -> s.yield(4));
                       }))
           .take(6)
           .printOut();

import static cyclops.streams.ReactorOperators.flux;
ReactiveSeq<List<Integer>> seq = Spouts.of(1,2,3)
                                       .map(i->i+1)
                                       .to(flux(o->o.buffer(10)));

ReactiveSeq<Integer> seq = Observables.of(1,2,3)
                                      .to(lift(new Observable.Operator<Integer,Integer>(){
                                              @Override
                                              public Subscriber<? super Integer> call(Subscriber<? super Integer> subscriber) {
                                                     return subscriber; // operator code
                                              }
                                       }))
                                       .map(i->i+1)