Cases (cyclops-pattern-matching 5.1.0 API)

java.lang.Object
- com.aol.cyclops.matcher.Cases<T,R,X>

Type Parameters:

T - Input type for predicate and function (action)

R - Return type for function (action) which is executed if the predicate tests positive

X - Type of Function - cyclops pattern matching builders use ActionWithReturn which is serialisable and retains type info

All Implemented Interfaces:

java.util.function.Function<T,java.util.Optional<R>>
```
public class Cases<T,R,X extends java.util.function.Function<T,R>>
extends java.lang.Object
implements java.util.function.Function<T,java.util.Optional<R>>
```
Represents an ordered list of pattern matching cases.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Cases<T,R,X>`	`append(int index, Case<T,R,X> pattern)` Append an individual case with supplied Cases inserted at index
`java.util.Optional<R>`	`apply(T t)`
`<T1,X> java.util.function.Function<T1,java.util.stream.Stream<X>>`	`asStreamFunction()` assertThat(Cases.of(Case.of(input->true,input->"hello")).asStreamFunction().apply(10).findFirst().get(),is("hello"));
`<T1,X> java.util.function.Function<T1,X>`	`asUnwrappedFunction()` assertThat(Cases.of(Case.of(input->true,input->"hello")).asUnwrappedFunction().apply(10),is("hello"));
`Cases<T,R,X>`	`filter(java.util.function.Predicate<Case<T,R,X>> predicate)` Filter the Cases with the supplied predicate
`Cases<T,R,X>`	`filterFunction(java.util.function.Predicate<java.util.function.Function<T,R>> predicate)` Filter the Cases with the supplied predicate
`Cases<T,R,X>`	`filterPredicate(java.util.function.Predicate<java.util.function.Predicate<T>> predicate)` Filter the Cases with the supplied predicate
`<T1,R1,X1 extends java.util.function.Function<T1,R1>> Cases<T,R,X>`	`flatMap(java.util.function.Function<Case<T,R,X>,Cases<T1,R1,X1>> mapper)` Expand each Case into a Cases object allowing 1:Many expansion of Cases
`<T1,R1,X1 extends java.util.function.Function<T1,R1>> Cases<T1,R1,X1>`	`flatMapAll(java.util.function.Function<org.pcollections.PStack<Case<T,R,X>>,Cases<T1,R1,X1>> mapper)` Map to a new Cases instance via a function that is provided all current Cases
`void`	`forEach(java.util.function.Consumer<Case<T,R,X>> consumer)` Iterate over each case
`org.pcollections.PStack<Case<T,R,X>>`	`get()`
`<T1,R1,X1 extends java.util.function.Function<T1,R1>> Cases<T,R,X>`	`map(java.util.function.Function<Case<T,R,X>,Case<T1,R1,X1>> mapper)` Map all Case instances present to a different value
`<R1> Cases<T,R,X>`	`mapFunction(java.util.function.Function<java.util.function.Function<T,R>,java.util.function.Function<T,R1>> actionMapper)` Map all the functions to another function
`Cases<T,R,X>`	`mapPredicate(java.util.function.Function<java.util.function.Predicate<T>,java.util.function.Predicate<T>> predicateMapper)` Map predicates for all Cases with the supplied function
`<R> java.util.Optional<R>`	`match(java.lang.Object... t)` Aggregates supplied objects into a List for matching against
`<R> java.util.Optional<R>`	`match(T t)`
`<R> java.util.concurrent.CompletableFuture<java.util.Optional<R>>`	`matchAsync(java.util.concurrent.Executor executor, java.lang.Object... t)` Aggregates supplied objects into a List for matching asynchronously against
`<R> java.util.stream.Stream<R>`	`matchFromStream(java.util.stream.Stream<T> s)` Each input element can generated a single matched value
`<R> java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>>`	`matchFromStreamAsync(java.util.concurrent.Executor executor, java.util.stream.Stream<T> s)` Execute matchFromStream asynchronously
`<R> java.util.stream.Stream<R>`	`matchMany(T t)` List<String> results = Cases.of(Case.of((Integer input)->10==input,input->"hello"), Case.of(input->11==input,input->"world"), Case.of(input->10==input,input->"woo!")) .<String>matchMany(10).toList(); assertThat(results.size(),is(2)); assertThat(results,hasItem("hello")); assertThat(results,hasItem("woo!"));
`<R> java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>>`	`matchManyAsync(java.util.concurrent.Executor executor, T t)` Match many asynchronously
`<R> java.util.stream.Stream<R>`	`matchManyFromStream(java.util.stream.Stream<T> s)` Each input element in the stream can generate multiple matched values
`<R> java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>>`	`matchManyFromStreamAsync(java.util.concurrent.Executor executor, java.util.stream.Stream s)` Asynchronously match against a Stream of data, on the supplied executor Each input element in the stream can generate multiple matched values
`Cases<T,R,X>`	`merge(Cases<T,R,X> patterns)` Merge two cases, with supplied Cases added after current Cases
`static <T,R,X extends java.util.function.Function<T,R>> Cases<T,R,X>`	`of(Case<T,R,X>... cazes)` Construct a Cases instance from an array Pattern Matching Cases Will execute sequentially when Match is called.
`static <T,R,X extends java.util.function.Function<T,R>> Cases<T,R,X>`	`ofList(java.util.List<Case<T,R,X>> cases)` Construct a Cases instance from a list of Pattern Matching Cases Will execute sequentially when Match is called.
`static <T,R,X extends java.util.function.Function<T,R>> Cases<T,R,X>`	`ofPStack(org.pcollections.PStack<Case<T,R,X>> cases)` Construct a Cases instance from a persistent stack of Pattern Matching Cases Will execute sequentially when Match is called.
`Cases<T,R,X>`	`parallel()` Default behaviour is to match sequentially
`Cases<T,R,X>`	`sequential()` This is the default behaviour, cases are matched sequentially when a matching function is called
`int`	`size()`
`<R> java.util.Optional<R>`	`unapply(com.aol.cyclops.lambda.api.Decomposable t)` Decomposes the supplied input via it's unapply method Provides a List to the Matcher of values to match on
`Two<java.util.stream.Stream<java.util.function.Predicate<T>>,java.util.stream.Stream<X>>`	`unzip()` `val cases = Cases.of(Case.of(input->true,input->"hello")); val unzipped = cases.unzip(); assertTrue(unzipped.v1.map(p->p.test(10)).allMatch(v->v)); assertTrue(unzipped.v2.map(fn->fn.apply(10)).allMatch(v->"hello".equals(v)));`
`static <T,R,X extends java.util.function.Function<T,R>> Cases<T,R,X>`	`zip(java.util.stream.Stream<java.util.function.Predicate<T>> predicates, java.util.stream.Stream<X> functions)` Zip two Streams into pattern Matching Cases

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.function.Function
andThen, compose, identity

Method Detail

get

public org.pcollections.PStack<Case<T,R,X>> get()

ofPStack
```
public static <T,R,X extends java.util.function.Function<T,R>> Cases<T,R,X> ofPStack(org.pcollections.PStack<Case<T,R,X>> cases)
```
Construct a Cases instance from a persistent stack of Pattern Matching Cases Will execute sequentially when Match is called.

Parameters:

cases - Persistent Stack of cases to build Cases from

Returns:

New Cases instance (sequential)

ofList
```
public static <T,R,X extends java.util.function.Function<T,R>> Cases<T,R,X> ofList(java.util.List<Case<T,R,X>> cases)
```
Construct a Cases instance from a list of Pattern Matching Cases Will execute sequentially when Match is called.

Parameters:

cases - Persistent Stack of cases to build Cases from

Returns:

New Cases instance (sequential)

of
```
public static <T,R,X extends java.util.function.Function<T,R>> Cases<T,R,X> of(Case<T,R,X>... cazes)
```
Construct a Cases instance from an array Pattern Matching Cases Will execute sequentially when Match is called.

Parameters:

cazes - Array of cases to build Cases instance from

Returns:

New Cases instance (sequential)

zip

public static <T,R,X extends java.util.function.Function<T,R>> Cases<T,R,X> zip(java.util.stream.Stream<java.util.function.Predicate<T>> predicates,
                                                                                java.util.stream.Stream<X> functions)

Zip two Streams into pattern Matching Cases

Parameters:: predicates - Stream of predicates; functions - Stream of functions
Returns:: Cases with predicates paired to functions

unzip

public Two<java.util.stream.Stream<java.util.function.Predicate<T>>,java.util.stream.Stream<X>> unzip()


 	val cases = Cases.of(Case.of(input->true,input->"hello"));
	val unzipped = cases.unzip();
	assertTrue(unzipped.v1.map(p->p.test(10)).allMatch(v->v));
	assertTrue(unzipped.v2.map(fn->fn.apply(10)).allMatch(v->"hello".equals(v)));

Returns:: unzipped Cases, with Predicates in one Stream and Functions in the other.

forEach
```
public void forEach(java.util.function.Consumer<Case<T,R,X>> consumer)
```
Iterate over each case

Parameters:

consumer - accept each case in turn

sequential
```
public Cases<T,R,X> sequential()
```
This is the default behaviour, cases are matched sequentially when a matching function is called

Returns:

New Cases object that will match sequentially

parallel
```
public Cases<T,R,X> parallel()
```
Default behaviour is to match sequentially

Returns:

A new cases object that will match in parallel

merge
```
public Cases<T,R,X> merge(Cases<T,R,X> patterns)
```
Merge two cases, with supplied Cases added after current Cases

Parameters:

patterns - Cases to merge to this set

Returns:

New merged Cases

See Also:

append(int, com.aol.cyclops.matcher.Case<T, R, X>)

filter

public Cases<T,R,X> filter(java.util.function.Predicate<Case<T,R,X>> predicate)

Filter the Cases with the supplied predicate

 cases = Cases.of(Case.of(input->true,input->"hello"),Case.of(input->false,input->"second"))
                                                                        .filter(p-> p.getPredicate().test(10));
                assertThat(cases.size(),is(1));

Parameters:: predicate - to filter out cases
Returns:: New Filtered Cases

filterPredicate

public Cases<T,R,X> filterPredicate(java.util.function.Predicate<java.util.function.Predicate<T>> predicate)

Filter the Cases with the supplied predicate

  Cases.of(Case.of(input->true,input->"hello"),Case.of(input->false,input->"second"))
                                .filterPredicate(p-> p.test(10));
                assertThat(cases.size(),is(1));

Parameters:: predicate - to filter out cases
Returns:: New Filtered Cases

filterFunction

public Cases<T,R,X> filterFunction(java.util.function.Predicate<java.util.function.Function<T,R>> predicate)

Filter the Cases with the supplied predicate

 
 cases = Cases.of(Case.of(input->true,input->"hello"),Case.of(input->false,input->"second"))
                        .filterFunction(fn-> fn.apply(10).equals("second"));
        assertThat(cases.size(),is(1));

Parameters:: predicate - to filter out cases
Returns:: New Filtered Cases

mapPredicate

public Cases<T,R,X> mapPredicate(java.util.function.Function<java.util.function.Predicate<T>,java.util.function.Predicate<T>> predicateMapper)

Map predicates for all Cases with the supplied function

 
 List results = Cases.of(Case.of(input->true,input->"hello"),Case.of(input->false,input->"second"))
                                        .mapPredicate(p->input->true).matchMany(10).collect(Collectors.toList());
        
        assertThat(results.size(),is(2));

Parameters:: predicateMapper - Function to map the predicates
Returns:: New Cases with mapped predicates

mapFunction

public <R1> Cases<T,R,X> mapFunction(java.util.function.Function<java.util.function.Function<T,R>,java.util.function.Function<T,R1>> actionMapper)

Map all the functions to another function

 
 List<String> results = Cases.of(Case.of(input->true,input->"hello"),Case.of(input->true,input->"second"))
                        .mapFunction(fn->input->"prefix_"+fn.apply(input)).<String>matchMany(10).collect(Collectors.toList());
        
        assertThat(results.size(),is(2));
        assertTrue(results.stream().allMatch(s->s.startsWith("prefix_")));
        assertTrue(results.stream().anyMatch(s->s.startsWith("prefix_hello")));
        assertTrue(results.stream().anyMatch(s->s.startsWith("prefix_second")));

Parameters:: actionMapper - Function to apply mapping
Returns:: New Cases with all functions mapped

map

public <T1,R1,X1 extends java.util.function.Function<T1,R1>> Cases<T,R,X> map(java.util.function.Function<Case<T,R,X>,Case<T1,R1,X1>> mapper)

Map all Case instances present to a different value

                List<String> results = Cases.of(Case.of(input->true,input->"hello"),Case.of(input->false,input->"second"))
                        .map(cse->Case.of(t->true,input->"prefix_"+cse.getAction().apply(input))).<String>matchMany(10).collect(Collectors.toList());
        
        assertThat(results.size(),is(2));
        assertTrue(results.stream().allMatch(s->s.startsWith("prefix_")));
        assertTrue(results.stream().anyMatch(s->s.startsWith("prefix_hello")));
        assertTrue(results.stream().anyMatch(s->s.startsWith("prefix_second")));

Parameters:: mapper - Function to map case instances
Returns:: New Cases with new Case instances

flatMap

public <T1,R1,X1 extends java.util.function.Function<T1,R1>> Cases<T,R,X> flatMap(java.util.function.Function<Case<T,R,X>,Cases<T1,R1,X1>> mapper)

Expand each Case into a Cases object allowing 1:Many expansion of Cases

                Case<Object,Integer,Function<Object,Integer>> cse = Case.of(input-> input instanceof Person, input -> ((Person)input).getAge());

         
        assertThat(Cases.of(cse).flatMap(c -> Cases.of(c.andThen(Case.of( age-> age<18,s->"minor")),
                                                                        c.andThen(Case.of( age->age>=18,s->"adult")))).match(new Person("bob",21)).get(),is("adult"));

Parameters:: mapper - Function to map Case instances to Cases instances
Returns:: New Cases aggregated from new mapped Cases instances

flatMapAll

public <T1,R1,X1 extends java.util.function.Function<T1,R1>> Cases<T1,R1,X1> flatMapAll(java.util.function.Function<org.pcollections.PStack<Case<T,R,X>>,Cases<T1,R1,X1>> mapper)

Map to a new Cases instance via a function that is provided all current Cases

 
  cases = Cases.of(Case.of(input->true,input->"hello"),Case.of(input->false,input->"second"))
                                                .flatMapAll(input-> Cases.of(input.plus(Case.of(in->true,in->"new"))));
                
                assertThat(cases.size(),is(3));

Parameters:: mapper - Function to map to a new Cases instance
Returns:: new Cases instance

append
```
public Cases<T,R,X> append(int index,
                           Case<T,R,X> pattern)
```
Append an individual case with supplied Cases inserted at index

Parameters:

index - to insert supplied cases in new Case instance

pattern - Cases to append / insert

Returns:

New Cases with current and supplied cases

See Also:

merge(com.aol.cyclops.matcher.Cases<T, R, X>)

size
```
public int size()
```
Returns:

number of cases

asUnwrappedFunction

public <T1,X> java.util.function.Function<T1,X> asUnwrappedFunction()

 
 
 assertThat(Cases.of(Case.of(input->true,input->"hello")).asUnwrappedFunction().apply(10),is("hello"));

Returns:: A function that when applied will return the 'unwrapped' result of matching. I.e. Optional#get will have been called.

asStreamFunction

public <T1,X> java.util.function.Function<T1,java.util.stream.Stream<X>> asStreamFunction()

 
 assertThat(Cases.of(Case.of(input->true,input->"hello")).asStreamFunction().apply(10).findFirst().get(),is("hello"));

Returns:: A function that returns the result of matching as a Stream

apply
```
public java.util.Optional<R> apply(T t)
```
Specified by:

apply in interface java.util.function.Function<T,java.util.Optional<R>>

matchManyFromStream

public <R> java.util.stream.Stream<R> matchManyFromStream(java.util.stream.Stream<T> s)

Each input element in the stream can generate multiple matched values

 
 List<String> results = Cases.of(Case.of((Integer input)->10==input,input->"hello"),
                                                                                Case.of(input->11==input,input->"world"))
                                                                        .<String>matchManyFromStream(Stream.of(1,10,11))
                                                                        .toList();
        
        assertThat(results.size(),is(2));
        assertThat(results,hasItem("hello"));
        assertThat(results,hasItem("world"));

Parameters:: s - Stream of data to match against (input to matcher)
Returns:: Stream of values from matched cases

matchManyFromStreamAsync

public <R> java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>> matchManyFromStreamAsync(java.util.concurrent.Executor executor,
                                                                                                       java.util.stream.Stream s)

Asynchronously match against a Stream of data, on the supplied executor Each input element in the stream can generate multiple matched values

 
 List<String> results = Cases.of(Case.of((Integer input)->10==input,input->"hello"),
                        Case.of(input->11==input,input->"world"))
                .<String>matchManyFromStreamAsync(ForkJoinPool.commonPool(),Stream.of(1,10,11))
                .join()
                .toList(); 

        assertThat(results.size(),is(2));
        assertThat(results,hasItem("hello"));
        assertThat(results,hasItem("world"));

Parameters:: executor - used to perform async task; s - Stream of data to match against (input to matcher)
Returns:: Stream of values from matched cases

matchMany

public <R> java.util.stream.Stream<R> matchMany(T t)

 List<String> results =  Cases.of(Case.of((Integer input)->10==input,input->"hello"),
                        Case.of(input->11==input,input->"world"),
                        Case.of(input->10==input,input->"woo!"))
                .<String>matchMany(10).toList();
        
        assertThat(results.size(),is(2));
        assertThat(results,hasItem("hello"));
        assertThat(results,hasItem("woo!"));

Parameters:: t - input to match against - can generate multiple values
Returns:: Stream of values from matched cases for the input

matchManyAsync

public <R> java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>> matchManyAsync(java.util.concurrent.Executor executor,
                                                                                             T t)

Match many asynchronously

 List<String> results =  Cases.of(Case.of((Integer input)->10==input,input->"hello"),
                        Case.of(input->11==input,input->"world"),
                        Case.of(input->10==input,input->"woo!"))
                .<String>matchManyAsync(ForkJoinPool.commonPool(),10).join().toList();
        
        assertThat(results.size(),is(2));
        assertThat(results,hasItem("hello"));
        assertThat(results,hasItem("woo!"));

Parameters:: executor - Executor to execute task asynchronously; t - input to match against - can generate multiple values
Returns:: Stream of values from matched cases for the input wrapped in a CompletableFuture

matchFromStream

public <R> java.util.stream.Stream<R> matchFromStream(java.util.stream.Stream<T> s)

Each input element can generated a single matched value

 
                List<String> results = Cases
                        .of(Case.of((Integer input) -> 10 == input, input -> "hello"),
                                        Case.of((Integer input) -> 10 == input, input -> "ignored"),
                                        Case.of(input -> 11 == input, input -> "world"))
                        .<String> matchFromStream(Stream.of(1, 11, 10)).toList(); 

        assertThat(results.size(), is(2));
        assertThat(results, hasItem("hello"));
        assertThat(results, hasItem("world"));

Parameters:: s - Stream of data to match against (input to matcher)
Returns:: Stream of matched values, one case per input value can match

matchFromStreamAsync

public <R> java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>> matchFromStreamAsync(java.util.concurrent.Executor executor,
                                                                                                   java.util.stream.Stream<T> s)

Execute matchFromStream asynchronously

Parameters:

executor - executor Executor to execute task asynchronously

s - Stream of data

Returns:

Results

See Also:

 List<String> results = Cases
			.of(Case.of((Integer input) -> 10 == input, input -> "hello"),
					Case.of((Integer input) -> 10 == input, input -> "ignored"),
					Case.of(input -> 11 == input, input -> "world"))
			.<String> matchFromStreamAsync(ForkJoinPool.commonPool(),Stream.of(1, 11, 10)).join().toList(); 
  
	assertThat(results.size(), is(2));
	assertThat(results, hasItem("hello"));
	assertThat(results, hasItem("world"));

match

public <R> java.util.Optional<R> match(java.lang.Object... t)

Aggregates supplied objects into a List for matching against

 assertThat(Cases.of(Case.of((List<Integer> input) -> input.size()==3, input -> "hello"),
                        Case.of((List<Integer> input) -> input.size()==2, input -> "ignored"),
                        Case.of((List<Integer> input) -> input.size()==1, input -> "world")).match(1,2,3).get(),is("hello"));

Parameters:: t - Array to match on
Returns:: Matched value wrapped in Optional

matchAsync

public <R> java.util.concurrent.CompletableFuture<java.util.Optional<R>> matchAsync(java.util.concurrent.Executor executor,
                                                                                    java.lang.Object... t)

Aggregates supplied objects into a List for matching asynchronously against

 assertThat(Cases.of(Case.of((List<Integer> input) -> input.size()==3, input -> "hello"),
                        Case.of((List<Integer> input) -> input.size()==2, input -> "ignored"),
                        Case.of((List<Integer> input) -> input.size()==1, input -> "world"))
                        .matchAsync(ForkJoinPool.commonPool(),1,2,3).join().get(),is("hello"));

Parameters:: executor - Executor to perform the async task; t - Array to match on
Returns:: Matched value wrapped in CompletableFuture & Optional

unapply

public <R> java.util.Optional<R> unapply(com.aol.cyclops.lambda.api.Decomposable t)

Decomposes the supplied input via it's unapply method Provides a List to the Matcher of values to match on

 assertThat(Cases.of(Case.of((List input) -> input.size()==3, input -> "hello"),
                        Case.of((List input) -> input.size()==2, input -> "ignored"),
                        Case.of((List input) -> input.size()==1, input -> "world"))
                        .unapply(new MyClass(1,"hello")).get(),is("ignored"));
                                        
        \@Value static class MyClass implements Decomposable{ int value; String name; }

Parameters:: t - Object to decompose and match on
Returns:: Matched result wrapped in an Optional

match
```
public <R> java.util.Optional<R> match(T t)
```
Parameters:

t - Object to match against supplied cases

Returns:

Value returned from matched case (if present) otherwise Optional.empty()

Class Cases<T,R,X extends java.util.function.Function<T,R>>

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.function.Function

Method Detail

get

ofPStack

ofList

of

zip

unzip

forEach

sequential

parallel

merge

filter

filterPredicate

filterFunction

mapPredicate

mapFunction

map

flatMap

flatMapAll

append

size

asUnwrappedFunction

asStreamFunction

apply

matchManyFromStream

matchManyFromStreamAsync

matchMany

matchManyAsync

matchFromStream

matchFromStreamAsync

match

matchAsync

unapply

match