com.aol.cyclops.internal.matcher2

Interface Case<T,R>

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 Known Implementing Classes:

ActiveCase, EmptyCase

public interface Case<T,R>

An interface / trait for building functionally compositional pattern matching cases Consists of a Predicate and a Function When match is called, if the predicate holds the function is executed

Field Summary

Fields

Modifier and Type	Field and Description
static Case	empty

Method Summary

Modifier and Type	Method and Description
static <T,R,X extends java.util.function.Function<T,R>> Case<T,R>	empty()
org.jooq.lambda.tuple.Tuple2<java.util.function.Predicate<? super T>,java.util.function.Function<? super T,? extends R>>	get()
default java.util.function.Function<? super T,? extends R>	getAction()
default java.util.function.Predicate<? super T>	getPredicate()
boolean	isEmpty()
default boolean	isNotEmpty()
default java.util.Optional<R>	match(T value) Match against the supplied value.
default java.util.concurrent.CompletableFuture<java.util.Optional<R>>	matchAsync(java.util.concurrent.Executor executor, T value) Similar to Match, but executed asynchonously on supplied Executor.
static <T,R> Case<T,R>	of(java.util.function.Predicate<? super T> predicate, java.util.function.Function<? super T,? extends R> action) Construct an instance of Case from supplied predicate and action
static <T,R> Case<T,R>	of(org.jooq.lambda.tuple.Tuple2<java.util.function.Predicate<? super T>,java.util.function.Function<? super T,? extends R>> pattern) Construct an instance of Case from supplied Tuple of predicate and action

Field Detail

empty

static final Case empty

Method Detail

isEmpty

boolean isEmpty()

Returns:

true is this an 'empty' case

get

org.jooq.lambda.tuple.Tuple2<java.util.function.Predicate<? super T>,java.util.function.Function<? super T,? extends R>> get()

Returns:

Pattern for this case

getPredicate

default java.util.function.Predicate<? super T> getPredicate()

Returns:

Predicate for this case

getAction

default java.util.function.Function<? super T,? extends R> getAction()

Returns:

Action (Function) for this case

isNotEmpty

default boolean isNotEmpty()

Returns:

true if this not an EmptyCase

match

default java.util.Optional<R> match(T value)

Match against the supplied value. Value will be passed into the current predicate If it passes / holds, value will be passed to the current function. The result of function application will be returned wrapped in an Optional. If the predicate does not hold, Optional.empty() is returned.

Parameters:

value - To match against

Returns:

Optional.empty if doesn't match, result of the application of current function if it does wrapped in an Optional

matchAsync

default java.util.concurrent.CompletableFuture<java.util.Optional<R>> matchAsync(java.util.concurrent.Executor executor,
                                                                                 T value)

Similar to Match, but executed asynchonously on supplied Executor.

Parameters:

executor - Executor to execute matching on

value - Value to match against

Returns:

A CompletableFuture that will eventual contain an Optional.empty if doesn't match, result of the application of current function if it does

See Also:

Match against the supplied value. Value will be passed into the current predicate If it passes / holds, value will be passed to the current function. The result of function application will be returned wrapped in an Optional. If the predicate does not hold, Optional.empty() is returned.

of

static <T,R> Case<T,R> of(java.util.function.Predicate<? super T> predicate,
                          java.util.function.Function<? super T,? extends R> action)

Construct an instance of Case from supplied predicate and action

Parameters:

predicate - That will be used to match

action - Function that is executed on succesful match

Returns:

New Case instance

of

static <T,R> Case<T,R> of(org.jooq.lambda.tuple.Tuple2<java.util.function.Predicate<? super T>,java.util.function.Function<? super T,? extends R>> pattern)

Construct an instance of Case from supplied Tuple of predicate and action

Parameters:

pattern - containing the predicate that will be used to match and the function that is executed on succesful match

Returns:

New Case instance

empty

static <T,R,X extends java.util.function.Function<T,R>> Case<T,R> empty()

Returns:

EmptyCase