Predicates (cyclops-react 1.0.3 API)

java.lang.Object
- com.aol.cyclops.util.function.Predicates

public class Predicates
extends java.lang.Object

Predicates for filtering and Pattern matching e.g.

  
  import static com.aol.cyclops.util.function.Predicates.greaterThan;
  
  Stream.of(1,2,3,100,200,300)
        .filter(greaterThan(10));
 
 //Stream[100,200,300]

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Predicates.PredicateBuilder1<T1>`
`static class`	`Predicates.PredicateBuilder2<T1,T2>`
`static class`	`Predicates.PredicateBuilder3<T1,T2,T3>`
`static class`	`Predicates.PredicateBuilder4<T1,T2,T3,T4>`
`static class`	`Predicates.PredicateBuilder5<T1,T2,T3,T4,T5>`

Field Summary

Fields
Modifier and Type Field and Description

static java.util.function.Predicate __
wildcard predicate

Fields
Modifier and Type	Field and Description
`static java.util.function.Predicate`	`__` wildcard predicate

Constructor Summary

Constructors
Constructor and Description

Predicates()

Constructors
Constructor and Description
`Predicates()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T1> java.util.function.Predicate<? super T1>`	`allOf(java.util.function.Predicate<? super T1>... preds)`
`static <Y> java.util.function.Predicate<Y>`	`any()`
`static <Y> java.util.function.Predicate<Y>`	`any(java.lang.Class<Y> c)` Match against any object that is an instance of supplied type
`static <T1> java.util.function.Predicate<? super T1>`	`anyOf(java.util.function.Predicate<? super T1>... preds)`
`static <T1,T2,T3> Predicates.PredicateBuilder1<T1>`	`decons(Matchable.MTuple1<java.util.function.Predicate<? super T1>> when)` Return a predicate builder for deconstructing a tuple.
`static <T1,T2,T3> Predicates.PredicateBuilder2<T1,T2>`	`decons(Matchable.MTuple2<java.util.function.Predicate<? super T1>,java.util.function.Predicate<? super T2>> when)` Return a predicate builder for deconstructing a tuple.
`static <T1,T2,T3> Predicates.PredicateBuilder3<T1,T2,T3>`	`decons(Matchable.MTuple3<java.util.function.Predicate<? super T1>,java.util.function.Predicate<? super T2>,java.util.function.Predicate<? super T3>> when)` Return a predicate builder for deconstructing a tuple.
`static <T1,T2,T3,T4> Predicates.PredicateBuilder4<T1,T2,T3,T4>`	`decons(Matchable.MTuple4<java.util.function.Predicate<? super T1>,java.util.function.Predicate<? super T2>,java.util.function.Predicate<? super T3>,java.util.function.Predicate<? super T4>> when)` Return a predicate builder for deconstructing a tuple.
`static <T1,T2,T3,T4,T5> Predicates.PredicateBuilder5<T1,T2,T3,T4,T5>`	`decons(Matchable.MTuple5<java.util.function.Predicate<? super T1>,java.util.function.Predicate<? super T2>,java.util.function.Predicate<? super T3>,java.util.function.Predicate<? super T4>,java.util.function.Predicate<? super T5>> when)` Return a predicate builder for deconstructing a tuple.
`static <T1> java.util.function.Predicate<java.lang.Iterable<? super T1>>`	`endsWith(T1... items)`
`static <V> java.util.function.Predicate<V>`	`eq(V value)` Check for universal equality (Object#equals) Filtering example
`static <T1 extends java.lang.Comparable<T1>> java.util.function.Predicate<? super T1>`	`equal(T1 v)`
`static <T1 extends java.lang.Comparable<T1>> java.util.function.Predicate<? super T1>`	`equals(T1 v)` Deprecated.
`static <V> java.util.function.Predicate<Value<? super V>>`	`eqv(Value<? super V> value)` Test for equivalence null eqv to absent, embedded value equivalency, non-values converted to values before testing .
`static <V> java.util.function.Predicate<V>`	`eqv2(Value<? super V> value)`
`static <V> java.util.function.Predicate<java.lang.Iterable<? super V>>`	`eqvIterable(java.lang.Iterable<? super V> iterable)`
`static <T1 extends java.lang.Comparable<T1>> java.util.function.Predicate<? super T1>`	`greaterThan(T1 v)`
`static <T1 extends java.lang.Comparable<T1>> java.util.function.Predicate<? super T1>`	`greaterThanOrEquals(T1 v)`
`static <V> java.util.function.Predicate<V>`	`has(V... values)` Recursively compose an Object without specifying a type
`static <T1> java.util.function.Predicate<java.util.Collection<? super T1>>`	`hasItems(java.util.Collection<T1> items)`
`static <T1> java.util.function.Predicate<java.util.Collection<? super T1>>`	`hasItems(java.util.stream.Stream<T1> items)`
`static <T1> java.util.function.Predicate<java.util.Collection<? super T1>>`	`hasItems(T1... items)`
`static <V> java.util.function.Predicate<V>`	`hasWhere(java.util.function.Predicate<V>... values)`
`static <T1> java.util.function.Predicate<T1>`	`in(T1... values)`
`static <T1> java.util.function.Predicate<? super T1>`	`instanceOf(java.lang.Class<?> clazz)`
`static <V> java.util.function.Predicate<V>`	`is(V... values)`
`static <V> java.util.function.Predicate<V>`	`isWhere(java.util.function.Predicate<V>... values)`
`static <T> java.util.function.Predicate<T>`	`iterablePresent()` `import static com.aol.cyclops.util.function.Predicates.valuePresent; ListX.of(Arrays.asList(),Arrays.asList(1),null) .filter(iterablePresent()); //ListX[List[1]]`
`static <T1 extends java.lang.Comparable<T1>> java.util.function.Predicate<? super T1>`	`lessThan(T1 v)`
`static <T1 extends java.lang.Comparable<T1>> java.util.function.Predicate<? super T1>`	`lessThanOrEquals(T1 v)`
`static <T1> java.util.function.Predicate<? super T1>`	`noneOf(java.util.function.Predicate<? super T1>... preds)`
`static <T1> java.util.function.Predicate<T1>`	`not(java.util.function.Predicate<T1> p)`
`static <T1> java.util.function.Predicate<? super T1>`	`nullValue()`
`static <T> java.util.function.Predicate<T>`	`optionalPresent()` `import static com.aol.cyclops.util.function.Predicates.optionalPresent; ListX.of(Optional.ofNullable(null),Optional.of(1),null) .filter(optionalPresent()); //ListX[Optional[1]]`
`static <T> java.util.function.Predicate<T>`	`p(java.util.function.Predicate<T> p)` Method for point-free Predicate definition (helps with lambda type inferencing) e.g.
`static <T> java.util.function.Predicate<T>`	`some()` `import static com.aol.cyclops.util.function.Predicates.some; ListX.of(Arrays.asList(),Arrays.asList(1),null, Optional.empty(),Maybe.none()) .filter(some()); //ListX[List[1]]`
`static <T> java.util.function.Predicate<T>`	`some(T value)` Alias for eq (results in nicer pattern matching dsl).
`static <T1> java.util.function.Predicate<java.lang.Iterable<? super T1>>`	`startsWith(T1... items)`
`static <T> com.aol.cyclops.internal.matcher2.ADTPredicateBuilder<T>`	`type(java.lang.Class<T> type)` Recursively decompose and match against case classes of specified type.
`static <T> java.util.function.Predicate<T>`	`valuePresent()` `import static com.aol.cyclops.util.function.Predicates.valuePresent; ListX.of(Maybe.ofNullable(null),Maybe.just(1),null) .filter(valuePresent()); //ListX[Maybe[1]]`
`static <T1> java.util.function.Predicate<? super T1>`	`xOf(int x, java.util.function.Predicate<? super T1>... preds)`

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

Field Detail

__

public static final java.util.function.Predicate __

wildcard predicate

  
  import static com.aol.cyclops.util.function.Predicates.__
 
  Eval<String> result = Matchables.listOfValues(1,new MyCase(4,5,6))
                                .matches(c->c.is(when(__,Predicates.has(4,5,6)),then("rec")),otherwise("n/a"));
        
        //Eval["rec"]

Constructor Detail
- Predicates
```
public Predicates()
```

Method Detail

p

public static <T> java.util.function.Predicate<T> p(java.util.function.Predicate<T> p)

Method for point-free Predicate definition (helps with lambda type inferencing) e.g.

  
    Predicate<Integer> pred = i->i>10;
   
    Predicates.<Integer>p(i->i>10).and(not(p(i<100));

Parameters:: p - Supplied predicate (normally as a lambda expression)
Returns:: Predicate

optionalPresent

public static <T> java.util.function.Predicate<T> optionalPresent()

  
      import static com.aol.cyclops.util.function.Predicates.optionalPresent;
      
      ListX.of(Optional.ofNullable(null),Optional.of(1),null)
            .filter(optionalPresent());
            
       //ListX[Optional[1]]

Returns:: A Predicate that checks if it's input is an Optional with a value

valuePresent

public static <T> java.util.function.Predicate<T> valuePresent()

  
      import static com.aol.cyclops.util.function.Predicates.valuePresent;
      
      ListX.of(Maybe.ofNullable(null),Maybe.just(1),null)
            .filter(valuePresent());
            
       //ListX[Maybe[1]]

Returns:: A Predicate that checks if it's input is a cyclops-react Value (which also contains a present value)

iterablePresent

public static <T> java.util.function.Predicate<T> iterablePresent()

  
      import static com.aol.cyclops.util.function.Predicates.valuePresent;
      
      ListX.of(Arrays.asList(),Arrays.asList(1),null)
            .filter(iterablePresent());
            
       //ListX[List[1]]

Returns:: A Predicate that checks if it's input is an Iterable with at least one value

some

public static <T> java.util.function.Predicate<T> some()

  
      import static com.aol.cyclops.util.function.Predicates.some;
      
      ListX.of(Arrays.asList(),Arrays.asList(1),null, Optional.empty(),Maybe.none())
            .filter(some());
            
       //ListX[List[1]]

Returns:: A predicate that checks for a values presence (i.e. for standard values that they are non-null, for Optionals that they are present, for cyclops-react values that they are present and for Iterables that they are non-null).

some

public static <T> java.util.function.Predicate<T> some(T value)

Alias for eq (results in nicer pattern matching dsl). Returns a Predicate that checks for equality between the supplied value and the predicates input parameter

  
 
 import static com.aol.cyclops.util.function.Predicates.some

 
 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[10]

Parameters:: value - Value to check for equality
Returns:: Predicate that checks for equality with the supplied value

any

public static final <Y> java.util.function.Predicate<Y> any()

Returns:: A Wildcard predicate, always returns true
See Also:: __

any

public static final <Y> java.util.function.Predicate<Y> any(java.lang.Class<Y> c)

Match against any object that is an instance of supplied type

  
  import static com.aol.cyclops.control.Matchable.whenGuard;
  import static com.aol.cyclops.control.Matchable.otherwise;
        import static com.aol.cyclops.control.Matchable.then;
  import static com.aol.cyclops.util.function.Predicates.eq;
  import static com.aol.cyclops.util.function.Predicates.any;
  
  Matchable.of(Arrays.asList(1,2,3))
                    .matches(c->c.is(whenGuard(eq(1),any(Integer.class),eq(4)),then("2")),otherwise("45"));

Parameters:: c - Class type to match against
Returns:: Predicate that mathes against type

type

public static <T> com.aol.cyclops.internal.matcher2.ADTPredicateBuilder<T> type(java.lang.Class<T> type)

Recursively decompose and match against case classes of specified type.

 
      List<String> result = of(new MyCase2(1,2),new MyCase2(3,4))
                                                      .patternMatch(
                                                              c->c.is(when(new MyCase2(1,2)),then("one"))
                                                                   .is(when(new MyCase2(3,4)),then("two"))
                                                                   .is(when(new MyCase2(3,5)),then("three"))
                                                                   .is(when(Predicates.type(MyCase.class).isGuard(3,4)),then(()->"two"))
                                                                   ,Matchable.otherwise("n/a")
                                                              )
                                                      .toListX();
            //Arrays.asList("one","two");

Parameters:: type - Classs type to decompose
Returns:: Predicate builder that can decompose classes of specified type

decons

public static <T1,T2,T3> Predicates.PredicateBuilder1<T1> decons(Matchable.MTuple1<java.util.function.Predicate<? super T1>> when)

Return a predicate builder for deconstructing a tuple. Any Object can be mapped to a nested hierarchy of Tuples, decons can be used to perform structural pattern matching over Java objects (once the Object to tuple mapping has been created). Supports structural pattern matching on a Tuple of a single field. decons deconstructs the Tuple so each field can be matched independently. Example : Given a class with § fields, we can provide a method to create a Matchable Tuple containing those fields

  
 static class Address{
            int house;
         
            
            
            public MTuple1<Integer> match(){
                return Matchables.supplier(()->house);
            }
        }

decons can be used to match against those fields directly

 
  Predicates.decons(when(10)).test(new Address(10).match()));
        //true

And in the pattern matching API

 
      String result =  new Customer("test",new Address(10))
                                .match()
                                .on$_2()
                                .matches(c->c.is(when(decons(when(10))),then("hello")), otherwise("miss"))
                                .get();
      
       //"hello"

Parameters:: when - 1 Predicates to match against (in the returned builder)
Returns:: Builder that matches values provided to it, with the Predicated provided to decons

decons

public static <T1,T2,T3> Predicates.PredicateBuilder2<T1,T2> decons(Matchable.MTuple2<java.util.function.Predicate<? super T1>,java.util.function.Predicate<? super T2>> when)

Return a predicate builder for deconstructing a tuple. Any Object can be mapped to a nested hierarchy of Tuples, decons can be used to perform structural pattern matching over Java objects (once the Object to tuple mapping has been created). Supports structural pattern matching on a Tuple of two fields. decons deconstructs the Tuple so each field can be matched independently. Example : Given a class with 2 fields, we can provide a method to create a Matchable Tuple containing those fields

  
 static class Address{
            int house;
            String street;
            
            
            public MTuple2<Integer,String> match(){
                return Matchables.supplier2(()->house,()->street);
            }
        }

decons can be used to match against those fields directly

 
  Predicates.decons(when(10,"hello")).test(new Address(10,"hello").match()));
        //true

And in the pattern matching API

 
      String result =  new Customer("test",new Address(10,"hello"))
                                .match()
                                .on$_2()
                                .matches(c->c.is(when(decons(when(10,"hello"))),then("hello")), otherwise("miss"))
                                .get();
      
       //"hello"

Parameters:: when - 2 Predicates to match against (in the returned builder)
Returns:: Builder that matches values provided to it, with the Predicated provided to decons

decons

public static <T1,T2,T3> Predicates.PredicateBuilder3<T1,T2,T3> decons(Matchable.MTuple3<java.util.function.Predicate<? super T1>,java.util.function.Predicate<? super T2>,java.util.function.Predicate<? super T3>> when)

Return a predicate builder for deconstructing a tuple. Any Object can be mapped to a nested hierarchy of Tuples, decons can be used to perform structural pattern matching over Java objects (once the Object to tuple mapping has been created). Supports structural pattern matching on a Tuple of three fields. decons deconstructs the Tuple so each field can be matched independently. Example : Given a class with 3 fields, we can provide a method to create a Matchable Tuple containing those fields

  
 static class Address{
            int house;
            String street;
            String city;
            
            public MTuple3<Integer,String,String> match(){
                return Matchables.supplier3(()->house,()->street,()->city);
            }
        }

decons can be used to match against those fields directly

 
  Predicates.decons(when(10,"hello","my city")).test(new Address(10,"hello","my city").match()));
        //true

And in the pattern matching API

 
      String result =  new Customer("test",new Address(10,"hello","my city"))
                                .match()
                                .on$_2()
                                .matches(c->c.is(when(decons(when(10,"hello","my city"))),then("hello")), otherwise("miss")).get();
      
       //"hello"

Parameters:: when - 3 Predicates to match against (in the returned builder)
Returns:: Builder that matches values provided to it, with the Predicated provided to decons

decons

public static <T1,T2,T3,T4> Predicates.PredicateBuilder4<T1,T2,T3,T4> decons(Matchable.MTuple4<java.util.function.Predicate<? super T1>,java.util.function.Predicate<? super T2>,java.util.function.Predicate<? super T3>,java.util.function.Predicate<? super T4>> when)

Return a predicate builder for deconstructing a tuple. Any Object can be mapped to a nested hierarchy of Tuples, decons can be used to perform structural pattern matching over Java objects (once the Object to tuple mapping has been created). Supports structural pattern matching on a Tuple of four fields. decons deconstructs the Tuple so each field can be matched independently. Example : Given a class with 4 fields, we can provide a method to create a Matchable Tuple containing those fields

  
 static class Address{
            int house;
            String street;
            String city;
            String country;
            
            public MTuple4<Integer,String,String> match(){
                return Matchables.supplier4(()->house,()->street,()->city,()->country);
            }
        }

decons can be used to match against those fields directly

 
  Predicates.decons(when(10,"hello","my city","Faroe Islands")).test(new Address(10,"hello","my city","Faroe Islands").match()));
        //true

And in the pattern matching API

 
      String result =  new Customer("test",new Address(10,"hello","my city","Faroe Islands"))
                                .match()
                                .on$_2()
                                .matches(c->c.is(when(decons(when(10,"hello","my city","Faroe Islands"))),then("hello")), otherwise("miss"))
                                .get();
      
       //"hello"

Parameters:: when - 4 Predicates to match against (in the returned builder)
Returns:: Builder that matches values provided to it, with the Predicated provided to decons

decons

public static <T1,T2,T3,T4,T5> Predicates.PredicateBuilder5<T1,T2,T3,T4,T5> decons(Matchable.MTuple5<java.util.function.Predicate<? super T1>,java.util.function.Predicate<? super T2>,java.util.function.Predicate<? super T3>,java.util.function.Predicate<? super T4>,java.util.function.Predicate<? super T5>> when)

Return a predicate builder for deconstructing a tuple. Any Object can be mapped to a nested hierarchy of Tuples, decons can be used to perform structural pattern matching over Java objects (once the Object to tuple mapping has been created). Supports structural pattern matching on a Tuple of five fields. decons deconstructs the Tuple so each field can be matched independently. Example : Given a class with 5 fields, we can provide a method to create a Matchable Tuple containing those fields

  
 static class Address{
            int house;
            String street;
            String city;
            String country;
            String zip;
            
            public MTuple5<Integer,String,String> match(){
                return Matchables.supplier5(()->house,()->street,()->city,()->country,()->zip);
            }
        }

decons can be used to match against those fields directly

 
  Predicates.decons(when(10,"hello","my city","Faroe Islands")).test(new Address(10,"hello","my city","Faroe Islands","CR25").match()));
        //true

And in the pattern matching API

 
      String result =  new Customer("test",new Address(10,"hello","my city","Faroe Islands","CR25"))
                                .match()
                                .on$_2()
                                .matches(c->c.is(when(decons(when(10,"hello","my city","Faroe Islands","CR25"))),then("hello")), otherwise("miss"))
                                .get();
      
       //"hello"

Parameters:: when - 5 Predicates to match against (in the returned builder)
Returns:: Builder that matches values provided to it, with the Predicated provided to decons

has

@SafeVarargs
public static <V> java.util.function.Predicate<V> has(V... values)

Recursively compose an Object without specifying a type

  
 return Matching.<Expression>whenValues().isType( (Add<Const,Mult> a)-> new Const(1))
    								.with(__,type(Mult.class).with(__,new Const(0)))
    			.whenValues().isType( (Add<Mult,Const> a)-> new Const(0)).with(type(Mult.class).with(__,new Const(0)),__)
    			.whenValues().isType( (Add<Add,Const> a)-> new Const(-100)).with(with(__,new Const(2)),__)
    			
    			
    			.apply(e).orElse(new Const(-1));

Parameters:: values - To match against
Returns:: Predicate builder that can decompose Case class and match against specified values

hasWhere

@SafeVarargs
public static <V> java.util.function.Predicate<V> hasWhere(java.util.function.Predicate<V>... values)

is

@SafeVarargs
public static <V> java.util.function.Predicate<V> is(V... values)

isWhere

@SafeVarargs
public static <V> java.util.function.Predicate<V> isWhere(java.util.function.Predicate<V>... values)

eq

public static <V> java.util.function.Predicate<V> eq(V value)

Check for universal equality (Object#equals) Filtering example

  
  ReactiveSeq.of(1,2,3).filter(anyOf(not(eq(2)),in(1,10,20)));
  //ReactiveSeq[1]

Pattern Matching Example

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

Parameters:: value - Value to check equality of
Returns:: Predicate for equality

eqv

public static <V> java.util.function.Predicate<Value<? super V>> eqv(Value<? super V> value)

Test for equivalence null eqv to absent, embedded value equivalency, non-values converted to values before testing .

  
 
   Stream.of(Maybe.of(2))
         .filter(eqv(Maybe.of(2)))
         .forEach(System.out::println);
   
   //Maybe[2]       
          
   Stream.of(2)
         .filter(eqv(Maybe.of(2)))
         .forEach(System.out::println);
         
   //2      (passes filter as equivalent to Maybe[2])

Parameters:: value -
Returns:

eqvIterable

public static <V> java.util.function.Predicate<java.lang.Iterable<? super V>> eqvIterable(java.lang.Iterable<? super V> iterable)

eqv2

public static <V> java.util.function.Predicate<V> eqv2(Value<? super V> value)

not

public static <T1> java.util.function.Predicate<T1> not(java.util.function.Predicate<T1> p)

in

@SafeVarargs
public static <T1> java.util.function.Predicate<T1> in(T1... values)

greaterThan

public static <T1 extends java.lang.Comparable<T1>> java.util.function.Predicate<? super T1> greaterThan(T1 v)

greaterThanOrEquals

public static <T1 extends java.lang.Comparable<T1>> java.util.function.Predicate<? super T1> greaterThanOrEquals(T1 v)

lessThan

public static <T1 extends java.lang.Comparable<T1>> java.util.function.Predicate<? super T1> lessThan(T1 v)

lessThanOrEquals

public static <T1 extends java.lang.Comparable<T1>> java.util.function.Predicate<? super T1> lessThanOrEquals(T1 v)

equal

public static <T1 extends java.lang.Comparable<T1>> java.util.function.Predicate<? super T1> equal(T1 v)

equals

@Deprecated
public static <T1 extends java.lang.Comparable<T1>> java.util.function.Predicate<? super T1> equals(T1 v)

Deprecated.

nullValue

public static <T1> java.util.function.Predicate<? super T1> nullValue()

hasItems

public static <T1> java.util.function.Predicate<java.util.Collection<? super T1>> hasItems(java.util.Collection<T1> items)

hasItems

public static <T1> java.util.function.Predicate<java.util.Collection<? super T1>> hasItems(java.util.stream.Stream<T1> items)

hasItems

@SafeVarargs
public static <T1> java.util.function.Predicate<java.util.Collection<? super T1>> hasItems(T1... items)

startsWith

@SafeVarargs
public static <T1> java.util.function.Predicate<java.lang.Iterable<? super T1>> startsWith(T1... items)

endsWith

@SafeVarargs
public static <T1> java.util.function.Predicate<java.lang.Iterable<? super T1>> endsWith(T1... items)

instanceOf

public static <T1> java.util.function.Predicate<? super T1> instanceOf(java.lang.Class<?> clazz)

allOf

@SafeVarargs
public static <T1> java.util.function.Predicate<? super T1> allOf(java.util.function.Predicate<? super T1>... preds)

anyOf

@SafeVarargs
public static <T1> java.util.function.Predicate<? super T1> anyOf(java.util.function.Predicate<? super T1>... preds)

noneOf

@SafeVarargs
public static <T1> java.util.function.Predicate<? super T1> noneOf(java.util.function.Predicate<? super T1>... preds)

xOf

@SafeVarargs
public static <T1> java.util.function.Predicate<? super T1> xOf(int x,
                                                                             java.util.function.Predicate<? super T1>... preds)

Class Predicates

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__

Constructor Detail

Predicates

Method Detail

p

optionalPresent

valuePresent

iterablePresent

some

some

any

any

type

decons

decons

decons

decons

decons

has

hasWhere

is

isWhere

eq

eqv

eqvIterable

eqv2

not

in

greaterThan

greaterThanOrEquals

lessThan

lessThanOrEquals

equal

equals

nullValue

hasItems

hasItems

hasItems

startsWith

endsWith

instanceOf

allOf

anyOf

noneOf

xOf