Matchables (cyclops-react 1.0.2 API)

java.lang.Object
- com.aol.cyclops.Matchables

```
public class Matchables
extends java.lang.Object
```
This class contains static methods for Structural Pattern matching

Constructor Summary

Constructors
Constructor and Description

Matchables()

Constructors
Constructor and Description
`Matchables()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> Matchable.MXor<Queue<T>,Topic<T>>`	`adapter(Adapter<T> adapter)` Create a Pattern Matcher on cyclops-react adapter type (note this will only match on known types within the cyclops-react library)
`static <T> Matchable.MXor<AnyMValue<T>,AnyMSeq<T>>`	`anyM(AnyM<T> anyM)`
`static <T> Matchable.MXor<java.util.concurrent.BlockingQueue<T>,java.util.Queue<T>>`	`blocking(java.util.Queue<T> queue)` Pattern matching on the blocking / non-blocking nature of a Queue
`static Matchable.MatchableIterable<java.lang.Character>`	`chars(java.lang.CharSequence chars)` Pattern match on the characters in a character sequence
`static <T> Matchable.MXor<CompletableFutureTValue<T>,CompletableFutureTSeq<T>>`	`completableFutureT(CompletableFutureT<T> transformer)`
`static Matchable.MTuple3<java.lang.Integer,java.lang.Integer,java.lang.Integer>`	`dateDDMMYYYY(java.util.Date date)`
`static Matchable.MTuple3<java.lang.Integer,java.lang.Integer,java.lang.Integer>`	`dateHMS(java.util.Date date)` Structural pattern matching on a Date's hour minutes and seconds component
`static Matchable.MTuple3<java.lang.Integer,java.lang.Integer,java.lang.Integer>`	`dateMMDDYYYY(java.util.Date date)`
`static <T extends Decomposable> Matchable.MatchableObject<T>`	`decomposable(Decomposable o)` Create a new matchable that will match on the fields of the provided Decomposable
`static <T> Matchable.MXor<EvalTValue<T>,EvalTSeq<T>>`	`evalT(EvalT<T> transformer)`
`static <T1> Matchable.MXor<T1,java.lang.Throwable>`	`future(java.util.concurrent.CompletableFuture<T1> future)` Create a Pattern Matcher on CompletableFutures, specify success and failure event paths
`static <T1> Matchable.MXor<T1,java.lang.Throwable>`	`future(FutureW<T1> future)` Pattern Match on a FutureW handling success and failure cases differently
`static <T> Matchable.MXor<FutureWTValue<T>,FutureWTSeq<T>>`	`futureWT(FutureWT<T> transformer)`
`static <T> Matchable.MTuple2<Maybe<T>,ListX<T>>`	`headAndTail(java.util.Collection<T> col)`
`static <T> Matchable.MatchableIterable<T>`	`iterable(java.lang.Iterable<T> o)`
`static <K,V> ReactiveSeq<Matchable.MTuple2<K,V>>`	`keysAndValues(java.util.Map<K,V> map)`
`static Matchable.AutoCloseableMatchableIterable<java.lang.String>`	`lines(java.io.BufferedReader in)` Pattern match on the contents of a BufferedReader
`static Matchable.AutoCloseableMatchableIterable<java.lang.String>`	`lines(java.io.File f)` Pattern match on the contents of a File
`static Matchable.AutoCloseableMatchableIterable<java.lang.String>`	`lines(java.net.URL url)`
`static <T> Matchable.MatchableObject<T>`	`listOfValues(T... o)` Create a matchable that matches on the provided Objects
`static <T> Matchable.MXor<ListTValue<T>,ListTSeq<T>>`	`listT(ListT<T> transformer)`
`static Matchable.MTuple3<java.lang.Integer,java.lang.Integer,java.lang.Integer>`	`localDateDDMMYYYY(java.time.LocalDate date)`
`static Matchable.MTuple3<java.lang.Integer,java.lang.Integer,java.lang.Integer>`	`localDateMMDDYYYY(java.time.LocalDate date)`
`static Matchable.MTuple3<java.lang.Integer,java.lang.Integer,java.lang.Integer>`	`localTimeHMS(java.time.LocalTime time)`
`static <T1> Matchable.MTuple1<T1>`	`match(T1 v)` Match on a single value
`static <T1,T2> Matchable.MTuple2<T1,T2>`	`match2(T1 t1, T2 t2)` Match on a two values
`static <T1,T2,T3> Matchable.MTuple3<T1,T2,T3>`	`match3(T1 t1, T2 t2, T3 t3)` Match on three values
`static <T1,T2,T3,T4> Matchable.MTuple4<T1,T2,T3,T4>`	`match4(T1 t1, T2 t2, T3 t3, T4 t4)` Match on four values
`static <T> Matchable.MatchableOptional<T>`	`maybe(Maybe<T> opt)`
`static <T> Matchable.MatchableOptional<T>`	`maybe(Value<T> opt)`
`static <T> Matchable.MXor<MaybeTValue<T>,MaybeTSeq<T>>`	`maybeT(MaybeT<T> transformer)`
`static <T> Matchable.MatchableOptional<T>`	`optional(java.util.Optional<T> opt)`
`static <T> Matchable.MXor<OptionalTValue<T>,OptionalTSeq<T>>`	`optionalT(OptionalT<T> transformer)`
`static <T,R> Matchable.MXor<ReaderTValue<T,R>,ReaderTSeq<T,R>>`	`readerT(ReaderT<T,R> transformer)`
`static <T> Matchable.MXor<SetTValue<T>,SetTSeq<T>>`	`setT(SetT<T> transformer)`
`static <T> Matchable.MXor<StreamableTValue<T>,StreamableTSeq<T>>`	`streamableT(StreamableT<T> transformer)`
`static <T> Matchable.MXor<StreamTValue<T>,StreamTSeq<T>>`	`streamT(StreamT<T> transformer)`
`static <T1> Matchable.MTuple1<T1>`	`supplier(java.util.function.Supplier<T1> s1)` Match on a Supplier
`static <T1,T2> Matchable.MTuple2<T1,T2>`	`supplier2(java.util.function.Supplier<T1> s1, java.util.function.Supplier<T2> s2)`
`static <TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE> Matchable.MTuple3<T1,T2,T3>`	`supplier3(java.util.function.Supplier<T1> s1, java.util.function.Supplier<T2> s2, java.util.function.Supplier<T3> s3)`
`static <TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE,T4 extends TYPE> Matchable.MTuple4<T1,T2,T3,T4>`	`supplier4(java.util.function.Supplier<T1> s1, java.util.function.Supplier<T2> s2, java.util.function.Supplier<T3> s3, java.util.function.Supplier<T4> s4)`
`static <TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE,T4 extends TYPE,T5 extends TYPE> Matchable.MTuple5<T1,T2,T3,T4,T5>`	`supplier5(java.util.function.Supplier<T1> s1, java.util.function.Supplier<T2> s2, java.util.function.Supplier<T3> s3, java.util.function.Supplier<T4> s4, java.util.function.Supplier<T5> s5)`
`static <X extends java.lang.Throwable> Matchable.MTuple4<java.lang.Class,java.lang.String,java.lang.Throwable,Matchable.MatchableIterable<java.lang.StackTraceElement>>`	`throwable(X t)`
`static <T1,X extends java.lang.Throwable> Matchable.MXor<T1,X>`	`tryMatch(Try<T1,X> match)`
`static <T,X extends java.lang.Throwable> Matchable.MXor<TryTValue<T,X>,TryTSeq<T,X>>`	`tryT(TryT<T,X> transformer)`
`static <T1> Matchable.MTuple1<T1>`	`tuple1(org.jooq.lambda.tuple.Tuple1<T1> t2)` Match on a tuple
`static <T1,T2> Matchable.MTuple2<T1,T2>`	`tuple2(org.jooq.lambda.tuple.Tuple2<T1,T2> t2)`
`static <TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE> Matchable.MTuple3<T1,T2,T3>`	`tuple3(org.jooq.lambda.tuple.Tuple3<T1,T2,T3> t3)`
`static <TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE,T4 extends TYPE> Matchable.MTuple4<T1,T2,T3,T4>`	`tuple4(org.jooq.lambda.tuple.Tuple4<T1,T2,T3,T4> t4)`
`static <TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE,T4 extends TYPE,T5 extends TYPE> Matchable.MTuple5<T1,T2,T3,T4,T5>`	`tuple5(org.jooq.lambda.tuple.Tuple5<T1,T2,T3,T4,T5> t5)`
`static Matchable.MTuple5<java.lang.String,java.lang.String,java.lang.Integer,java.lang.String,java.lang.String>`	`url(java.net.URL url)` Break an URL down into protocol, host, port, path, query
`static Matchable.MatchableIterable<java.lang.String>`	`words(java.lang.CharSequence seq)` Pattern match on the words (space separated) in a character sequence
`static Matchable.MatchableIterable<java.lang.String>`	`words(java.lang.CharSequence seq, java.lang.String separator)` Pattern match on the words in a character sequence
`static <ST,PT> Matchable.MXor<ST,PT>`	`xor(Xor<ST,PT> xor)` Pattern match on an Xor type
`static <ST,T> Matchable.MXor<XorTValue<ST,T>,XorTSeq<ST,T>>`	`xorT(XorT<ST,T> transformer)`

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

Constructor Detail
- Matchables
```
public Matchables()
```

Method Detail

match

public static <T1> Matchable.MTuple1<T1> match(T1 v)

Match on a single value

  
 import static com.aol.cyclops.util.function.Predicates.greaterThan;
 import static com.aol.cyclops.control.Matchable.when;
 
 Matchables.match(100)
                 .matches(c->c.is(when(greaterThan(50)), ()->"large"), ()->"small");
       
       //Eval["large"]

Parameters:: v - Value to match on
Returns:: Structural Pattern matching API for that value (encompasing presence and absence / null)

match2

public static <T1,T2> Matchable.MTuple2<T1,T2> match2(T1 t1,
                                                      T2 t2)

Match on a two values

  
 import static com.aol.cyclops.util.function.Predicates.greaterThan;
 import static com.aol.cyclops.control.Matchable.when;
 
        Matchables.match2(100,2)
                  .matches(c->c.is(when(Predicates.greaterThan(50),Predicates.lessThan(10)), ()->"large and small"), 
                  ()->"not large and small");
       //Eval["large and small"]

Parameters:: t1 - 1st Value to match on; t2 - 2nd Value to match on
Returns:: Structural Pattern matching API for those values

match3

public static <T1,T2,T3> Matchable.MTuple3<T1,T2,T3> match3(T1 t1,
                                                            T2 t2,
                                                            T3 t3)

Match on three values

  
 
 Matchables.match3(100,2,1000)
                .matches(c->c.is(when(Predicates.greaterThan(50),Predicates.lessThan(10),Predicates.greaterThan(500)), ()->"large and small and huge"),
                         ()->"not large and small")
                         
        //"large and small and huge"

Parameters:: t1 - 1st Value to match on; t2 - 2nd Value to match on; t3 - 3rd Value to match on
Returns:: Structural Pattern matching API for those values

match4

public static <T1,T2,T3,T4> Matchable.MTuple4<T1,T2,T3,T4> match4(T1 t1,
                                                                  T2 t2,
                                                                  T3 t3,
                                                                  T4 t4)

Match on four values

 
 
 Matchables.match4(100,2,1000,1)
                .matches(c->c.is(when(Predicates.greaterThan(50),
                                       Predicates.lessThan(10),
                                       Predicates.greaterThan(500),
                                       Predicates.lessThan(2)), ()->"large and small and huge and tiny"), ()->"not large and small").get();
       
       //"large and small and huge and tiny"

Parameters:: t1 - 1st Value to match on; t2 - 2nd Value to match on; t3 - 3rd Value to match on; t4 - 4th Value to match on
Returns:: Structural Pattern matching API for those values

supplier

public static <T1> Matchable.MTuple1<T1> supplier(java.util.function.Supplier<T1> s1)

Match on a Supplier

 
 import static com.aol.cyclops.util.function.Predicates.greaterThan;
 import static com.aol.cyclops.control.Matchable.when;
 
 Matchables.supplier(() -> 100)
                                 .matches(c->c.is(when(greaterThan(50)), ()->"large"), ()->"small")
                                 .get()
                                  
      //large

Parameters:: s1 - Supplier to generate a value to match on
Returns:: Structural Pattern matching API for Supplier (encompasing presence and absence / null)

tuple1

public static <T1> Matchable.MTuple1<T1> tuple1(org.jooq.lambda.tuple.Tuple1<T1> t2)

Match on a tuple

 
 import static com.aol.cyclops.util.function.Predicates.greaterThan;
 import static com.aol.cyclops.control.Matchable.when;
 
 Matchables.tuple1(Tuple.tuple(100))
                                 .matches(c->c.is(when(greaterThan(50)), ()->"large"), ()->"small")
                                 .get()
                                  
      //large

Parameters:: t2 - Tuple1 to match on
Returns:: Structural Pattern matching API for Tuple

supplier2

public static <T1,T2> Matchable.MTuple2<T1,T2> supplier2(java.util.function.Supplier<T1> s1,
                                                         java.util.function.Supplier<T2> s2)

tuple2

public static <T1,T2> Matchable.MTuple2<T1,T2> tuple2(org.jooq.lambda.tuple.Tuple2<T1,T2> t2)

tuple3

public static <TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE> Matchable.MTuple3<T1,T2,T3> tuple3(org.jooq.lambda.tuple.Tuple3<T1,T2,T3> t3)

supplier3

public static <TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE> Matchable.MTuple3<T1,T2,T3> supplier3(java.util.function.Supplier<T1> s1,
                                                                                                           java.util.function.Supplier<T2> s2,
                                                                                                           java.util.function.Supplier<T3> s3)

tuple4

public static <TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE,T4 extends TYPE> Matchable.MTuple4<T1,T2,T3,T4> tuple4(org.jooq.lambda.tuple.Tuple4<T1,T2,T3,T4> t4)

supplier4

public static <TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE,T4 extends TYPE> Matchable.MTuple4<T1,T2,T3,T4> supplier4(java.util.function.Supplier<T1> s1,
                                                                                                                              java.util.function.Supplier<T2> s2,
                                                                                                                              java.util.function.Supplier<T3> s3,
                                                                                                                              java.util.function.Supplier<T4> s4)

tuple5

public static <TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE,T4 extends TYPE,T5 extends TYPE> Matchable.MTuple5<T1,T2,T3,T4,T5> tuple5(org.jooq.lambda.tuple.Tuple5<T1,T2,T3,T4,T5> t5)

supplier5

public static <TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE,T4 extends TYPE,T5 extends TYPE> Matchable.MTuple5<T1,T2,T3,T4,T5> supplier5(java.util.function.Supplier<T1> s1,
                                                                                                                                                 java.util.function.Supplier<T2> s2,
                                                                                                                                                 java.util.function.Supplier<T3> s3,
                                                                                                                                                 java.util.function.Supplier<T4> s4,
                                                                                                                                                 java.util.function.Supplier<T5> s5)

iterable

public static <T> Matchable.MatchableIterable<T> iterable(java.lang.Iterable<T> o)

decomposable
```
public static <T extends Decomposable> Matchable.MatchableObject<T> decomposable(Decomposable o)
```
Create a new matchable that will match on the fields of the provided Decomposable

Parameters:

o - Decomposable to match on it's fields

Returns:

new Matchable

listOfValues

public static <T> Matchable.MatchableObject<T> listOfValues(T... o)

Create a matchable that matches on the provided Objects

  
 Eval<String> result = Matchables.listOfValues(1,2)
                                        .matches(c->c.has(when(1,3),then("2"))
                                                     .has(when(1,2),then("3")),otherwise("8"));
        
       //Eval["3"];

Parameters:: o - Objects to match on
Returns:: new Matchable

adapter

public static <T> Matchable.MXor<Queue<T>,Topic<T>> adapter(Adapter<T> adapter)

Create a Pattern Matcher on cyclops-react adapter type (note this will only match on known types within the cyclops-react library)

  
     Adapter<Integer> adapter = QueueFactories.<Integer>unboundedQueue()
                                              .build();
                                              
     String result =   Matchables.adapter(adapter)
                                       .visit(queue->"we have a queue",topic->"we have a topic");
                      
    //"we have a queue"

Parameters:: adapter - Adapter to match on
Returns:: Structural pattern matcher for Adapter types.

future

public static <T1> Matchable.MXor<T1,java.lang.Throwable> future(java.util.concurrent.CompletableFuture<T1> future)

Create a Pattern Matcher on CompletableFutures, specify success and failure event paths

  
  Eval<Integer> result = Matchables.future(CompletableFuture.completedFuture(10))
                                         .matches(c-> 
                                                     c.is( when(some(10)), then(20)),  //success
                                                      
                                                     c->c.is(when(instanceOf(RuntimeException.class)), then(2)), //failure
                                                      
                                                     otherwise(3) //no match
                                                 );
        
        //Eval[20]

Parameters:: future - Future to match on
Returns:: Pattern Matcher for CompletableFutures

future

public static <T1> Matchable.MXor<T1,java.lang.Throwable> future(FutureW<T1> future)

Pattern Match on a FutureW handling success and failure cases differently

  
  Eval<Integer> result = Matchables.future(FutureW.ofResult(1))
                                         .matches(c-> c.is( when(some(1)), then(10)), 
                                                  c->c.is(when(instanceOf(RuntimeException.class)), then(2)),
                                                  otherwise(3));
        
        //Eval.now[10]
 
  Eval<Integer> result = Matchables.future(FutureW.ofError(new RuntimeException()))
                                         .matches(c-> c.is( when(some(10)), then(2)), 
                                                  c->c.is(when(instanceOf(RuntimeException.class)), then(2)),
                                                  otherwise(3));
        
       //Eval.now(2)

Parameters:: future - Future to match on
Returns:: Pattern Matcher for Futures

tryMatch

public static <T1,X extends java.lang.Throwable> Matchable.MXor<T1,X> tryMatch(Try<T1,X> match)

maybe

public static <T> Matchable.MatchableOptional<T> maybe(Maybe<T> opt)

maybe

public static <T> Matchable.MatchableOptional<T> maybe(Value<T> opt)

optional

public static <T> Matchable.MatchableOptional<T> optional(java.util.Optional<T> opt)

anyM

public static <T> Matchable.MXor<AnyMValue<T>,AnyMSeq<T>> anyM(AnyM<T> anyM)

maybeT

public static <T> Matchable.MXor<MaybeTValue<T>,MaybeTSeq<T>> maybeT(MaybeT<T> transformer)

optionalT

public static <T> Matchable.MXor<OptionalTValue<T>,OptionalTSeq<T>> optionalT(OptionalT<T> transformer)

evalT

public static <T> Matchable.MXor<EvalTValue<T>,EvalTSeq<T>> evalT(EvalT<T> transformer)

xorT

public static <ST,T> Matchable.MXor<XorTValue<ST,T>,XorTSeq<ST,T>> xorT(XorT<ST,T> transformer)

tryT

public static <T,X extends java.lang.Throwable> Matchable.MXor<TryTValue<T,X>,TryTSeq<T,X>> tryT(TryT<T,X> transformer)

futureWT

public static <T> Matchable.MXor<FutureWTValue<T>,FutureWTSeq<T>> futureWT(FutureWT<T> transformer)

completableFutureT

public static <T> Matchable.MXor<CompletableFutureTValue<T>,CompletableFutureTSeq<T>> completableFutureT(CompletableFutureT<T> transformer)

listT

public static <T> Matchable.MXor<ListTValue<T>,ListTSeq<T>> listT(ListT<T> transformer)

setT

public static <T> Matchable.MXor<SetTValue<T>,SetTSeq<T>> setT(SetT<T> transformer)

streamT

public static <T> Matchable.MXor<StreamTValue<T>,StreamTSeq<T>> streamT(StreamT<T> transformer)

streamableT

public static <T> Matchable.MXor<StreamableTValue<T>,StreamableTSeq<T>> streamableT(StreamableT<T> transformer)

readerT

public static <T,R> Matchable.MXor<ReaderTValue<T,R>,ReaderTSeq<T,R>> readerT(ReaderT<T,R> transformer)

throwable

public static <X extends java.lang.Throwable> Matchable.MTuple4<java.lang.Class,java.lang.String,java.lang.Throwable,Matchable.MatchableIterable<java.lang.StackTraceElement>> throwable(X t)

url

public static Matchable.MTuple5<java.lang.String,java.lang.String,java.lang.Integer,java.lang.String,java.lang.String> url(java.net.URL url)

Break an URL down into protocol, host, port, path, query

  
 Eval<String> url = Matchables.url(new URL("http://www.aol.com/path?q=hello"))
                                     .on$12_45()
                                     .matches(c->c.is(when("http","www.aol.com","/path","q=hello"), then("correct")),otherwise("miss"));
        
        //Eval["correct"]

Parameters:: url - URL to pattern match on
Returns:: Pattern Matcher for URLs

lines

public static Matchable.AutoCloseableMatchableIterable<java.lang.String> lines(java.io.BufferedReader in)

Pattern match on the contents of a BufferedReader

  
  String result = Matchables.lines(new BufferedReader(new FileReader(new File(file))))
                                  .on$12___()
                                  .matches(c->c.is(when("hello","world"),then("correct")), otherwise("miss")).get();
        
        //"correct"

Parameters:: in - BufferedReader to match on
Returns:

lines

public static Matchable.AutoCloseableMatchableIterable<java.lang.String> lines(java.net.URL url)

lines

public static Matchable.AutoCloseableMatchableIterable<java.lang.String> lines(java.io.File f)

Pattern match on the contents of a File

  
 String result = Matchables.lines(new File(file))
                                 .on$12___()
                                 .matches(c->c.is(when("hello","world"),then("correct")), otherwise("miss")).get();

Parameters:: f - File to match against
Returns:: Matcher

words

public static Matchable.MatchableIterable<java.lang.String> words(java.lang.CharSequence seq)

Pattern match on the words (space separated) in a character sequence

  
  Matchables.words("hello world")
                                  .matches(c->c.has(when("hello","world"), then("correct")), otherwise("miss"))
                                  .get();
  //"correct

Parameters:: seq - Character Sequence to match against
Returns:: Pattern matching for words based on input sequence

words

public static Matchable.MatchableIterable<java.lang.String> words(java.lang.CharSequence seq,
                                                                  java.lang.String separator)

Pattern match on the words in a character sequence

  
  Matchables.words("hello,world",",")
                                  .matches(c->c.has(when("hello","world","boo!"), then("incorrect")), otherwise("miss"))
                                  .get();
  //"miss"

Parameters:: seq - Character Sequence to match against; separator - Word separator
Returns:: Pattern matching for words based on input sequence

chars

public static Matchable.MatchableIterable<java.lang.Character> chars(java.lang.CharSequence chars)

Pattern match on the characters in a character sequence

  
  String result =   Matchables.chars("hello,world")
                                    .matches(c->c.has(when('h','e','l','l','o'), then("startsWith")), otherwise("miss"))
                                    .get();
      
       //"startsWith"

Parameters:: chars - Characters to match on
Returns:: MatchableIterable for pattern matching on the characters in the sequence

xor

public static <ST,PT> Matchable.MXor<ST,PT> xor(Xor<ST,PT> xor)

Pattern match on an Xor type

  
 
  Xor<Exception, String> xor = Xor.primary("hello world");

        Eval<String> result = Matchables.xor(xor)
                                        .matches(c -> c.is(when(instanceOf(RuntimeException.class)), () -> "runtime"),
                                                 c -> c.is(when(equal("hello world")), () -> "hello back"), () -> "unknown");

       //Eval["hello back"]

Parameters:: xor - Xor to match on
Returns:: Pattern matcher for Xor

headAndTail

public static <T> Matchable.MTuple2<Maybe<T>,ListX<T>> headAndTail(java.util.Collection<T> col)

keysAndValues

public static <K,V> ReactiveSeq<Matchable.MTuple2<K,V>> keysAndValues(java.util.Map<K,V> map)

dateDDMMYYYY

public static Matchable.MTuple3<java.lang.Integer,java.lang.Integer,java.lang.Integer> dateDDMMYYYY(java.util.Date date)

dateMMDDYYYY

public static Matchable.MTuple3<java.lang.Integer,java.lang.Integer,java.lang.Integer> dateMMDDYYYY(java.util.Date date)

localDateDDMMYYYY

public static Matchable.MTuple3<java.lang.Integer,java.lang.Integer,java.lang.Integer> localDateDDMMYYYY(java.time.LocalDate date)

localDateMMDDYYYY

public static Matchable.MTuple3<java.lang.Integer,java.lang.Integer,java.lang.Integer> localDateMMDDYYYY(java.time.LocalDate date)

dateHMS
```
public static Matchable.MTuple3<java.lang.Integer,java.lang.Integer,java.lang.Integer> dateHMS(java.util.Date date)
```
Structural pattern matching on a Date's hour minutes and seconds component

Parameters:

date - Date to match on

Returns:

Structural pattern matcher for hours / minutes / seconds

localTimeHMS

public static Matchable.MTuple3<java.lang.Integer,java.lang.Integer,java.lang.Integer> localTimeHMS(java.time.LocalTime time)

blocking

public static <T> Matchable.MXor<java.util.concurrent.BlockingQueue<T>,java.util.Queue<T>> blocking(java.util.Queue<T> queue)

Pattern matching on the blocking / non-blocking nature of a Queue

  
  Matchables.blocking(new ManyToManyConcurrentArrayQueue(10))
                  .visit(c->"blocking", c->"not")
         //"not"
    
   
       Matchables.blocking(new LinkedBlockingQueue(10))
                 .visit(c->"blocking", c->"not")
        //"blocking

Parameters:: queue - Queue to pattern match on
Returns:: Pattern matchier on the blocking / non-blocking nature of the supplied Queue

Class Matchables

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Matchables

Method Detail

match

match2

match3

match4

supplier

tuple1

supplier2

tuple2

tuple3

supplier3

tuple4

supplier4

tuple5

supplier5

iterable

decomposable

listOfValues

adapter

future

future

tryMatch

maybe

maybe

optional

anyM

maybeT

optionalT

evalT

xorT

tryT

futureWT

completableFutureT

listT

setT

streamT

streamableT

readerT

throwable

url

lines

lines

lines

words

words

chars

xor

headAndTail

keysAndValues

dateDDMMYYYY

dateMMDDYYYY

localDateDDMMYYYY

localDateMMDDYYYY

dateHMS

localTimeHMS

blocking