x

java.lang.Object
- com.wantedtech.common.xpresso.x

```
public class x
extends java.lang.Object
```
This is the entry point of xpresso. x contains all important high-level static utility methods of the library. It is recommended to start exploring the Javadoc from here. The class x can be seen as a container of the highest-level methods of xpresso, similar to Python's __builtin__ namespace.

Since:

0.01

Author:

Andriy Burkov

Field Summary

Fields
Modifier and Type	Field and Description
`static Assert`	`Assert` Contains an instance of `Assert` class object that has useful assertion methods.
`static Function<java.lang.Object,java.lang.Object>`	`doNothing` A `Function` that takes any object as input and returns the same object.
`static Predicate<java.lang.Object>`	`empty` A `Predicate` that only true if `len(Object)` returns 0 for the input value.
`static Function<java.lang.Object,java.lang.String>`	`escape` A synonym to `x.String.escape`
`static Predicate<java.lang.Object>`	`FALSE` A `Predicate` that is always false no matter the input.
`static Function<java.lang.Object,java.lang.Integer>`	`getHashCode` A `Function` that returns the value of the hash code of the input object.
`static Predicate<java.lang.Object>`	`isEmpty` A synonym to `empty`.
`static Function<java.lang.Object,java.lang.Integer>`	`len` A `Function` that takes any object as input and returns its "length", e.g.
`static Function<java.lang.Object,java.lang.String>`	`lower` A synonym to
`static java.util.Random`	`Random` Static acces to Java's Random object methods
`static RegexStatic`	`Regex` An instance of RegexStatic class.
`static strStatic`	`str` `str` contains an instance of a utility `strStatic` object that implements some Function and Predicate objects that take a `str` as input.
`static HappyStringStatic`	`String` For consistency, `x.String` contains an instance of a utility `HappyStringStatic` object that implements some static methods that a usual String class has as well plus some new Function and Predicate objects that take `String` as input.
`static Function<java.lang.Object,java.lang.String>`	`strip` A synonym to
`static Time`	`Time` An instance of Time class.
`static ThreadTimer`	`timer` Starts the static `ThreadLocal` timer of the `ThreadTimer` class.
`static TokenStatic`	`Token` An instance of a `TokenStatic` object.
`static Function<java.lang.Object,java.lang.String>`	`toLowerCase` A synonym to
`static Function<java.lang.Object,java.lang.String>`	`toUpperCase` A synonym to
`static Function<java.lang.Object,java.lang.String>`	`trim` A synonym to
`static Predicate<java.lang.Object>`	`TRUE` A `Predicate` that is always true no matter the input.
`static Function<java.lang.Object,java.lang.String>`	`upper` A synonym to

Constructor Summary

Constructors
Constructor and Description

x()

Constructors
Constructor and Description
`x()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static <T extends java.lang.Number> Function<tuple2<T,T>,T>`	`add()` A `Function` that takes a tuple of arguments an adds them up.
`static boolean`	`all(java.lang.Iterable<java.lang.Boolean> iterable)`
`static <T> boolean`	`all(java.lang.Iterable<T> iterable, Predicate<java.lang.Object> predicate)`
`static boolean`	`any(java.lang.Iterable<java.lang.Boolean> iterable)`
`static <T> boolean`	`any(java.lang.Iterable<T> iterable, Predicate<java.lang.Object> predicate)`
`static <O> Function<java.lang.Object,O>`	`asKey(java.lang.Iterable<?> iterable)` Creates and returns a `Function` that takes as a parameter an `Iterable` and uses the Function's input value as key to get a value from the `Iterable`
`static <O> Function<java.lang.Object,O>`	`asKey(java.util.Map<?,O> map)` Creates and returns a `Function` that takes as a parameter a `Map` and uses the Function's input value as key to get a value from the corresponding `Map`
`static <T> void`	`assertNotEmpty(T expression)` Gets the Assert class object and calls its notEmpty method.
`static <T> void`	`assertNotEmpty(T expression, java.lang.String message)` Gets the Assert class object and calls its notEmpty method.
`static <T> void`	`assertNotNull(T expression)` Gets the Assert class object object and calls its notNull method.
`static <T> void`	`assertNotNull(T expression, java.lang.String message)` Gets the Assert class object and calls its notNull method.
`static void`	`assertTrue(boolean expression)` Gets the Assert class object and calls its True method.
`static void`	`assertTrue(boolean expression, java.lang.String message)` Gets the Assert class object and calls its True method.
`static <T extends java.lang.Number> Function<tuple2<T,T>,T>`	`avg()` A `Function` that takes a tuple of arguments an adds them up.
`static <T extends java.lang.Number> T`	`avg(java.lang.Iterable<T> iterable)` Averages the elements of the input `Iterable` and returs the average.
`static Bag<java.lang.Boolean>`	`Bag(java.lang.Boolean boolean0, java.lang.Boolean boolean1, java.lang.Boolean... otherBooleans)` Factory method that returns an new `Bag` obtained by counting bolleans in the input array.
`static <T> Bag<T>`	`Bag(java.lang.Iterable<T> iterable)` Factory method that returns an new `Bag` obtained by counting values in the input iterable.
`static <T> Bag<T>`	`Bag(java.util.Map<T,java.lang.Integer> map)` Factory method that returns an new `Bag` obtained from the input `Map`.
`static Bag<java.lang.Number>`	`Bag(java.lang.Number number0, java.lang.Number number1, java.lang.Number... otherNumbers)` Factory method that returns an new `Bag` obtained by counting numbers in the input array.
`static Bag<java.lang.String>`	`Bag(java.lang.String string)` Factory method that returns an new `Bag` obtained by counting characters in the input string.
`static Bag<java.lang.String>`	`Bag(java.lang.String string0, java.lang.String string1, java.lang.String... otherStrings)` Factory method that returns an new `Bag` obtained by counting strings in the input array.
`static <I,O> Function<I,O>`	`chain(Function<java.lang.Object,?>... functions)` Chains functions in the following way: `f2(f1(f0(x)))` where `x` is the input of the chained function and f0, f1, ...
`static <T> java.lang.Iterable<T>`	`chain(java.lang.Iterable<T> iterable0, java.lang.Iterable<T> iterable1, java.lang.Iterable<T>... iterables)` Returns an `Iterable` that chains input iterables of the chained function and f0, f1, ...
`static java.lang.Iterable<java.lang.String>`	`chain(java.lang.String string0, java.lang.String string1, java.lang.String... otherStrings)` Returns an `Iterable` that iterates over the characters of the sequence of input strings, starting from the first character of the string0
`static <T> Channel<T>`	`Channel(java.lang.Class<T> type)` Creates a new unbuffered (synchronous) channel of the given type.
`static <T> Channel<T>`	`Channel(java.lang.Class<T> type, int bufferSize)` Creates a new buffered (asynchronous) channel.
`static <T> Function<java.lang.Object,T>`	`constant(T obj)` A `Function` that always returns the same object no matter the input of the
`static <T> boolean`	`contains(java.lang.Iterable<T> iterable, T value)`
`static java.lang.Iterable<java.lang.Integer>`	`count(int min, int max)`
`static java.lang.Iterable<java.lang.Integer>`	`count(int min, int max, int step)`
`static <T> java.lang.Iterable<java.lang.Integer>`	`count(java.lang.Iterable<T> iterable)`
`static <T> java.lang.Iterable<java.lang.Integer>`	`count(java.lang.Iterable<T> iterable, int step)`
`static <T> java.lang.Iterable<java.lang.Integer>`	`count(T[] array)`
`static <T> java.lang.Iterable<java.lang.Integer>`	`count(T[] array, int step)`
`static java.lang.Iterable<java.lang.Integer>`	`countFrom(int min)`
`static java.lang.Iterable<java.lang.Double>`	`countReal(double min, double max, double step)`
`static java.lang.Iterable<java.lang.Integer>`	`countTo(int max)`
`static CSV`	`csv(java.lang.Iterable<?> iterable)` Creates a `CSV` object from an iterable.
`static CSV`	`csv(java.lang.StringBuilder builder)` Creates a `CSV` object from a `StringBuilder`.
`static CSV`	`csv(java.lang.String path, java.lang.String operation)` Opens a `HappyFile` for reading or writing in csv format with the default encoding "utf-8".
`static CSV`	`csv(java.lang.String path, java.lang.String operation, java.lang.String encoding)` Opens a `HappyFile` for reading or writing in csv format.
`static <T> java.lang.Iterable<T>`	`cycle(java.lang.Iterable<T> iterable)`
`static <T> java.lang.Iterable<T>`	`cycle(java.lang.Iterable<T> iterable, java.lang.Integer maxCount)`
`static java.lang.Iterable<java.lang.String>`	`cycle(java.lang.String string)`
`static java.lang.Iterable<java.lang.String>`	`cycle(java.lang.String string, int maxCount)`
`static <T> DefaultDict<T>`	`DefaultDict(java.lang.Class<T> defaultType)` Factory method that returns an new `DefaultDict` of type @param defaultType.
`static <T> dict<T>`	`dict()` Factory method that returns an new empty `dict`.
`static <T> dict<T>`	`dict(dict<T> dict)` Factory method that returns an new `dict` filled using the values of the input another `dict`.
`static <T> dict<T>`	`dict(java.lang.Iterable<tuple> tuples)` Factory method that returns an new `dict` filled using the values of the input `Iterable` of tuples.
`static <T> dict<T>`	`dict(java.util.Map<java.lang.String,T> map)` Factory method that returns an new `dict` filled using the values of the input `Map<String,T>`.
`static <T> dict<T>`	`dict(tuple... tuples)` Factory method that returns an new `dict` filled using the values of the input array of tuples.
`static <T> java.lang.Iterable<tuple2<java.lang.Integer,T>>`	`enumerate(java.lang.Iterable<T> iterable)`
`static <T> java.lang.Iterable<tuple2<java.lang.Integer,T>>`	`enumerate(java.lang.Iterable<T> iterable, int startCount)`
`static java.lang.Iterable<tuple2<java.lang.Integer,java.lang.String>>`	`enumerate(java.lang.String string)`
`static java.lang.Iterable<tuple2<java.lang.Integer,java.lang.String>>`	`enumerate(java.lang.String string, int startCount)`
`static <T> java.lang.Iterable<tuple2<java.lang.Integer,T>>`	`enumerate(T[] array)`
`static <T> java.lang.Iterable<tuple2<java.lang.Integer,T>>`	`enumerate(T[] array, int startCount)`
`static <T> java.lang.Iterable<tuple2<java.lang.Integer,T>>`	`enumerate(T value0, T value1, T... values)`
`static java.lang.String`	`escape(java.lang.String string)` A synonym to `x.String.escape(String)`
`static <T> java.lang.Iterable<T>`	`filter(Predicate<java.lang.Object> predicate, java.lang.Iterable<T> iterable)` Applies the input `Predicate` to each element of the input `Iterable`
`static <T> T`	`first(java.lang.Iterable<T> iterable)`
`static <T> Goer<T>`	`go(Predicate<Channel<T>> worker, Channel<T> channel)` Starts a thread with the computation described in worker and the channel for sending computed values to.
`static <T> Predicate<java.lang.Object>`	`in(java.lang.Iterable<T> iterable)` Creates and returns new `Predicate` that returns true only if the input value of the predicate (key) is contained within in the `Iterable`
`static Predicate<java.lang.Object>`	`in(str str)` Creates and returns new `Predicate` that returns true only if the input value of the predicate,
`static Predicate<java.lang.Object>`	`in(java.lang.String string)` Creates and returns new `Predicate` that returns true only if the input value of the predicate,
`static <T> Function<java.lang.Object,T>`	`invoke(java.lang.String methodName, java.lang.Object... methodParams)` A `Function` that takes an object's method name and method's parameters values as input, invokes that method with those parameters and the output of invocation.
`static boolean`	`isEmpty(java.lang.Object object)` Checks if the input object is empty (does not contains any element).
`static boolean`	`isFalse(java.lang.Object value)` This static method evaluates an input object as false or true.
`static boolean`	`isNotEmpty(java.lang.Object object)` Checks if the input object is empty (does not contains any element).
`static boolean`	`isTrue(java.lang.Object value)` This static method evaluates an input object as true or false.
`static Function<java.lang.Object,java.lang.String>`	`joinOn(java.lang.String separator)` Creates and returns a `Function` that takes as a parameter a `String` separator and concatinates the Function's input `Iterable` using the separator
`static <O> Json<O>`	`Json(java.lang.Integer v)` Factory method that creates a new xpresso `Json` object from a `tuple`.
`static <O> Json<O>`	`Json(java.lang.Iterable<?> o)` Factory method that creates a new xpresso `Json` object from an `Iterable`.
`static <O> Json<O>`	`Json(java.util.Map<?,?> o)` Factory method that creates a new xpresso `Json` object from a `Map`.
`static <O> Json<O>`	`Json(java.lang.String string)` Factory method that creates a new xpresso `Json` object from a `String`.
`static <O> Json<O>`	`Json(tuple o)` Factory method that creates a new xpresso `Json` object from a `Integer`.
`static <O> LambdaFunction<O>`	`lambdaF(java.lang.String lambdaExpression)`
`static <O> LambdaFunction<O>`	`lambdaF(java.lang.String lambdaExpression, Function<java.lang.Object,?>... functions)` Creates and returns new `LambdaFunction` for a given `String` lambda expression Example 1:
`static LambdaPredicate`	`lambdaP(java.lang.String lambdaExpression)`
`static LambdaPredicate`	`lambdaP(java.lang.String lambdaExpression, Function<java.lang.Object,?>... functions)` Creates and returns new `LambdaPredicate` for a given `String` lambda expression Example 1:
`static <T extends java.lang.Comparable<T>> java.lang.Iterable<T>`	`largestN(java.lang.Iterable<T> iterable, int N)` Returns the N largest elements of the input `Iterable`.
`static <T> T`	`last(java.lang.Iterable<T> iterable)`
`static int`	`len(java.lang.Object value)` Returns the length of the argument, usually it is the number of elements it contains.
`static <T> list<T>`	`list()` Factory method that creates a new empty `list` object.
`static <T> list<T>`	`list(java.lang.Iterable<T> iterable)` Factory method that creates a new `list` object from the input `Iterable` iterable of type T.
`static <T> list<T>`	`list(T[] values)` Factory method that creates a new `list` object from the input array of type T.
`static <T> list<T>`	`list(T element0, T element1, T... elements)` Factory method that creates a new `list` object from the input elements of type T.
`static <T> list<T>`	`listOf(T element)` Factory method that creates a new `list` containing the input element.
`static <I,O> java.lang.Iterable<O>`	`map(Function<java.lang.Object,O> function, java.lang.Iterable<I> iterable)` Applies the input `Function` to each element of the input `Iterable`
`static <T extends java.lang.Comparable<? super T>> Function<tuple2<T,T>,T>`	`max()`
`static <T extends java.lang.Comparable<? super T>> T`	`max(java.lang.Iterable<T> iterable)`
`static <T extends java.lang.Comparable<? super T>> T`	`max(T value0, T value1, T... values)`
`static <T> T`	`memo(T object)`
`static <T extends java.lang.Comparable<? super T>> Function<tuple2<T,T>,T>`	`min()`
`static <T extends java.lang.Comparable<? super T>> T`	`min(java.lang.Iterable<T> iterable)`
`static <T extends java.lang.Comparable<? super T>> T`	`min(T value0, T value1, T... values)`
`static HappySQL`	`mysql(HappyMySQL sql)` Creates a new instance of a HappyMySQL object with the same parameters as those of the input HappyMySQL object.
`static HappySQL`	`mysql(java.lang.String dbHost, java.lang.String userName, java.lang.String password, java.lang.String dbName)` Creates an instance of a HappySQL object.
`static Predicate<java.lang.Object>`	`NOT(Predicate<java.lang.Object> predicate)` Creates and returns new `Predicate` with the NOT logic applied to the input `Predicate`
`static HappyObject`	`Object(java.lang.Object o)` Creates an instance of a HappyObject class.
`static HappyFile`	`open(java.lang.String path, java.lang.String operation)` Opens a `HappyFile` for reading or writing, in binary or text mode.
`static HappyFile`	`open(java.lang.String path, java.lang.String operation, java.lang.String encoding)` Opens a `HappyFile` for reading or writing, in binary or text mode.
`static <T> OrderedDict<T>`	`OrderedDict()` Factory method that returns an new empty `OrderedDict`.
`static <T> OrderedDict<T>`	`OrderedDict(java.lang.Iterable<T> iterable)` Factory method that returns an new `OrderedDict` from an input `Iterable`.
`static <T0> void`	`print(T0 object)` A less verbose console print method.
`static <T0,T1> void`	`print(T0 object0, T1 object1)` A less verbose console print method.
`static <T0,T1,T2> void`	`print(T0 object0, T1 object1, T2 object2)` A less verbose console print method.
`static <T0,T1,T2,T3> void`	`print(T0 object0, T1 object1, T2 object2, T3 object3)` A less verbose console print method.
`static <T0,T1,T2,T3,T4> void`	`print(T0 object0, T1 object1, T2 object2, T3 object3, T4 object4)` A less verbose console print method.
`static <T0,T1,T2,T3,T4,T5> void`	`print(T0 object0, T1 object1, T2 object2, T3 object3, T4 object4, T5 object5)` A less verbose console print method.
`static <T0,T1,T2,T3,T4,T5,T6> void`	`print(T0 object0, T1 object1, T2 object2, T3 object3, T4 object4, T5 object5, T6 object6)` A less verbose console print method.
`static <T0,T1,T2,T3,T4,T5,T6,T7> void`	`print(T0 object0, T1 object1, T2 object2, T3 object3, T4 object4, T5 object5, T6 object6, T7 object7)` A less verbose console print method.
`static <T0,T1,T2,T3,T4,T5,T6,T7,T8> void`	`print(T0 object0, T1 object1, T2 object2, T3 object3, T4 object4, T5 object5, T6 object6, T7 object7, T8 object8)` A less verbose console print method.
`static java.lang.Iterable<java.lang.Integer>`	`range(int min, int max)` Alias for compatibility with Python.
`static java.lang.Iterable<java.lang.Integer>`	`range(int min, int max, int step)` Alias for compatibility with Python.
`static <I> I`	`reduce(Function<tuple2<I,I>,I> function, java.lang.Iterable<I> iterable)` Applies function of two arguments cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value.
`static <I> I`	`reduce(Function<tuple2<I,I>,I> function, java.lang.Iterable<I> iterable, I initializer)` Applies function of two arguments cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value.
`static Regex`	`Regex(dict<java.lang.String> translator)`
`static Regex`	`Regex(dict<java.lang.String> translator, int flags)`
`static Regex`	`Regex(java.lang.String regularExpression)` Factory method that creates a new Regex object from a string regular expression.
`static Regex`	`Regex(java.lang.String regularExpression, int flags)` Factory method that creates a new Regex object from a string regular expression.
`static Regex`	`RegexNoCase(dict<java.lang.String> translator)`
`static Regex`	`RegexNoCase(java.lang.String regularExpression)` Factory method that creates a new case insensitive Regex object from a string regular expression.
`static <T> java.lang.Iterable<T>`	`repeat(T value)`
`static <T> java.lang.Iterable<T>`	`repeat(T value, java.lang.Integer maxCount)`
`static <T> java.lang.Iterable<T>`	`reverse(java.lang.Iterable<T> iterable)` Reverse the order of elements of the input `Iterable`
`static str`	`reverse(str str)` Reverse the order of charcters in the input `str`
`static double`	`round(double number)` Return the double value number rounded to ndigits digits after the decimal point.
`static double`	`round(double number, int nDigits)` Return the double value number rounded to nDigits digits after the decimal point.
`static <T> set<T>`	`set()` Factory method that creates a new empty `set` object.
`static <T> set<T>`	`set(java.lang.Iterable<T> iterable)` Factory method that creates a new `set` object from the input `Iterable` iterable of type T.
`static <T> set<T>`	`set(T[] elements)` Factory method that creates a new `set` object from the array of input elements of type T.
`static <T> set<T>`	`set(T element0, T element1, T... elements)` Factory method that creates a new `set` object from all input elements of type T.
`static <T> set<T>`	`setOf(T element)` Factory method that creates a new `set` object and puts into the set the input element.
`static <T> java.lang.Iterable<T>`	`shuffle(java.lang.Iterable<T> iterable)` Suffles the input iterable and returns the shuffled copy.
`Slicer`	`slice()`
`Slicer`	`slice(int step)`
`Slicer`	`slice(int startIndex, int endIndex)`
`Slicer`	`slice(int startIndex, int endIndex, int step)`
`Slicer`	`sliceFrom(int startIndex)`
`Slicer`	`sliceFrom(int startIndex, int step)`
`Slicer`	`sliceTo(int endIndex)`
`Slicer`	`sliceTo(int endIndex, int step)`
`static <T extends java.lang.Comparable<T>> java.lang.Iterable<T>`	`smallestN(java.lang.Iterable<T> iterable, int N)` Returns the N smallest elements of the input `Iterable`.
`static <T extends java.lang.Comparable<T>> java.lang.Iterable<T>`	`sort(java.lang.Iterable<T> iterable)`
`static <T extends java.lang.Comparable<T>> java.lang.Iterable<T>`	`sort(java.lang.Iterable<T> iterable, boolean reverse)`
`static <T> java.lang.Iterable<T>`	`sort(java.lang.Iterable<T> iterable, Function<java.lang.Object,? extends java.lang.Comparable<?>> function)`
`static <T> java.lang.Iterable<T>`	`sort(java.lang.Iterable<T> iterable, Function<java.lang.Object,? extends java.lang.Comparable<?>> function, boolean reverse)` Sorts the values of the input `Iterable` of type T according to the evaluation function `Function` which is applied to each element of the input Iterable.
`static str`	`sort(str str)`
`static str`	`sort(str str, boolean reverse)`
`static str`	`sort(str str, Function<java.lang.Object,? extends java.lang.Comparable<?>> function)`
`static str`	`sort(str str, Function<java.lang.Object,? extends java.lang.Comparable<?>> function, boolean reverse)`
`static str`	`str()` Factory method that creates a new empty `str` object.
`static str`	`str(java.lang.Iterable<java.lang.String> iterable)` Factory method that creates a new `str` object from the input `Iterable` of type `String`.
`static str`	`str(java.lang.String string)` Factory method that creates a new `str` object from the input `String` string.
`static HappyString`	`String(char character)` Returns a `HappyString` object that extends the String object with additional methods, such as `HappyString.join(java.lang.Iterable<?>)`, `HappyString.split(java.lang.String, int)`, and `HappyString.in(java.lang.String...)`.
`static HappyString`	`String(java.lang.Character character)` Returns a `HappyString` object that extends the String object with additional methods, such as `HappyString.join(java.lang.Iterable<?>)`, `HappyString.split(java.lang.String, int)`, and `HappyString.in(java.lang.String...)`.
`static HappyString`	`String(str str)` Returns a HappyString object that extends the String object with additional methods, such as `HappyString.join(java.lang.Iterable<?>)`, `HappyString.split(java.lang.String, int)`, and `HappyString.in(java.lang.String...)`.
`static HappyString`	`String(java.lang.String string)` Returns a `HappyString` object that extends the String object with additional methods, such as `HappyString.join(java.lang.Iterable<?>)`, `HappyString.split(java.lang.String, int)`, and `HappyString.in(java.lang.String...)`.
`static <T extends java.lang.Number> T`	`sum(java.lang.Iterable<T> iterable)` Sums the elements of the input `Iterable` and returs the sum.
`static double`	`time()` Returns the time in seconds since the epoch as a floating point number.
`static Timer`	`Timer()` Returns the running `Timer` object.
`static Token`	`Token(java.lang.String string)` An instance of a `Token` object.
`static <T0> tuple`	`tuple(T0 value)` Factory method that returns an `tuple` of one element.
`static <T0,T1> tuple`	`tuple(T0 value0, T1 value1)` Factory method that returns an `tuple` of two elements.
`static <T0,T1,T2> tuple`	`tuple(T0 value0, T1 value1, T2 value2)` Factory method that returns an `tuple` of three elements.
`static <T0,T1,T2,T3> tuple`	`tuple(T0 value0, T1 value1, T2 value2, T3 value3)` Factory method that returns an `tuple` of three elements.
`static <T> tuple`	`tupleOf(list<T> lst)` Factory method that returns a new `tuple` from a given list.
`static tuple`	`tupleOf(tuple tpl)` Factory method that returns a new `tuple` from a given tuple.
`static <T> set<T>`	`union(java.lang.Iterable<T>... iterables)`
`static <T0> tuple1<list<T0>>`	`unzip(java.lang.Iterable<tuple> iterable, java.lang.Class<T0> class0)` Does the opposite of zip.
`static <T0,T1> tuple2<list<T0>,list<T1>>`	`unzip(java.lang.Iterable<tuple> iterable, java.lang.Class<T0> class0, java.lang.Class<T1> class1)` Does the opposite of zip.
`static <T0,T1,T2> tuple3<list<T0>,list<T1>,list<T2>>`	`unzip(java.lang.Iterable<tuple> iterable, java.lang.Class<T0> class0, java.lang.Class<T1> class1, java.lang.Class<T2> class2)` Does the opposite of zip.
`static <T0,T1,T2,T3> tuple4<list<T0>,list<T1>,list<T2>,list<T3>>`	`unzip(java.lang.Iterable<tuple> iterable, java.lang.Class<T0> class0, java.lang.Class<T1> class1, java.lang.Class<T2> class2, java.lang.Class<T3> class3)` Does the opposite of zip.
`static <O> ScalarComprehensionStart<O>`	`yield()` Factory method that starts a new scalar comprehension.
`static Tuple1ComprehensionStart`	`yield(java.lang.String fieldName)` Factory method that starts a new tuple comprehension.
`static Tuple2ComprehensionStart`	`yield(java.lang.String fieldName0, java.lang.String fieldName1)` Factory method that starts a new tuple comprehension.
`static list<tuple>`	`zip()`
`static <T0> list<tuple>`	`zip(java.lang.Iterable<T0> iterable0)`
`static <T0,T1> list<tuple>`	`zip(java.lang.Iterable<T0> iterable0, java.lang.Iterable<T1> iterable1)`
`static <T0,T1,T2> list<tuple>`	`zip(java.lang.Iterable<T0> iterable0, java.lang.Iterable<T1> iterable1, java.lang.Iterable<T2> iterable2)`
`static <T0,T1,T2,T3> list<tuple>`	`zip(java.lang.Iterable<T0> iterable0, java.lang.Iterable<T1> iterable1, java.lang.Iterable<T2> iterable2, java.lang.Iterable<T3> iterable3)`

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

- Field Detail
 - Assert
```
public static Assert Assert
```
 Contains an instance of Assert class object that has useful assertion methods.
 - String
```
public static HappyStringStatic String
```
 For consistency, x.String contains an instance of a utility HappyStringStatic object that implements some static methods that a usual String class has as well plus some new Function and Predicate objects that take String as input.
```
 
 Example 1: String three = x.String.valueOf(3);
 x.print(three);
 
 Console: 3
 
 Example 2: Function<Object,String> upperFun = x.String.upper;
 
 
```
 - str
```
public static strStatic str
```
 str contains an instance of a utility strStatic object that implements some Function and Predicate objects that take a str as input.
```
 
 Example 1: Function<Object,str> upperFun = x.str.upper;
 
 
```
 - Time
```
public static Time Time
```
 An instance of Time class.
 - timer
```
public static ThreadTimer timer
```
 Starts the static ThreadLocal timer of the ThreadTimer class. This timer can be started, stopped and printed. The difference between x.timer based on the ThreadTimer and x.Timer() based on Timer it that if you use x.timer you don't have to create any instance of any object. You can simply use the static reference
```
 x.timer.start()
```
 and
```
 x.timer.stop();
```
 The timer x.timer is global for the current thread and independent of any other thread. Example:
```
 
 x.timer.start();
 //do something
 x.print(x.timer.stop());
 
 Console: 0.133s
 
 
```
 - Token
```
public static TokenStatic Token
```
 An instance of a TokenStatic object. Example:
```
 
 String stem = x.Token.stem("Worker");
 
 
```
 Example:
```
 
 String stem = x.Token.stem("Marcher", "french");
 
 
```
 - Random
```
public static java.util.Random Random
```
 Static acces to Java's Random object methods
 - Regex
```
public static RegexStatic Regex
```
 An instance of RegexStatic class. A standard acess to xpresso Regex constants and methods.
 - escape
```
public static Function<java.lang.Object,java.lang.String> escape
```
 A synonym to x.String.escape
 - strip
```
public static Function<java.lang.Object,java.lang.String> strip
```
 A synonym to
```
x.String.strip
```
 - trim
```
public static Function<java.lang.Object,java.lang.String> trim
```
 A synonym to
```
x.String.trim
```
 - toLowerCase
```
public static Function<java.lang.Object,java.lang.String> toLowerCase
```
 A synonym to
```
x.String.toLowerCase
```
 - lower
```
public static Function<java.lang.Object,java.lang.String> lower
```
 A synonym to
```
x.String.lower
```
 - toUpperCase
```
public static Function<java.lang.Object,java.lang.String> toUpperCase
```
 A synonym to
```
x.String.toUpperCase
```
 - upper
```
public static Function<java.lang.Object,java.lang.String> upper
```
 A synonym to
```
x.String.upper
```
 - len
```
public static Function<java.lang.Object,java.lang.Integer> len
```
 A Function that takes any object as input and returns its "length", e.g. the number of elements in case of Iterable or tuple.
 - doNothing
```
public static Function<java.lang.Object,java.lang.Object> doNothing
```
 A Function that takes any object as input and returns the same object.
 - FALSE
```
public static Predicate<java.lang.Object> FALSE
```
 A Predicate that is always false no matter the input.
 - TRUE
```
public static Predicate<java.lang.Object> TRUE
```
 A Predicate that is always true no matter the input.
 - empty
```
public static Predicate<java.lang.Object> empty
```
 A Predicate that only true if len(Object) returns 0 for the input value.
 - isEmpty
```
public static Predicate<java.lang.Object> isEmpty
```
 A synonym to empty.
 - getHashCode
```
public static Function<java.lang.Object,java.lang.Integer> getHashCode
```
 A Function that returns the value of the hash code of the input object.
- Constructor Detail
 - x
```
public x()
```
- Method Detail
 - go
```
public static <T> Goer<T> go(Predicate<Channel<T>> worker,
 Channel<T> channel)
```
 Starts a thread with the computation described in worker and the channel for sending computed values to. Example: First, define a worker as an instance of Predicate:
```
 
 Predicate<Channel<Integer>> worker = new Predicate<Channel<Integer>>() {
 public Boolean apply(Channel<Integer> channel) {
 while (some_condition_true) {
 Integer value = computeValue(); //compute something in parallel
 channel.send(value); //send the computed value to the channel
 }
 return true; //everything went as expected
 }
 };
 
 
```
 Then, define the channel to where the workers should send the computed values as soon as those values are ready:
```
 
 Channel<Integer> channel = x.Channel(Integer.class);//this channel only accepts Integer values
 
 
```
 Then, start as many concurrent workers as needed:
```
 
 x.go(worker, channel);
 x.go(worker, channel);
 x.go(worker, channel);
 ...
 
 
```
 Finally, retrieve the computed values from the channel when those values are needed:
```
 
 for (Integer value : channel) {
 x.print(value);
 }
 
 
```
 Type Parameters:
 
 T - type of values one can send o and retrieve from the channel
 
 Parameters:
 
 worker - a Predicate object whose apply method describes the computation and uses the channel to send computed values to
 
 channel - a Channel to send the computed values to by the workers, and to read them from by the main routine as those values are ready
 
 Returns:
 
 a Goer object
 - Channel
```
public static <T> Channel<T> Channel(java.lang.Class<T> type)
```
 Creates a new unbuffered (synchronous) channel of the given type. To be used with the x.go method to start a thread. A unbuffered channel means that no values will be sent to the channel by the workers unless there's a retriever ready to retrieve those values. Example: First, define a worker as an instance of Predicate:
```
 
 Predicate<Channel<Integer>> worker = new Predicate<Channel<Integer>>() {
 public Boolean apply(Channel<Integer> channel) {
 while (some_condition_true) {
 Integer value = computeValue(); //compute something in parallel
 channel.send(value); //send the computed value to the channel
 }
 return true; //everything went as expected
 }
 };
 
 
```
 Then, define the channel to where the workers should send the computed values as soon as those values are ready:
```
 
 Channel<Integer> channel = x.Channel(Integer.class);//this channel only accepts Integer values
 
 
```
 Then, start as many concurrent workers as needed:
```
 
 x.go(worker, channel);
 x.go(worker, channel);
 x.go(worker, channel);
 ...
 
 
```
 Finally, retrieve the computed values from the channel when those values are needed:
```
 
 for (Integer value : channel) {
 x.print(value);
 }
 
 
```
 Type Parameters:
 
 T - type of values one can send o and retrieve from the channel
 
 Parameters:
 
 type - type of values that can be sent to and retrieved from the channel.
 
 Returns:
 
 a Channel object
 - Channel
```
public static <T> Channel<T> Channel(java.lang.Class<T> type,
 int bufferSize)
```
 Creates a new buffered (asynchronous) channel. To be used with the x.go method to start a thread. A buffered channel means that values will be sent to the channel by the workers unless there's a place in the buffer. Even if there's no retriever ready to retrieve those values. Example: First, define a worker as an instance of Predicate:
```
 
 Predicate<Channel<Integer>> worker = new Predicate<Channel<Integer>>() {
 public Boolean apply(Channel<Integer> channel) {
 while (some_condition_true) {
 Integer value = computeValue(); //compute something in parallel
 channel.send(value); //send the computed value to the channel
 }
 return true; //everything went as expected
 }
 };
 
 
```
 Then, define the channel to where the workers should send the computed values as soon as those values are ready:
```
 
 Channel<Integer> channel = x.Channel(Integer.class, 100);//this channel with buffer size 100 only accepts Integer values 
 
 
```
 Then, start as many concurrent workers as needed:
```
 
 x.go(worker, channel);
 x.go(worker, channel);
 x.go(worker, channel);
 ...
 
 
```
 Finally, retrieve the computed values from the channel when those values are needed:
```
 
 for (Integer value : channel) {
 x.print(value);
 }
 
 
```
 Type Parameters:
 
 T - type of values one can send o and retrieve from the channel
 
 Parameters:
 
 type - type of values that can be sent to and retrieved from the channel.
 
 bufferSize - the size of buffer
 
 Returns:
 
 a Channel object
 - assertTrue
```
public static void assertTrue(boolean expression)
```
 Gets the Assert class object and calls its True method.
 
 Parameters:
 
 expression - the expression to assert true
 - assertTrue
```
public static void assertTrue(boolean expression,
 java.lang.String message)
```
 Gets the Assert class object and calls its True method.
 
 Parameters:
 
 expression - the expression to assert true
 
 message - the message to print in case of false
 - assertNotNull
```
public static <T> void assertNotNull(T expression)
```
 Gets the Assert class object object and calls its notNull method.
 
 Type Parameters:
 
 T - input type
 
 Parameters:
 
 expression - the expression to assert not null
 - assertNotNull
```
public static <T> void assertNotNull(T expression,
 java.lang.String message)
```
 Gets the Assert class object and calls its notNull method.
 
 Type Parameters:
 
 T - input type
 
 Parameters:
 
 expression - the expression to assert not null
 
 message - the message to print in case of null
 - assertNotEmpty
```
public static <T> void assertNotEmpty(T expression)
```
 Gets the Assert class object and calls its notEmpty method.
 
 Type Parameters:
 
 T - input type
 
 Parameters:
 
 expression - the expression to assert not empty
 - assertNotEmpty
```
public static <T> void assertNotEmpty(T expression,
 java.lang.String message)
```
 Gets the Assert class object and calls its notEmpty method.
 
 Type Parameters:
 
 T - input type
 
 Parameters:
 
 expression - the expression to assert not empty
 
 message - the message to print in case of empty
 - mysql
```
public static HappySQL mysql(java.lang.String dbHost,
 java.lang.String userName,
 java.lang.String password,
 java.lang.String dbName)
 throws java.lang.ClassNotFoundException,
 java.sql.SQLException
```
 Creates an instance of a HappySQL object.
 Parameters:
 
 dbHost - db host
 
 userName - user name
 
 password - password
 
 dbName - db name
 
 Returns:
 an object that has the HappySQL.execute(String) method that takes the query and params as input; Example:
 try (HappySQL sql = x.mysql("localhost", "user", "password", "db")) { sql.execute("SELECT * FROM Table WHERE ID BETWEEN ? and ? and UserName LIKE ?", 1000, 2000, "John %"); }
 Throws:
 
 java.lang.ClassNotFoundException - in case the jdbc driver for mysql is not found on the system
 
 java.sql.SQLException - in case of bad SQL request
 - mysql
```
public static HappySQL mysql(HappyMySQL sql)
 throws java.lang.ClassNotFoundException,
 java.sql.SQLException
```
 Creates a new instance of a HappyMySQL object with the same parameters as those of the input HappyMySQL object.
 Parameters:
 
 sql - A HappyMySQL object to clone
 
 Returns:
 an object that has the HappySQL.execute(String) method that takes the query and params as input; Example:
 try (HappySQL sql2 = x.mysql(sql1)) { sql2.execute("SELECT * FROM Table WHERE ID BETWEEN ? and ? and UserName LIKE ?", 1000, 2000, "John %"); }
 Throws:
 
 java.lang.ClassNotFoundException - in case the jdbc driver for mysql is not found on the system
 
 java.sql.SQLException - in case of bad SQL request
 - Object
```
public static HappyObject Object(java.lang.Object o)
```
 Creates an instance of a HappyObject class. This class has utility methods equals, compareTo and HashCode. Examples: When defining a class:
```
 \@Override
 int hashCode(){
 		return x.Object(this).hashCode();
 }
 
 
```
 In the above code, xpresso first finds the members of this (via reflections) and then dynamically computes the hash code for this based on the values of its members.
```
 
 \@Override
 boolean equals(Object obj){
 		return x.Object(this).equals(obj);
 }
 
 
```
 In the above code, xpresso first finds the members of the two objects (this and obj), and then compares the values of those members.
```
 
 \@Override
 public int compareTo(Object obj){
 return x.Object(this).compareTo(obj, fieldName0, fieldName1, ...);
 }
 
 
```
 In the above code, xpresso first finds the members of the two objects (this and obj). It then compares the values of those members between the two objects if those members' names are listed among the input field names fieldName0, fieldName1, etc. The order of comparisons between the member's values is the same as the order of input field names.
 Parameters:
 
 o - the Object whose properties we want to extend
 
 Returns:
 
 an instance of HappyObject object that wraps the input object o
 - open
```
public static HappyFile open(java.lang.String path,
 java.lang.String operation,
 java.lang.String encoding)
 throws java.io.IOException
```
 Opens a HappyFile for reading or writing, in binary or text mode. Example:
```
 
 try (HappyFile f = x.open("filename.txt","r","utf-8"){
 		//do stuff
 }
 
 
```
 In case of a text file, the HappyFile object is also an Iterable containing lines of the file:
```
 
 for(String line : f){
 		x.print(line);
 }
 
 
```
 Parameters:
 
 path - a String object containing the path to the file
 
 operation - can be "r" (read in text mode), "rb" (read in binary mode), "w" (write in text mode), "wb" write in binary mode "a" append in text mode, "ab" append in binary mode
 
 encoding - the String object containing the encoding of the file (can be "utf-8" or "latin-1")
 
 Returns:
 
 a HappyFile object
 
 Throws:
 
 java.io.IOException - in case there's a problem opening file
 - open
```
public static HappyFile open(java.lang.String path,
 java.lang.String operation)
 throws java.io.IOException
```
 Opens a HappyFile for reading or writing, in binary or text mode. Example:
```
 
 HappyFile f = x.open("filename.txt","r","utf-8");
 
 
```
 In case of a text file, the HappyFile object is also an Iterable containing lines of the file:
```
 
 for(String line : x.open("filename.txt","r","utf-8")){
 		x.print(line);
 }
 
 
```
 Parameters:
 
 path - a String object containing the path to the file
 
 operation - can be "r" (read in text mode with utf-8 encoding), "rb" (read in binary mode), "w" (write in text mode), "wb" write in binary mode "a" append in text mode, "ab" append in binary mode
 
 Returns:
 
 a HappyFile object
 
 Throws:
 
 java.io.IOException - in case there's a problem opening file
 - csv
```
public static CSV csv(java.lang.String path,
 java.lang.String operation,
 java.lang.String encoding)
 throws java.io.IOException
```
 Opens a HappyFile for reading or writing in csv format. Example 1:
```
 
 try (csv f = x.csv("filename.txt","r","utf-8"){
 		for(list<String> line : f){
 			x.print(line);
 		}
 }
 
 
```
 Example 2:
```
 
 try (csv f = x.csv("filename.txt","w","utf-8"){
 		for(list<?> line : iterable>){
 			csv.writerow(line);
 		}
 }
 
 
```
 In case of a text file, the CSV object is also an Iterable containing list<String> objects for each line of the file:
```
 
 for(list<String> line : f){
 		x.print(line);
 }
 
 
```
 Parameters:
 
 path - a String object containing the path to the file
 
 operation - can be "r" (read in text mode), "rb" (read in binary mode), "w" (write in text mode), "wb" write in binary mode "a" append in text mode, "ab" append in binary mode
 
 encoding - the String object containing the encoding of the file (can be "utf-8" or "latin-1")
 
 Returns:
 
 a CSV object
 
 Throws:
 
 java.io.IOException - in case there's a problem opening file
 - csv
```
public static CSV csv(java.lang.String path,
 java.lang.String operation)
 throws java.io.IOException
```
 Opens a HappyFile for reading or writing in csv format with the default encoding "utf-8". Example:
```
 
 try (csv f = x.csv("filename.txt","r","utf-8"){
 		//do stuff
 }
 
 
```
 In case of a text file, the CSV object is also an Iterable containing list<String> objects for each line of the file:
```
 
 for(list<String> line : f){
 		x.print(line);
 }
 
 
```
 Parameters:
 
 path - a String object containing the path to the file
 
 operation - can be "r" (read in text mode), "rb" (read in binary mode), "w" (write in text mode), "wb" write in binary mode "a" append in text mode, "ab" append in binary mode
 
 Returns:
 
 a CSV object
 
 Throws:
 
 java.io.IOException - in case there's a problem opening file
 - csv
```
public static CSV csv(java.lang.Iterable<?> iterable)
```
 Creates a CSV object from an iterable. The Iterable can be either an instance of HappyFile or an Iterable<list<?>>. When the input Iterable is a HappyFile, the csv object reads or writes from/into the given HappyFile object. When the input Iterable is an Iterable<list<?>>, the csv object can only be used with the toString() function. It will generate the csv String representation of the input Iterable and toString() will return this csv String representation
 
 Parameters:
 
 iterable - a HappyFile object or an Iterable<list<?>>
 
 Returns:
 
 a CSV object
 - csv
```
public static CSV csv(java.lang.StringBuilder builder)
```
 Creates a CSV object from a StringBuilder. Example:
```
 
 StringBuilder builder = new StringBuilder();
 
 csv c = x.csv(builder);
 
 for (list<?> line : iterable){
 		c.writerow(line);
 }
 
 String mycsv = c.toString();
 
 
```
 Parameters:
 
 builder - a StringBuffer object to write csv to
 
 Returns:
 
 a CSV object
 - String
```
public static HappyString String(char character)
```
 Returns a HappyString object that extends the String object with additional methods, such as HappyString.join(java.lang.Iterable<?>), HappyString.split(java.lang.String, int), and HappyString.in(java.lang.String...). Example 1:
```
 
 			 boolean q = x.String("na").in("banana");
 x.print(q);
 
 
```
 Console: true
```
 
 Example 2: String s = x.String("|").join(x.listOf("a","b","c"));
 x.print(s);
 
 
```
 Console: a|b|c
 Parameters:
 
 character - char to wrap
 
 Returns:
 
 a HappyString object that wraps char
 - String
```
public static HappyString String(java.lang.Character character)
```
 Returns a HappyString object that extends the String object with additional methods, such as HappyString.join(java.lang.Iterable<?>), HappyString.split(java.lang.String, int), and HappyString.in(java.lang.String...).
```
 
 Example 1: boolean q = x.String("na").in("banana");
 x.print(q);
 
 Console: true
 
 
 Example 2: String s = x.String("|").join(x.listOf("a","b","c"));
 x.print(s);
 
 Console: a|b|c
 
 
```
 Parameters:
 
 character - char to wrap
 
 Returns:
 
 a HappyString object that wraps char
 - String
```
public static HappyString String(java.lang.String string)
```
 Returns a HappyString object that extends the String object with additional methods, such as HappyString.join(java.lang.Iterable<?>), HappyString.split(java.lang.String, int), and HappyString.in(java.lang.String...).
```
 
 Example 1: boolean q = x.String("na").in("banana");
 x.print(q);
 
 Console: true
 
 
 Example 2: String s = x.String("|").join(x.listOf("a","b","c"));
 x.print(s);
 
 Console: a|b|c
 
 
```
 Parameters:
 
 string - to wrap
 
 Returns:
 
 a HappyString object that wraps string
 - String
```
public static HappyString String(str str)
```
 Returns a HappyString object that extends the String object with additional methods, such as HappyString.join(java.lang.Iterable<?>), HappyString.split(java.lang.String, int), and HappyString.in(java.lang.String...).
```
 
 Example 1: boolean q = x.String(x.str("na")).in("banana");
 x.print(q);
 
 Console: true
 
 
 Example 2: String s = x.String("|").join(x.listOf("a","b","c"));
 x.print(s);
 
 Console: a|b|c
 
 
```
 Parameters:
 
 str - to wrap
 
 Returns:
 
 a HappyString object that wraps the str
 - str
```
public static str str()
```
 Factory method that creates a new empty str object. Example 1:
```
 
 str newStr = x.str();
 
 x.print(newStr);
 
 Console:
 
 
```
 Returns:
 
 the new str object
 - str
```
public static str str(java.lang.String string)
```
 Factory method that creates a new str object from the input String string. Example 1:
```
 
 str newStr = x.str("I like xpresso!");
 
 x.print(newStr.sliceFrom(7));
 
 Console: xpresso!
 
 
```
 Parameters:
 
 string - a String that initialized the new str object
 
 Returns:
 
 the new str object containing the string from the input String
 - str
```
public static str str(java.lang.Iterable<java.lang.String> iterable)
```
 Factory method that creates a new str object from the input Iterable of type String. Example 1:
```
 
 str newStr = x.str(x.list("hello", " ", "world", "!"));
 
 x.print(newStr);
 
 Console: hello world!
 
 
```
 Parameters:
 
 iterable - the Iterable that contains data to initialize the new str object
 
 Returns:
 
 the new str object that represent a concatenation of all elements of the input Iterable
 - set
```
public static <T> set<T> set(java.lang.Iterable<T> iterable)
```
 Factory method that creates a new set object from the input Iterable iterable of type T. The elements of the input iterable will become the members of the new set object.
 
 Type Parameters:
 
 T - type of elements in the input Iterable
 
 Parameters:
 
 iterable - an Iterable containing elements to be put into new set object
 
 Returns:
 
 new set
 - set
```
public static <T> set<T> set()
```
 Factory method that creates a new empty set object.
 
 Type Parameters:
 
 T - type of elements of the new set
 
 Returns:
 
 new empty set
 - set
```
@SafeVarargs
public static <T> set<T> set(T element0,
 T element1,
 T... elements)
```
 Factory method that creates a new set object from all input elements of type T. The elements of the input will become the members of the new set object.
 
 Type Parameters:
 
 T - type of elements of the new set
 
 Parameters:
 
 element0 - an element to put into new set
 
 element1 - an element to put into new set
 
 elements - elements to put into new set
 
 Returns:
 
 new set
 - set
```
public static <T> set<T> set(T[] elements)
```
 Factory method that creates a new set object from the array of input elements of type T. The elements of the input array will become the members of the new set object.
 
 Type Parameters:
 
 T - the type of elements in the new set
 
 Parameters:
 
 elements - an array of elements to put into the new set
 
 Returns:
 
 a set
 - setOf
```
public static <T> set<T> setOf(T element)
```
 Factory method that creates a new set object and puts into the set the input element.
 
 Type Parameters:
 
 T - the type of elements in the set
 
 Parameters:
 
 element - the element to put into the new set
 
 Returns:
 
 the new set
 - list
```
public static <T> list<T> list()
```
 Factory method that creates a new empty list object.
 
 Type Parameters:
 
 T - the type of elements in the list
 
 Returns:
 
 the new list
 - listOf
```
public static <T> list<T> listOf(T element)
```
 Factory method that creates a new list containing the input element.
 
 Type Parameters:
 
 T - the type of elements in the list
 
 Parameters:
 
 element - the element to put into the new list
 
 Returns:
 
 the new list
 - list
```
@SafeVarargs
public static <T> list<T> list(T element0,
 T element1,
 T... elements)
```
 Factory method that creates a new list object from the input elements of type T. The input elements will become the members of the new list object in the same order.
 
 Type Parameters:
 
 T - type of elements of the new list
 
 Parameters:
 
 element0 - the first element to put into new list
 
 element1 - teh second element to put into new list
 
 elements - all other elements to put into new list
 
 Returns:
 
 new list
 - list
```
public static <T> list<T> list(T[] values)
```
 Factory method that creates a new list object from the input array of type T. The elements of the input array become the elements of new list. The order of elements in the input array is preserved in the new list.
 
 Type Parameters:
 
 T - type of elements of the new list
 
 Parameters:
 
 values - the input array of elements of type T
 
 Returns:
 
 new list
 - list
```
public static <T> list<T> list(java.lang.Iterable<T> iterable)
```
 Factory method that creates a new list object from the input Iterable iterable of type T. The elements of the input iterable become the elements of new list. The order of elements in the input iterable is preserved in the new list.
 
 Type Parameters:
 
 T - type of elements of the new list
 
 Parameters:
 
 iterable - the input iterable containing elements to put in the new list
 
 Returns:
 
 new list
 - yield
```
public static <O> ScalarComprehensionStart<O> yield()
```
 Factory method that starts a new scalar comprehension. The difference of a scalar comprehension from a tuple comprehension is that scalar comprehension sees the elements of the input iterable as scalars even if the latter are tuples, or iterables or other collection types. Example 1, a list comprehension: Python:
```
 
 foreign_trips_lower = [element.lower() for element in trips if element not in russian_cities]
 
 
```
 xpresso:
```
 
 list<String> foreignTripsLower = x.list(x.yield().apply(x.lower).forEach(trips).unless(x.in(russianCities)));
 
 
```
 Type Parameters:
 
 O - the type of elements in the output iterable
 
 Returns:
 
 the fist object in the sequence that builds the comprehension expression
 - yield
```
public static Tuple1ComprehensionStart yield(java.lang.String fieldName)
```
 Factory method that starts a new tuple comprehension. The difference of a scalar comprehension from a tuple comprehension is that the tuple comprehension returns tuples of values. Usually it's used when the elements of the input iterable are themselves tuples, or iterables or other collection types. But it freely can be used with iterables of scalars if needed. Example 1, a list comprehension: Python:
```
 
 list1 = [a.lower() for a, b, c, d in list0]
 
 
```
 xpresso:
```
 
 list<tuple> list1 = x.list(x.yield("a").apply(x.lower).where("a", "b", "c", "d").in(list0));
 
 
```
 Parameters:
 
 fieldName - the name of the "field" of each element of the input Iterable we want in our output Iterable
 
 Returns:
 
 the fist object in the sequence that builds the comprehension expression
 - yield
```
public static Tuple2ComprehensionStart yield(java.lang.String fieldName0,
 java.lang.String fieldName1)
```
 Factory method that starts a new tuple comprehension. The difference of a scalar comprehension from a tuple comprehension is that the tuple comprehension returns tuples of values. Usually it's used when the elements of the input iterable are themselves tuples, or iterables or other collection types. But it freely can be used with iterables of scalars if needed. Example 1, a list comprehension: Python:
```
 
 list1 = [a.lower(), b.upper() for a, b, c, d in list0]
 
 
```
 xpresso:
```
 
 list<tuple> list1 = x.list(x.yield("a", "b").apply(x.lower, x.upper).where("a", "b", "c", "d").in(list0));
 
 
```
 Example 2, a list comprehension: Python:
```
 
 list1 = [a.lower(), true for a, b, c, d in list0]
 
 
```
 xpresso:
```
 
 list<tuple> list1 = x.list(x.yield("a", "b").apply(x.lower).replace(True).where("a", "b", "c", "d").in(list0));
 
 
```
 Parameters:
 
 fieldName0 - and
 
 fieldName1 - are the names of the "fields" of each element of the input Iterable we want in our output Iterable
 
 Returns:
 
 the fist object in the sequence that builds the comprehension expression
 - asKey
```
public static <O> Function<java.lang.Object,O> asKey(java.lang.Iterable<?> iterable)
```
 Creates and returns a Function that takes as a parameter an Iterable and uses the Function's input value as key to get a value from the Iterable
 
 Type Parameters:
 
 O - the type of elements in the
 
 Parameters:
 
 iterable - an Iterable
 
 Returns:
 
 a Function
 - asKey
```
public static <O> Function<java.lang.Object,O> asKey(java.util.Map<?,O> map)
```
 Creates and returns a Function that takes as a parameter a Map and uses the Function's input value as key to get a value from the corresponding Map
 
 Type Parameters:
 
 O - the type of values in the map
 
 Parameters:
 
 map - a Map
 
 Returns:
 
 a Function
 - joinOn
```
public static Function<java.lang.Object,java.lang.String> joinOn(java.lang.String separator)
```
 Creates and returns a Function that takes as a parameter a String separator and concatinates the Function's input Iterable using the separator
 
 Parameters:
 
 separator - an String separator
 
 Returns:
 
 a Function
 - NOT
```
public static Predicate<java.lang.Object> NOT(Predicate<java.lang.Object> predicate)
```
 Creates and returns new Predicate with the NOT logic applied to the input Predicate
 
 Parameters:
 
 predicate - a Predicate to apply the NOT logic to
 
 Returns:
 
 a Predicate that negates the input @param predicate
 - in
```
public static <T> Predicate<java.lang.Object> in(java.lang.Iterable<T> iterable)
```
 Creates and returns new Predicate that returns true only if the input value of the predicate (key) is contained within in the Iterable
```
 iterable
```
 parameter.
 Type Parameters:
 
 T - the type of iterable's element
 
 Parameters:
 
 iterable - an Iterable of type <T>
 
 Returns:
 
 a new Predicate
 - in
```
public static Predicate<java.lang.Object> in(java.lang.String string)
```
 Creates and returns new Predicate that returns true only if the input value of the predicate,
```
 stringOrChar
```
 is contained within in the <pre>string</pre> parameter.
 Parameters:
 
 string - the String to search in
 
 Returns:
 
 a new Predicate
 - in
```
public static Predicate<java.lang.Object> in(str str)
```
 Creates and returns new Predicate that returns true only if the input value of the predicate,
```
 stringOrChar
```
 is contained within in the <pre>str</pre> parameter.
 Parameters:
 
 str - a str object
 
 Returns:
 
 a new Predicate
 - lambdaP
```
@SafeVarargs
public static LambdaPredicate lambdaP(java.lang.String lambdaExpression,
 Function<java.lang.Object,?>... functions)
```
 Creates and returns new LambdaPredicate for a given String lambda expression Example 1:
```
 Predicate\<Object\> isNonEmptyLongString = x.lambdaP("x : f0(x) > 5 || f1(x) != 0",x.len,x.len);
```
 Parameters:
 
 lambdaExpression - a String containing a lambda expression
 
 functions - optional Function objects
 
 Returns:
 
 a LambdaPredicate that realizes the description given in @param lambdaExpression and using @param functions
 - lambdaP
```
public static LambdaPredicate lambdaP(java.lang.String lambdaExpression)
```
 - lambdaF
```
@SafeVarargs
public static <O> LambdaFunction<O> lambdaF(java.lang.String lambdaExpression,
 Function<java.lang.Object,?>... functions)
```
 Creates and returns new LambdaFunction for a given String lambda expression Example 1:
```
 Function<Object,Integer> increment = x.\<Integer\>lambdaF("x : x + 1");
```
 Type Parameters:
 
 O - output type of the LambdaFunction
 
 Parameters:
 
 lambdaExpression - a String with a lambda expression
 
 functions - functions to use in the lambda expressions (optional)
 
 Returns:
 
 a LambdaFunction that realizes the description given in @param lambdaExpression and using @param functions
 - lambdaF
```
public static <O> LambdaFunction<O> lambdaF(java.lang.String lambdaExpression)
```
 - chain
```
@SafeVarargs
public static <I,O> Function<I,O> chain(Function<java.lang.Object,?>... functions)
```
 Chains functions in the following way: f2(f1(f0(x))) where x is the input of the chained function and f0, f1, ... are the functions to apply to x in chain. Example 1:
```
 Function<Integer,Integer> incrementAndMultiplyBy5 = x.chain(increment,x.\<Integer\>lambdaF("x : x * 5"));
```
 Type Parameters:
 
 I - input type for the final chained function
 
 O - output type for the final chained function
 
 Parameters:
 
 functions - functions to chain (optional)
 
 Returns:
 
 a Function that chains the input functions
 - chain
```
@SafeVarargs
public static <T> java.lang.Iterable<T> chain(java.lang.Iterable<T> iterable0,
 java.lang.Iterable<T> iterable1,
 java.lang.Iterable<T>... iterables)
```
 Returns an Iterable that chains input iterables of the chained function and f0, f1, ... are the functions to apply to x in chain.
 
 Type Parameters:
 
 T - the type of values returned by the input iterables
 
 Parameters:
 
 iterable0 - the first iterable
 
 iterable1 - the second iterable
 
 iterables - the remaining iterables
 
 Returns:
 
 an Iterable ot type T
 - chain
```
@SafeVarargs
public static java.lang.Iterable<java.lang.String> chain(java.lang.String string0,
 java.lang.String string1,
 java.lang.String... otherStrings)
```
 Returns an Iterable that iterates over the characters of the sequence of input strings, starting from the first character of the string0
 
 Parameters:
 
 string0 - the first string
 
 string1 - the second string
 
 otherStrings - the remaining strings
 
 Returns:
 
 an Iterable or String
 - tupleOf
```
public static tuple tupleOf(tuple tpl)
```
 Factory method that returns a new tuple from a given tuple.
 
 Parameters:
 
 tpl - a tuple
 
 Returns:
 
 a new tuple that has the same member values as the old tuple value
 - tupleOf
```
public static <T> tuple tupleOf(list<T> lst)
```
 Factory method that returns a new tuple from a given list.
 
 Type Parameters:
 
 T - type of values in teh list
 
 Parameters:
 
 lst - a list
 
 Returns:
 
 a new tuple that has the same member values as the old tuple value
 - tuple
```
public static <T0> tuple tuple(T0 value)
```
 Factory method that returns an tuple of one element.
 
 Type Parameters:
 
 T0 - the type of value
 
 Parameters:
 
 value - a value of any type
 
 Returns:
 
 a tuple that contains @param value
 - tuple
```
public static <T0,T1> tuple tuple(T0 value0,
 T1 value1)
```
 Factory method that returns an tuple of two elements.
 
 Type Parameters:
 
 T0 - the type of value0
 
 T1 - the type of value1
 
 Parameters:
 
 value0 - a value of any type
 
 value1 - a value of any type (can be different of the type of value0)
 
 Returns:
 
 a tuple that contains @param value0 as the first dimension and @param value1 as the second dimension
 - tuple
```
public static <T0,T1,T2> tuple tuple(T0 value0,
 T1 value1,
 T2 value2)
```
 Factory method that returns an tuple of three elements.
 
 Type Parameters:
 
 T0 - the type of value0
 
 T1 - the type of value1
 
 T2 - the type of value2
 
 Parameters:
 
 value0 - a value of any type
 
 value1 - a value of any type (can be different of the type of value0)
 
 value2 - a value of any type (can be different of the types of value0 and value1)
 
 value1 - as the second dimension, and @param value2 as the third dimension
 
 Returns:
 
 a tuple that contains @param value0 as the first dimension,
 - tuple
```
public static <T0,T1,T2,T3> tuple tuple(T0 value0,
 T1 value1,
 T2 value2,
 T3 value3)
```
 Factory method that returns an tuple of three elements.
 
 Type Parameters:
 
 T0 - the type of value0
 
 T1 - the type of value1
 
 T2 - the type of value2
 
 T3 - the type of value2
 
 Parameters:
 
 value0 - a value of any type
 
 value1 - a value of any type (can be different of the type of value0)
 
 value2 - a value of any type (can be different of the types of value0 and value1)
 
 value3 - a value of any type (can be different of the types of value0, value1, and value3)
 
 value1 - as the second dimension, @param value2 as the third dimension, and @param value3 as the fourth dimension
 
 Returns:
 
 a tuple that contains @param value0 as the first dimension,
 - dict
```
public static <T> dict<T> dict()
```
 Factory method that returns an new empty dict.
 
 Type Parameters:
 
 T - the type of values in the dict
 
 Returns:
 
 a new empty dict
 - dict
```
public static <T> dict<T> dict(java.lang.Iterable<tuple> tuples)
```
 Factory method that returns an new dict filled using the values of the input Iterable of tuples. The input tuples have to be instances of tuple2<String,T>. The first dimension of each tuple is used as key and the second as value for the dict.
 
 Type Parameters:
 
 T - the type of values in the new dict
 
 Parameters:
 
 tuples - an Iterable of tuples
 
 Returns:
 
 a new dict
 - dict
```
@SafeVarargs
public static <T> dict<T> dict(tuple... tuples)
```
 Factory method that returns an new dict filled using the values of the input array of tuples. The input tuples have to be instances of tuple2<String,T>. The first dimension of each tuple is used as key and the second as value for the dict.
 
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 tuples - zero or more instances of tuple2<String,T>
 
 Returns:
 
 a new dict
 - dict
```
public static <T> dict<T> dict(java.util.Map<java.lang.String,T> map)
```
 Factory method that returns an new dict filled using the values of the input Map<String,T>. *
 
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 map - a Map of type <String,T>
 
 Returns:
 
 a new dict
 - dict
```
public static <T> dict<T> dict(dict<T> dict)
```
 Factory method that returns an new dict filled using the values of the input another dict. *
 
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 dict - a dict<T>.
 
 Returns:
 
 a new dict
 - DefaultDict
```
public static <T> DefaultDict<T> DefaultDict(java.lang.Class<T> defaultType)
```
 Factory method that returns an new DefaultDict of type @param defaultType. DefaultDict in xpresso works similarly to Python's defaultdict. See collections.
 
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 defaultType - a Class<T> object
 
 Returns:
 
 a new DefaultDict
 - OrderedDict
```
public static <T> OrderedDict<T> OrderedDict(java.lang.Iterable<T> iterable)
```
 Factory method that returns an new OrderedDict from an input Iterable. The input iterable object has to be an Iterable<tuple> or two dimensions or an Iterable<tuple2<String,T>> or an OrderedDict OrderedDict in xpresso works similarly to Python's OrderedDict. See collections.
 
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - an Iterable
 
 Returns:
 
 new OrderedDict
 - OrderedDict
```
public static <T> OrderedDict<T> OrderedDict()
```
 Factory method that returns an new empty OrderedDict. OrderedDict in xpresso works similarly to Python's OrderedDict. See collections.
 
 Type Parameters:
 
 T - the type of elements in the dict
 
 Returns:
 
 new OrderedDict
 - Bag
```
public static <T> Bag<T> Bag(java.lang.Iterable<T> iterable)
```
 Factory method that returns an new Bag obtained by counting values in the input iterable. Bag in xpresso works similarly to Python's Counter object. See the page about Python's collections.
 
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - an Iterable of type T
 
 Returns:
 
 new OrderedDict
 - Bag
```
public static Bag<java.lang.String> Bag(java.lang.String string)
```
 Factory method that returns an new Bag obtained by counting characters in the input string. Bag in xpresso works similarly to Python's Counter object. See the page about Python's collections.
 
 Parameters:
 
 string - a String
 
 Returns:
 
 new Bag
 - Bag
```
public static Bag<java.lang.String> Bag(java.lang.String string0,
 java.lang.String string1,
 java.lang.String... otherStrings)
```
 Factory method that returns an new Bag obtained by counting strings in the input array. Bag in xpresso works similarly to Python's Counter object. See the page about Python's collections.
 
 Parameters:
 
 string0 - the first String to put in the new Bag
 
 string1 - the second String to put in the new Bag
 
 otherStrings - all other Strings to put in the new Bag
 
 Returns:
 
 new Bag
 - Bag
```
public static Bag<java.lang.Number> Bag(java.lang.Number number0,
 java.lang.Number number1,
 java.lang.Number... otherNumbers)
```
 Factory method that returns an new Bag obtained by counting numbers in the input array. Bag in xpresso works similarly to Python's Counter object. See the page about Python's collections.
 
 Parameters:
 
 number0 - the first Number to put in the new Bag
 
 number1 - the second Number to put in the new Bag
 
 otherNumbers - all other Numbers to put in the new Bag
 
 Returns:
 
 new Bag
 - Bag
```
public static Bag<java.lang.Boolean> Bag(java.lang.Boolean boolean0,
 java.lang.Boolean boolean1,
 java.lang.Boolean... otherBooleans)
```
 Factory method that returns an new Bag obtained by counting bolleans in the input array. Bag in xpresso works similarly to Python's Counter object. See the page about Python's collections.
 
 Parameters:
 
 boolean0 - the fist Boolean to put in the new Bag
 
 boolean1 - the second Boolean to put in the new Bag
 
 otherBooleans - all other Booleans to put in the new Bag
 
 Returns:
 
 new Bag
 - Bag
```
public static <T> Bag<T> Bag(java.util.Map<T,java.lang.Integer> map)
```
 Factory method that returns an new Bag obtained from the input Map. The keys in the input map will used as the new Bag's counted elements, while the Integer values of the input Map will be used as the respective counts for those counted elements. Bag in xpresso works similarly to Python's Counter object. See the page about Python's collections.
 
 Type Parameters:
 
 T - the type of elements in the Bag
 
 Parameters:
 
 map - a map containing elements to put into new Bag
 
 Returns:
 
 new Bag
 - len
```
public static int len(java.lang.Object value)
```
 Returns the length of the argument, usually it is the number of elements it contains. The len of a scalar or a null is 0. The len of an Object is 0 unless the object has a property "length" or methods "len", "length", or "size"
 
 Parameters:
 
 value - any Object
 
 Returns:
 
 the length of the Object
 - time
```
public static double time()
```
 Returns the time in seconds since the epoch as a floating point number.
 
 Returns:
 
 time in seconds
 - Timer
```
public static Timer Timer()
```
 Returns the running Timer object. This object can be then stopped and printed:
```
 
 Timer timer = x.Timer();
 //do something
 x.print(timer.stop());
 
 
```
 Console: 0.133s
 Returns:
 
 the running Timer object
 - Token
```
public static Token Token(java.lang.String string)
```
 An instance of a Token object. Example:
```
 
 String stem = x.Token("Worker").stem();
 
 
```
 Example:
```
 
 String stem = x.Token("Marcher").stem("french");
 
 
```
 Example:
```
 
 String stem = x.Token("Java8").shape();
 
 
```
```
 Console: ULLLD
 
```
 Parameters:
 
 string - the string that defines the token
 
 Returns:
 
 new Token for the given String
 - round
```
public static double round(double number,
 int nDigits)
```
 Return the double value number rounded to nDigits digits after the decimal point. If ndigits is omitted, it defaults to zero. The result is a double.
 
 Parameters:
 
 number - the number to round
 
 nDigits - the number of decimals after the decimal point
 
 Returns:
 
 a rounded input value
 - round
```
public static double round(double number)
```
 Return the double value number rounded to ndigits digits after the decimal point. If ndigits is omitted, it defaults to zero. The result is a double.
 
 Parameters:
 
 number - the number to round
 
 Returns:
 
 a rounded input value
 - all
```
public static boolean all(java.lang.Iterable<java.lang.Boolean> iterable)
```
 Parameters:
 
 iterable - in Iterable of booleans
 
 Returns:
 
 Only returns true if all elements of the input Iterable are true.
 - all
```
public static <T> boolean all(java.lang.Iterable<T> iterable,
 Predicate<java.lang.Object> predicate)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - an Iterable of type <T>
 
 predicate - any Predicate
 
 Returns:
 
 Only returns true if the input Predicate, when applied to each element of the input Iterable, returns true.
 - any
```
public static boolean any(java.lang.Iterable<java.lang.Boolean> iterable)
```
 Parameters:
 
 iterable - an Iterable object
 
 Returns:
 
 Returns true if at least one element of the input Iterable is true.
 - any
```
public static <T> boolean any(java.lang.Iterable<T> iterable,
 Predicate<java.lang.Object> predicate)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - an Iterable of type <T>
 
 predicate - any Predicate
 
 Returns:
 
 Returns true if the input Predicate, when applied to at least one element of the input Iterable, returns true.
 - max
```
public static <T extends java.lang.Comparable<? super T>> T max(java.lang.Iterable<T> iterable)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - an Iterable of type <T>
 
 Returns:
 
 Returns the biggest element of the input Iterable.
 - max
```
@SafeVarargs
public static <T extends java.lang.Comparable<? super T>> T max(T value0,
 T value1,
 T... values)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 value0 - value of type <T>
 
 value1 - value of type <T>
 
 values - values of type <T>
 
 Returns:
 
 Returns the biggest element among the input values.
 - min
```
public static <T extends java.lang.Comparable<? super T>> T min(java.lang.Iterable<T> iterable)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - an Iterable of type <T>
 
 Returns:
 
 Returns the smallest element of the input Iterable.
 - min
```
@SafeVarargs
public static <T extends java.lang.Comparable<? super T>> T min(T value0,
 T value1,
 T... values)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 value0 - value of type <T>
 
 value1 - value of type <T>
 
 values - values of type <T>
 
 Returns:
 
 Returns the smallest element among the input values.
 - sum
```
public static <T extends java.lang.Number> T sum(java.lang.Iterable<T> iterable)
```
 Sums the elements of the input Iterable and returs the sum.
 
 Type Parameters:
 
 T - a type that extends a Number
 
 Parameters:
 
 iterable - an Iterable of Numbers
 
 Returns:
 
 the sum of elements of the input Iterable
 - avg
```
public static <T extends java.lang.Number> T avg(java.lang.Iterable<T> iterable)
```
 Averages the elements of the input Iterable and returs the average.
 
 Type Parameters:
 
 T - a type that extends a Number
 
 Parameters:
 
 iterable - an Iterable of Numbers
 
 Returns:
 
 the average of elemets of the Iterable
 - first
```
public static <T> T first(java.lang.Iterable<T> iterable)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - an Iterable
 
 Returns:
 
 Returns the first element of the input Iterable.
 - last
```
public static <T> T last(java.lang.Iterable<T> iterable)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - an Iterable
 
 Returns:
 
 Returns the last element of the input Iterable.
 - count
```
public static java.lang.Iterable<java.lang.Integer> count(int min,
 int max,
 int step)
```
 Parameters:
 
 min - start value
 
 max - end value (not returned)
 
 step - the increment
 
 Returns:
 
 Returns the Iterator over Integer elements starting from @param min with the increment between the values given by @param step. The last returned value by the Iterator will be the biggest Integer less than @param max.
 - range
```
public static java.lang.Iterable<java.lang.Integer> range(int min,
 int max,
 int step)
```
 Alias for compatibility with Python.
 
 Parameters:
 
 min - start value
 
 max - end value (not returned)
 
 step - the increment
 
 Returns:
 
 Returns the Iterator over Integer elements starting from @param min with the increment between the values given by @param step. The last returned value by the Iterator will be the biggest Integer less than @param max.
 - count
```
public static java.lang.Iterable<java.lang.Integer> count(int min,
 int max)
```
 Parameters:
 
 min - start value
 
 max - end value (not returned)
 
 Returns:
 
 Returns the Iterable over Integer elements starting from @param min with the increment of 1 between the values. The last returned value by the Iterator will be the biggest Integer less than @param max.
 - range
```
public static java.lang.Iterable<java.lang.Integer> range(int min,
 int max)
```
 Alias for compatibility with Python.
 
 Parameters:
 
 min - start value
 
 max - end value (not returned)
 
 Returns:
 
 Returns the Iterable over Integer elements starting from @param min with the increment of 1 between the values. The last returned value by the Iterator will be the biggest Integer less than @param max.
 - countTo
```
public static java.lang.Iterable<java.lang.Integer> countTo(int max)
```
 Parameters:
 
 max - end value (not returned)
 
 Returns:
 
 Returns the Iterable over Integer elements starting from 0 with the increment of 1 between the values. The last returned value by the Iterator will be @param max - 1.
 - countFrom
```
public static java.lang.Iterable<java.lang.Integer> countFrom(int min)
```
 Parameters:
 
 min - start value
 
 Returns:
 
 Returns an infinite Iterable over Integer elements starting from @param min with the increment of 1 between the values.
 - countReal
```
public static java.lang.Iterable<java.lang.Double> countReal(double min,
 double max,
 double step)
```
 Parameters:
 
 min - start value
 
 max - end value (not returned)
 
 step - the increment
 
 Returns:
 
 Returns the Iterable over Double elements starting from @param min with the increment between the values given by @param step. The last returned value by the Iterator will be the biggest Double less than @param max.
 - count
```
public static <T> java.lang.Iterable<java.lang.Integer> count(java.lang.Iterable<T> iterable,
 int step)
```
 Type Parameters:
 
 T - the type of elements of the input Iterable
 
 Parameters:
 
 iterable - an Iterable of any type
 
 step - the increment
 
 Returns:
 
 Returns the Iterable over Integer elements starting from 0 with the increment between the values given by @param step. The last returned value by the Iterable will be the biggest Integer less than the length of the input Iterable.
 - count
```
public static <T> java.lang.Iterable<java.lang.Integer> count(java.lang.Iterable<T> iterable)
```
 Type Parameters:
 
 T - the type of elements of the input Iterable
 
 Parameters:
 
 iterable - an Iterable of any type
 
 Returns:
 
 Returns the Iterable over Integer elements starting from 0 with the increment of 1 between the values. The last returned value by the Iterator will be the biggest Integer less than the length of the input Iterable.
 - count
```
public static <T> java.lang.Iterable<java.lang.Integer> count(T[] array,
 int step)
```
 Type Parameters:
 
 T - type of elements of the array
 
 Parameters:
 
 array - an array
 
 step - the increment
 
 Returns:
 
 Returns the Iterable over Integer elements starting from 0 with the increment of step between the values. The last returned value by the Iterator will be the biggest Integer less than the length of the input array.
 - count
```
public static <T> java.lang.Iterable<java.lang.Integer> count(T[] array)
```
 Type Parameters:
 
 T - type of elements of the array
 
 Parameters:
 
 array - an array
 
 Returns:
 
 Returns the Iterable over Integer elements starting from 0 with the increment of 1 between the values. The last returned value by the Iterator will be the biggest Integer less than the length of the input array.
 - map
```
public static <I,O> java.lang.Iterable<O> map(Function<java.lang.Object,O> function,
 java.lang.Iterable iterable)
```
 Applies the input Function to each element of the input Iterable
 
 Type Parameters:
 
 I - input element type
 
 O - output element type
 
 Parameters:
 
 iterable - an iterable or type I
 
 function - a function to apply to elements of the Iterable
 
 Returns:
 
 a new Iterable containing the Functions' outputs of each element. Preserves the order of elements.
 - reduce
```
public static  I reduce(Function<tuple2<I,I>,I> function,
 java.lang.Iterable iterable,
 I initializer)
```
 Applies function of two arguments cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value. For example,
```
 x.reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])
```
 calculates ((((1+2)+3)+4)+5). The left argument, x, is the accumulated value and the right argument, y, is the update value from the iterable. If the optional initializer is present, it is placed before the items of the iterable in the calculation, and serves as a default when the iterable is empty. If initializer is not given and iterable contains only one item, the first item is returned. Roughly equivalent to:
```
 
 
 def reduce(function, iterable, initializer):
 		it = iter(iterable)
 		accum_value = initializer
 		for x in it:
 			accum_value = function(accum_value, x)
 		return accum_value
 
 
```
 Preserves the order of elements.
 Type Parameters:
 
 I - input and output element types
 
 Parameters:
 
 iterable - an iterable of type I
 
 initializer - the initializer
 
 function - a function to apply to every pair of subsequent elements
 
 Returns:
 
 the final value
 - reduce
```
public static  I reduce(Function<tuple2<I,I>,I> function,
 java.lang.Iterable iterable)
```
 Applies function of two arguments cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value. For example,
```
 x.reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])
```
 calculates ((((1+2)+3)+4)+5). The left argument, x, is the accumulated value and the right argument, y, is the update value from the iterable. Roughly equivalent to:
```
 
 
 def reduce(function, iterable):
 		it = iter(iterable)
 	try:
 	 initializer = next(it)
 	except StopIteration:
 	 raise TypeError('reduce() of empty sequence with no initial value')
 		accum_value = initializer
 		for x in it:
 			accum_value = function(accum_value, x)
 		return accum_value
 
 
```
 Preserves the order of elements.
 Type Parameters:
 
 I - input and output element types
 
 Parameters:
 
 iterable - an iterable of type I
 
 function - a function to apply to every pair of subsequent elements
 
 Returns:
 
 the final value
 - filter
```
public static <T> java.lang.Iterable<T> filter(Predicate<java.lang.Object> predicate,
 java.lang.Iterable<T> iterable)
```
 Applies the input Predicate to each element of the input Iterable
 
 Type Parameters:
 
 T - element types of the iterable
 
 Parameters:
 
 iterable - an Iterable of type T
 
 predicate - a Predicate
 
 Returns:
 
 a new Iterable containing those elements of the input Iterable for which the predicate is true. Preserves the order of elements.
 - union
```
@SafeVarargs
public static <T> set<T> union(java.lang.Iterable<T>... iterables)
```
 Type Parameters:
 
 T - element type of each input iterable
 
 Parameters:
 
 iterables - an array of Iterables of type <T>
 
 Returns:
 
 Returns a set containing all unique elements from all input Iterables.
 - enumerate
```
public static <T> java.lang.Iterable<tuple2<java.lang.Integer,T>> enumerate(java.lang.Iterable<T> iterable,
 int startCount)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - an Iterable of type T
 
 startCount - the value of index of the first tuple
 
 Returns:
 
 Returns an Iterable of tuples (int index, T value) from the input Iterable of type T. enumerate in xpresso works similarly to Python's enumerate. See the page about Python's enumerate for more details.
 - enumerate
```
public static <T> java.lang.Iterable<tuple2<java.lang.Integer,T>> enumerate(java.lang.Iterable<T> iterable)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - an Iterable of type T
 
 Returns:
 
 Returns an Iterable of tuples (int index, T value) from the input Iterable of type T. enumerate in xpresso works similarly to Python's enumerate. See the page about Python's enumerate for more details.
 - enumerate
```
@SafeVarargs
public static <T> java.lang.Iterable<tuple2<java.lang.Integer,T>> enumerate(T value0,
 T value1,
 T... values)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 value0 - the first value
 
 value1 - the second value
 
 values - the array of all other values
 
 Returns:
 
 Returns an Iterable of tuples (int index, T value) from the input values. enumerate in xpresso works similarly to Python's enumerate. See the page about Python's enumerate for more details.
 - enumerate
```
public static java.lang.Iterable<tuple2<java.lang.Integer,java.lang.String>> enumerate(java.lang.String string,
 int startCount)
```
 Parameters:
 
 string - a String object
 
 startCount - the value if the index of the first tuple in the output Iterable
 
 Returns:
 
 Returns an Iterable of tuples (int index, String character) for the input string, thet iterates over the characters of the string. enumerate in xpresso works similarly to Python's enumerate. See the page about Python's enumerate for more details.
 - enumerate
```
public static java.lang.Iterable<tuple2<java.lang.Integer,java.lang.String>> enumerate(java.lang.String string)
```
 Parameters:
 
 string - a String object
 
 Returns:
 
 Returns an Iterable of tuples (int index, String character) for the input string, thet iterates over the characters of the string. enumerate in xpresso works similarly to Python's enumerate. See the page about Python's enumerate for more details.
 - enumerate
```
public static <T> java.lang.Iterable<tuple2<java.lang.Integer,T>> enumerate(T[] array,
 int startCount)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 array - an array or type T
 
 startCount - the value if the index of the first tuple in the output Iterable
 
 Returns:
 
 Returns an Iterable of tuples (int index, String character) for the input array, thet iterates over the elements of the array. enumerate in xpresso works similarly to Python's enumerate. See the page about Python's enumerate for more details.
 - enumerate
```
public static <T> java.lang.Iterable<tuple2<java.lang.Integer,T>> enumerate(T[] array)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 array - an array of type T
 
 Returns:
 
 Returns an Iterable of tuples (int index, String character) for the input array, thet iterates over the elements of the array. enumerate in xpresso works similarly to Python's enumerate. See the page about Python's enumerate for more details.
 - cycle
```
public static <T> java.lang.Iterable<T> cycle(java.lang.Iterable<T> iterable,
 java.lang.Integer maxCount)
```
 Type Parameters:
 
 T - the type of elements in the input Iterable
 
 Parameters:
 
 iterable - an Iterable
 
 maxCount - the number of repetitions
 
 Returns:
 Makes an Iterable returning elements from the input iterable and saving a copy of each. When the input iterable is exhausted, return elements from the saved copy. Repeats maxCount times. Equivalent to:
 x.cycle(x.listOf("A","B","C","D") --> A B C D A B C D A B C D ...
 - cycle
```
public static <T> java.lang.Iterable<T> cycle(java.lang.Iterable<T> iterable)
```
 Type Parameters:
 
 T - the type of elements in the input Iterable
 
 Parameters:
 
 iterable - an Iterable
 
 Returns:
 Makes an Iterable returning elements from the input iterable and saving a copy of each. When the input iterable is exhausted, return elements from the saved copy. Repeats indifinitely. Equivalent to:
 x.cycle(x.listOf("A","B","C","D") --> A B C D A B C D A B C D ...
 - cycle
```
public static java.lang.Iterable<java.lang.String> cycle(java.lang.String string)
```
 Parameters:
 
 string - a string that contains the characters to repeat
 
 Returns:
 Makes an Iterable returning characters from the input string and saving a copy of these characters. When the above iterable is exhausted, return elements from the saved copy. Repeats indifinitely. Equivalent to:
 x.cycle("ABCD") --> A B C D A B C D A B C D ...
 - cycle
```
public static java.lang.Iterable<java.lang.String> cycle(java.lang.String string,
 int maxCount)
```
 Parameters:
 
 string - a string that contains the characters to repeat
 
 maxCount - the number of repetitions
 
 Returns:
 Makes an Iterable returning characters from the input string and saving a copy of these characters. When the above iterable is exhausted, return elements from the saved copy. Repeats maxCount times. Equivalent to:
 x.cycle("ABCD") --> A B C D A B C D A B C D ...
 - repeat
```
public static <T> java.lang.Iterable<T> repeat(T value,
 java.lang.Integer maxCount)
```
 Type Parameters:
 
 T - the type of the value
 
 Parameters:
 
 value - the value to repeat
 
 maxCount - the number of repetitions
 
 Returns:
 
 Make an Iterable that returns the input value of type T over and over again for maxCount times.
 - repeat
```
public static <T> java.lang.Iterable<T> repeat(T value)
```
 Type Parameters:
 
 T - the type of the value
 
 Parameters:
 
 value - the value to repeat
 
 Returns:
 
 Make an infinite Iterable that returns the input value of type T over and over again.
 - shuffle
```
public static <T> java.lang.Iterable<T> shuffle(java.lang.Iterable<T> iterable)
```
 Suffles the input iterable and returns the shuffled copy.
 
 Type Parameters:
 
 T - the type of elements of the input iterable
 
 Parameters:
 
 iterable - The input Iterable
 
 Returns:
 
 the shuffled copy of the iterable
 - sort
```
public static <T> java.lang.Iterable<T> sort(java.lang.Iterable<T> iterable,
 Function<java.lang.Object,? extends java.lang.Comparable<?>> function,
 boolean reverse)
```
 Sorts the values of the input Iterable of type T according to the evaluation function Function which is applied to each element of the input Iterable.
 
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - an iterable of type T
 
 function - a function that takes an object and retursn a Comparable
 
 reverse - if true, then the values are sorted from biggest to smallest
 
 Returns:
 
 a sorted Iterable of type T
 - sort
```
public static <T> java.lang.Iterable<T> sort(java.lang.Iterable<T> iterable,
 Function<java.lang.Object,? extends java.lang.Comparable<?>> function)
```
 - sort
```
public static <T extends java.lang.Comparable<T>> java.lang.Iterable<T> sort(java.lang.Iterable<T> iterable,
 boolean reverse)
```
 - sort
```
public static <T extends java.lang.Comparable<T>> java.lang.Iterable<T> sort(java.lang.Iterable<T> iterable)
```
 - sort
```
public static str sort(str str,
 Function<java.lang.Object,? extends java.lang.Comparable<?>> function,
 boolean reverse)
```
 - sort
```
public static str sort(str str,
 Function<java.lang.Object,? extends java.lang.Comparable<?>> function)
```
 - sort
```
public static str sort(str str)
```
 - sort
```
public static str sort(str str,
 boolean reverse)
```
 - reverse
```
public static <T> java.lang.Iterable<T> reverse(java.lang.Iterable<T> iterable)
```
 Reverse the order of elements of the input Iterable
 
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - Iterable of type T
 
 Returns:
 
 the input iterable in the reverse order
 - reverse
```
public static str reverse(str str)
```
 Reverse the order of charcters in the input str
 
 Parameters:
 
 str - a str object
 
 Returns:
 
 the input str with the characters in the reverse order
 - largestN
```
public static <T extends java.lang.Comparable<T>> java.lang.Iterable<T> largestN(java.lang.Iterable<T> iterable,
 int N)
```
 Returns the N largest elements of the input Iterable.
 
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - Iterable of type T
 
 N - the desired number of results
 
 Returns:
 
 an Iterable that contains the N largest elements of the input Iterable
 - smallestN
```
public static <T extends java.lang.Comparable<T>> java.lang.Iterable<T> smallestN(java.lang.Iterable<T> iterable,
 int N)
```
 Returns the N smallest elements of the input Iterable.
 
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 N - the desired number of results
 
 iterable - an Iterable of type T
 
 Returns:
 
 an Iterable that contains the N smallest elements of the input Iterable
 - contains
```
public static <T> boolean contains(java.lang.Iterable<T> iterable,
 T value)
```
 Type Parameters:
 
 T - any type
 
 Parameters:
 
 iterable - Iterable of type T
 
 value - a value of type T
 
 Returns:
 
 Only returns true if the input Iterable contains the value.
 - zip
```
public static list<tuple> zip()
```
 Returns:
 This method returns a list of tuples, where the i-th tuple contains the i-th element from each of the argument Iterables. The returned list is truncated in length With a single sequence argument, it returns a list of 1-tuples. With no arguments, it returns an empty list. Example:
 x.print(zip(x.listOf(1,3,5),x.listOf(2,4,6)))
 
 Console: [(1, 2), (3, 4), (5, 6)]
 - zip
```
public static <T0> list<tuple> zip(java.lang.Iterable<T0> iterable0)
```
 Type Parameters:
 T0 - type of Iterable0
 Example: x.print(zip(x.listOf(1,3,5),x.listOf(2,4,6))) Console: [(1, 2), (3, 4), (5, 6)]
 Parameters:
 
 iterable0 - [, iterable1[, iterable2]...]
 
 Returns:
 
 This method returns a list of tuples, where the i-th tuple contains the i-th element from each of the argument Iterables. The returned list is truncated in length With a single sequence argument, it returns a list of 1-tuples. With no arguments, it returns an empty list.
 - zip
```
public static <T0,T1> list<tuple> zip(java.lang.Iterable<T0> iterable0,
 java.lang.Iterable<T1> iterable1)
```
 Type Parameters:
 
 T0 - type of Iterable0
 T1 - type of Iterable1
 Example: x.print(zip(x.listOf(1,3,5),x.listOf(2,4,6))) Console: [(1, 2), (3, 4), (5, 6)]
 Parameters:
 
 iterable0 - [, iterable1[, iterable2]...]
 
 iterable1 - [, iterable2[, iterable3]...]
 
 Returns:
 
 This method returns a list of tuples, where the i-th tuple contains the i-th element from each of the argument Iterables. The returned list is truncated in length With a single sequence argument, it returns a list of 1-tuples. With no arguments, it returns an empty list.
 - zip
```
public static <T0,T1,T2> list<tuple> zip(java.lang.Iterable<T0> iterable0,
 java.lang.Iterable<T1> iterable1,
 java.lang.Iterable<T2> iterable2)
```
 Type Parameters:
 
 T0 - type of Iterable0
 
 T1 - type of Iterable1
 T2 - type of Iterable2
 Example: x.print(zip(x.listOf(1,3,5),x.listOf(2,4,6))) Console: [(1, 2), (3, 4), (5, 6)]
 Parameters:
 
 iterable0 - [, iterable1[, iterable2]...]
 
 iterable1 - [, iterable2[, iterable3]...]
 
 iterable2 - [, iterable3...]
 
 Returns:
 
 This method returns a list of tuples, where the i-th tuple contains the i-th element from each of the argument Iterables. The returned list is truncated in length With a single sequence argument, it returns a list of 1-tuples. With no arguments, it returns an empty list.
 - zip
```
public static <T0,T1,T2,T3> list<tuple> zip(java.lang.Iterable<T0> iterable0,
 java.lang.Iterable<T1> iterable1,
 java.lang.Iterable<T2> iterable2,
 java.lang.Iterable<T3> iterable3)
```
 Type Parameters:
 
 T0 - type of Iterable0
 
 T1 - type of Iterable1
 
 T2 - type of Iterable2
 T3 - type of Iterable3
 Example: x.print(zip(x.listOf(1,3,5),x.listOf(2,4,6))) Console: [(1, 2), (3, 4), (5, 6)]
 Parameters:
 
 iterable0 - [, iterable1[, iterable2]...]
 
 iterable1 - [, iterable2[, iterable3]...]
 
 iterable2 - [, iterable3]
 
 iterable3 - an Iterable
 
 Returns:
 
 This method returns a list of tuples, where the i-th tuple contains the i-th element from each of the argument Iterables. The returned list is truncated in length With a single sequence argument, it returns a list of 1-tuples. With no arguments, it returns an empty list.
 - unzip
```
public static <T0> tuple1<list<T0>> unzip(java.lang.Iterable<tuple> iterable,
 java.lang.Class<T0> class0)
```
 Does the opposite of zip.
```
 
 Example:
 l = x.listOf(x.tupleOf(1,2), x.tupleOf(3,4), x.tupleOf(5,6));
 x.print(x.unzip(l))
 
 Console:
 ([1, 3, 5], [2, 4, 6])
 
 
```
 Type Parameters:
 
 T0 - type of value0 in the tuple
 
 Parameters:
 
 iterable - of tuples
 
 class0 - the class of first element of each tuple in the Iterable
 
 Returns:
 
 a tuple of lists. Each list of type class0, class1, ...
 - unzip
```
public static <T0,T1> tuple2<list<T0>,list<T1>> unzip(java.lang.Iterable<tuple> iterable,
 java.lang.Class<T0> class0,
 java.lang.Class<T1> class1)
```
 Does the opposite of zip.
```
 
 Example:
 l = x.listOf(x.tupleOf(1,2), x.tupleOf(3,4), x.tupleOf(5,6));
 x.print(x.unzip(l))
 
 Console:
 ([1, 3, 5], [2, 4, 6])
 
 
```
 Type Parameters:
 
 T0 - type of value0 in the tuple
 
 T1 - type of value1 in the tuple
 
 Parameters:
 
 iterable - of tuples
 
 class0 - the class of first element of each tuple in the Iterable
 
 class1 - the class of second element of each tuple in the Iterable
 
 Returns:
 
 a tuple of lists. Each list of type class0, class1, ...
 - unzip
```
public static <T0,T1,T2> tuple3<list<T0>,list<T1>,list<T2>> unzip(java.lang.Iterable<tuple> iterable,
 java.lang.Class<T0> class0,
 java.lang.Class<T1> class1,
 java.lang.Class<T2> class2)
```
 Does the opposite of zip.
```
 
 Example:
 l = x.listOf(x.tupleOf(1,2), x.tupleOf(3,4), x.tupleOf(5,6));
 x.print(x.unzip(l))
 
 Console:
 ([1, 3, 5], [2, 4, 6])
 
 
```
 Type Parameters:
 
 T0 - type of value0 in the tuple
 
 T1 - type of value1 in the tuple
 
 T2 - type of value2 in the tuple
 
 Parameters:
 
 iterable - of tuples
 
 class0 - the class of first element of each tuple in the Iterable
 
 class1 - the class of second element of each tuple in the Iterable
 
 class2 - the class of third element of each tuple in the Iterable
 
 Returns:
 
 a tuple of lists. Each list of type class0, class1, ...
 - unzip
```
public static <T0,T1,T2,T3> tuple4<list<T0>,list<T1>,list<T2>,list<T3>> unzip(java.lang.Iterable<tuple> iterable,
 java.lang.Class<T0> class0,
 java.lang.Class<T1> class1,
 java.lang.Class<T2> class2,
 java.lang.Class<T3> class3)
```
 Does the opposite of zip.
```
 
 Example:
 l = x.listOf(x.tupleOf(1,2), x.tupleOf(3,4), x.tupleOf(5,6));
 x.print(x.unzip(l))
 
 Console:
 ([1, 3, 5], [2, 4, 6])
 
 
```
 Type Parameters:
 
 T0 - type of value0 in the tuple
 
 T1 - type of value1 in the tuple
 
 T2 - type of value2 in the tuple
 
 T3 - type of value3 in the tuple
 
 Parameters:
 
 iterable - of tuples
 
 class0 - the class of first element of each tuple in the Iterable
 
 class1 - the class of second element of each tuple in the Iterable
 
 class2 - the class of third element of each tuple in the Iterable
 
 class3 - the class of fourth element of each tuple in the Iterable
 
 Returns:
 
 a tuple of lists. Each list of type class0, class1, ...
 - Json
```
public static <O> Json<O> Json(java.lang.String string)
```
 Factory method that creates a new xpresso Json object from a String.
```
 
 Example:
 String jsonString = x.Json("Hello").toString();
 
 x.print(jsonString);
 
 Console: "Hello"
 
 Compare that with:
 
 x.print("Hello");
 
 Console: Hello
 
 
```
 Type Parameters:
 
 O - the type of the output object
 
 Parameters:
 
 string - a String object
 
 Returns:
 
 a Json object
 - Json
```
public static <O> Json<O> Json(java.util.Map<?,?> o)
```
 Factory method that creates a new xpresso Json object from a Map.
```
 
 Example:
 
 Map<String,Integer> map = Helpers.newHashMap();
 map.put("a",1);
 map.put("b",2);
 String jsonString = x.Json(map).toString();
 
 x.print(jsonString);
 
 Console {"a": 1, "b": 2}
 
 
```
 Type Parameters:
 
 O - the type of the output object
 
 Parameters:
 
 o - a Map object
 
 Returns:
 
 a Json object
 - Json
```
public static <O> Json<O> Json(java.lang.Iterable<?> o)
```
 Factory method that creates a new xpresso Json object from an Iterable.
```
 
 Example 1:
 
 list<String> lst = x.list("a","b","c");
 String jsonString = x.Json(lst).toString();
 
 x.print(jsonString);
 
 Console {"a", "b", "c"}
 
 Example 2:
 dict<Integer> dic = x.list(x.tuple("a":1),x.tuple("b":2));
 String jsonString = x.Json(lst).toString();
 
 x.print(jsonString);
 
 Console {"a": 1, "b": 2}
 
 
```
 Type Parameters:
 
 O - the type of the output object
 
 Parameters:
 
 o - an Iterable
 
 Returns:
 
 a Json object
 - Json
```
public static <O> Json<O> Json(java.lang.Integer v)
```
 Factory method that creates a new xpresso Json object from a tuple.
```
 
 Example:
 
 Map<String,Integer> map = Helpers.newHashMap();
 map.put("a",1);
 map.put("b",2);
 String jsonString = x.Json(map).toString();
 
 x.print(jsonString);
 
 Console {"a": 1, "b": 2}
 
 
```
 Type Parameters:
 
 O - the type of the output object
 
 Parameters:
 
 v - an Integer object
 
 Returns:
 
 a Json object
 - Json
```
public static <O> Json<O> Json(tuple o)
```
 Factory method that creates a new xpresso Json object from a Integer.
 
 Type Parameters:
 
 O - the type of the output object
 
 Parameters:
 
 o - a tuple object
 
 Returns:
 
 a Json object
 - Regex
```
public static Regex Regex(java.lang.String regularExpression,
 int flags)
```
 Factory method that creates a new Regex object from a string regular expression. I takes an optional parameter flags (the same values as Pattern's flags).
```
 
 Example:
 
 Regex mama = x.Regex("\\bmama\\b", Regex.CASE_INSENSITIVE);
 
 
```
 Parameters:
 
 regularExpression - a string with a valid Java regular expression
 
 flags - flags (standard Pattern flags values are accepted)
 
 Returns:
 
 a Regex object
 - Regex
```
public static Regex Regex(java.lang.String regularExpression)
```
 Factory method that creates a new Regex object from a string regular expression. I takes an optional parameter flags (the same values as Pattern's flags).
```
 
 Example:
 
 Regex mama = x.Regex("\\bmama\\b", Regex.CASE_INSENSITIVE);
 
 
```
 Parameters:
 
 regularExpression - a string with a valid Java regular expression
 
 Returns:
 
 a Regex object
 - RegexNoCase
```
public static Regex RegexNoCase(java.lang.String regularExpression)
```
 Factory method that creates a new case insensitive Regex object from a string regular expression.
```
 
 Example:
 
 Regex mama = x.RegexNoCase("\\bmama\\b");
 
 
```
 Parameters:
 
 regularExpression - a string with a valid Java regular expression
 
 Returns:
 
 a Regex object
 - Regex
```
public static Regex Regex(dict<java.lang.String> translator,
 int flags)
```
 Parameters:
 
 translator - a dict with string to string mapping
 
 flags - usual flags of Pattern
 
 Returns:
 Factory method that creates a new Regex object with given optional flags. It takes a dictionary instead of the string and works as follows. The translator dict is a dict<String> that contains pairs of the form: (regular expressions string, replacement string) When you call the Regex.translate(str) or the Regex.translate(String) method of such a Regex object, the algorithms replaces each regular expressions string from the translator dict by the corresponding replacement string.
 Example: dict\<String\> happyReplacer = x.dict(x.tuple("bad","good"),x.tuple("small","big"),x.tuple("hard","easy")); text = x.Regex(happyReplacer).sub(text);
 - Regex
```
public static Regex Regex(dict<java.lang.String> translator)
```
 Parameters:
 
 translator - a dict with string to string mapping
 
 Returns:
 Factory method that creates a new Regex object with given optional flags. It takes a dictionary instead of the string and works as follows. The translator dict is a dict<String> that contains pairs of the form: (regular expressions string, replacement string) When you call the Regex.translate(str) or the Regex.translate(String) method of such a Regex object, the algorithms replaces each regular expressions string from the translator dict by the corresponding replacement string.
 Example: dict\<String\> happyReplacer = x.dict(x.tuple("bad","good"),x.tuple("small","big"),x.tuple("hard","easy")); text = x.Regex(happyReplacer).sub(text);
 - RegexNoCase
```
public static Regex RegexNoCase(dict<java.lang.String> translator)
```
 Parameters:
 
 translator - a dict with string to string mapping
 
 Returns:
 Factory method that creates a new case insensitive Regex object. It takes a dictionary instead of the string and works as follows. The translator dict is a dict<String> that contains pairs of the form: (regular expressions string, replacement string) When you call the Regex.translate(str) or the Regex.translate(String) method of such a Regex object, the algorithms replaces each regular expressions string from the translator dict by the corresponding replacement string.
 Example: dict\<String\> happyReplacer = x.dict(x.tuple("bad","good"),x.tuple("small","big"),x.tuple("hard","easy")); text = x.Regex(happyReplacer).sub(text);
 - slice
```
public Slicer slice(int startIndex,
 int endIndex)
```
 Parameters:
 
 startIndex - a start index for slicing
 
 endIndex - an end index for slicing
 
 Returns:
 Factory method that creates a new Slicer object. Slicer objects can be used as input for the slice method of any Slicable object (like list or str)
 Example: Slice LAST_THREE = x.sliceFrom(-3); x.print(x.String("tic tac toe").slice(LAST_THREE)); Console: toe
 - slice
```
public Slicer slice(int startIndex,
 int endIndex,
 int step)
```
 Parameters:
 
 startIndex - a start index for slicing
 
 step - a step for slicing
 
 endIndex - an end index for slicing
 
 Returns:
 Factory method that creates a new Slicer object. Slicer objects can be used as input for the slice method of any Slicable object (like list or str)
 Example: Slice LAST_THREE = x.sliceFrom(-3); x.print(x.String("tic tac toe").slice(LAST_THREE)); Console: toe
 - slice
```
public Slicer slice()
```
 Returns:
 Factory method that creates a new Slicer object with startIndex = 0 and endIndex=Integer.MAX_VALUE and step=0. Slicer objects can be used as input for the slice method of any Slicable object (like list or str)
 Example: Slice LAST_THREE = x.sliceFrom(-3); x.print(x.String("tic tac toe").slice(LAST_THREE)); Console: toe
 - slice
```
public Slicer slice(int step)
```
 Parameters:
 
 step - the step of slicer
 
 Returns:
 Factory method that creates a new Slicer object with startIndex = 0 and endIndex=Integer.MAX_VALUE the given value of step. Slicer objects can be used as input for the slice method of any Slicable object (like list or str)
 Example: Slice LAST_THREE = x.sliceFrom(-3); x.print(x.String("tic tac toe").slice(LAST_THREE)); Console: toe
 - sliceTo
```
public Slicer sliceTo(int endIndex,
 int step)
```
 Parameters:
 
 step - a step for slicing
 
 endIndex - an end index for slicing
 
 Returns:
 Factory method that creates a new Slicer object with the startIndex=0. Slicer objects can be used as input for the slice method of any Slicable object (like list or str)
 Example: Slice LAST_THREE = x.sliceFrom(-3); x.print(x.String("tic tac toe").slice(LAST_THREE)); Console: toe
 - sliceTo
```
public Slicer sliceTo(int endIndex)
```
 Parameters:
 
 endIndex - an end index for slicing
 
 Returns:
 Factory method that creates a new Slicer object with startIndex=0 and step=1. Slicer objects can be used as input for the slice method of any Slicable object (like list or str)
 Example: Slice LAST_THREE = x.sliceFrom(-3); x.print(x.String("tic tac toe").slice(LAST_THREE)); Console: toe
 - sliceFrom
```
public Slicer sliceFrom(int startIndex,
 int step)
```
 Parameters:
 
 startIndex - a start index for slicing
 
 step - a step for slicing
 
 Returns:
 Factory method that creates a new Slicer object with endIndex=Integer.MAX_VALUE Slicer objects can be used as input for the slice method of any Slicable object (like list or str)
 Example: Slice LAST_THREE = x.sliceFrom(-3); x.print(x.String("tic tac toe").slice(LAST_THREE)); Console: toe
 - sliceFrom
```
public Slicer sliceFrom(int startIndex)
```
 Parameters:
 
 startIndex - a start index for slicing
 
 Returns:
 Factory method that creates a new Slicer object with endIndex=Integer.MAX_VALUE and step=0 Slicer objects can be used as input for the slice method of any Slicable object (like list or str)
 Example: Slice LAST_THREE = x.sliceFrom(-3); x.print(x.String("tic tac toe").slice(LAST_THREE)); Console: toe
 - print
```
public static <T0> void print(T0 object)
```
 A less verbose console print method. Preferred over System.out.println. x.print is also more versatile. It can take values of any type as input.
```
 
 Example:
 
 x.print("Hello World", 1, true, x.list(1, 2, 3), null);
 
 Console: Hello World 1 true [1, 2, 3] NullType
 
 
```
 Type Parameters:
 
 T0 - type of object to print
 
 Parameters:
 
 object - object to print
 - print
```
public static <T0,T1> void print(T0 object0,
 T1 object1)
```
 A less verbose console print method. Preferrred over System.out.println. x.print is also more versatile. It can take values of any type as input.
```
 
 Example:
 
 x.print("Hello World", 1, true, x.list(1, 2, 3), null);
 
 Console: Hello World 1 true [1, 2, 3] NullType
 
 
```
 Type Parameters:
 
 T0 - type of first object to print
 
 T1 - type of second object to print
 
 Parameters:
 
 object0 - first object to print
 
 object1 - second object to print
 - print
```
public static <T0,T1,T2> void print(T0 object0,
 T1 object1,
 T2 object2)
```
 A less verbose console print method. Preferrred over System.out.println. x.print is also more versatile. It can take values of any type as input.
```
 
 Example:
 
 x.print("Hello World", 1, true, x.list(1, 2, 3), null);
 
 Console: Hello World 1 true [1, 2, 3] NullType
 
 
```
 Type Parameters:
 
 T0 - type of first object to print
 
 T1 - type of second object to print
 
 T2 - type of third object to print
 
 Parameters:
 
 object0 - first object to print
 
 object1 - second object to print
 
 object2 - third object to print
 - print
```
public static <T0,T1,T2,T3> void print(T0 object0,
 T1 object1,
 T2 object2,
 T3 object3)
```
 A less verbose console print method. Preferrred over System.out.println. x.print is also more versatile. It can take values of any type as input.
```
 
 Example:
 
 x.print("Hello World", 1, true, x.list(1, 2, 3), null);
 
 Console: Hello World 1 true [1, 2, 3] NullType
 
 
```
 Type Parameters:
 
 T0 - type of first object to print
 
 T1 - type of second object to print
 
 T2 - type of third object to print
 
 T3 - type of fourth object to print
 
 Parameters:
 
 object0 - first object to print
 
 object1 - second object to print
 
 object2 - third object to print
 
 object3 - fourth object to print
 - print
```
public static <T0,T1,T2,T3,T4> void print(T0 object0,
 T1 object1,
 T2 object2,
 T3 object3,
 T4 object4)
```
 A less verbose console print method. Preferrred over System.out.println. x.print is also more versatile. It can take values of any type as input. Example: x.print("Hello World", 1, true, x.list(1, 2, 3), null); Console: Hello World 1 true [1, 2, 3] NullType
 
 Type Parameters:
 
 T0 - type of first object to print
 
 T1 - type of second object to print
 
 T2 - type of third object to print
 
 T3 - type of fourth object to print
 
 T4 - type of fifth object to print
 
 Parameters:
 
 object0 - first object to print
 
 object1 - second object to print
 
 object2 - third object to print
 
 object3 - fourth object to print
 
 object4 - fifth object to print
 - print
```
public static <T0,T1,T2,T3,T4,T5> void print(T0 object0,
 T1 object1,
 T2 object2,
 T3 object3,
 T4 object4,
 T5 object5)
```
 A less verbose console print method. Preferred over System.out.println. x.print is also more versatile. It can take values of any type as input. Example: x.print("Hello World", 1, true, x.list(1, 2, 3), null); Console: Hello World 1 true [1, 2, 3] NullType
 
 Type Parameters:
 
 T0 - type of first object to print
 
 T1 - type of second object to print
 
 T2 - type of third object to print
 
 T3 - type of fourth object to print
 
 T4 - type of fourth object to print
 
 T5 - type of sixth object to print
 
 Parameters:
 
 object0 - first object to print
 
 object1 - second object to print
 
 object2 - third object to print
 
 object3 - fourth object to print
 
 object4 - fifth object to print
 
 object5 - sixth object to print
 - print
```
public static <T0,T1,T2,T3,T4,T5,T6> void print(T0 object0,
 T1 object1,
 T2 object2,
 T3 object3,
 T4 object4,
 T5 object5,
 T6 object6)
```
 A less verbose console print method. Preferrred over System.out.println. x.print is also more versatile. It can take values of any type as input. Example: x.print("Hello World", 1, true, x.list(1, 2, 3), null); Console: Hello World 1 true [1, 2, 3] NullType
 
 Type Parameters:
 
 T0 - type of first object to print
 
 T1 - type of second object to print
 
 T2 - type of third object to print
 
 T3 - type of fourth object to print
 
 T4 - type of fourth object to print
 
 T5 - type of sixth object to print
 
 T6 - type of seventh object to print
 
 Parameters:
 
 object0 - first object to print
 
 object1 - second object to print
 
 object2 - third object to print
 
 object3 - fourth object to print
 
 object4 - fifth object to print
 
 object5 - sixth object to print
 
 object6 - seventh object to print
 - print
```
public static <T0,T1,T2,T3,T4,T5,T6,T7> void print(T0 object0,
 T1 object1,
 T2 object2,
 T3 object3,
 T4 object4,
 T5 object5,
 T6 object6,
 T7 object7)
```
 A less verbose console print method. Preferrred over System.out.println. x.print is also more versatile. It can take values of any type as input. Example: x.print("Hello World", 1, true, x.list(1, 2, 3), null); Console: Hello World 1 true [1, 2, 3] NullType
 
 Type Parameters:
 
 T0 - type of first object to print
 
 T1 - type of second object to print
 
 T2 - type of third object to print
 
 T3 - type of fourth object to print
 
 T4 - type of fourth object to print
 
 T5 - type of sixth object to print
 
 T6 - type of seventh object to print
 
 T7 - type of eighth object to print
 
 Parameters:
 
 object0 - first object to print
 
 object1 - second object to print
 
 object2 - third object to print
 
 object3 - fourth object to print
 
 object4 - fifth object to print
 
 object5 - sixth object to print
 
 object6 - seventh object to print
 
 object7 - eighth object to print
 - print
```
public static <T0,T1,T2,T3,T4,T5,T6,T7,T8> void print(T0 object0,
 T1 object1,
 T2 object2,
 T3 object3,
 T4 object4,
 T5 object5,
 T6 object6,
 T7 object7,
 T8 object8)
```
 A less verbose console print method. Preferrred over System.out.println. x.print is also more versatile. It can take values of any type as input. Example: x.print("Hello World", 1, true, x.list(1, 2, 3), null); Console: Hello World 1 true [1, 2, 3] NullType
 
 Type Parameters:
 
 T0 - type of first object to print
 
 T1 - type of second object to print
 
 T2 - type of third object to print
 
 T3 - type of fourth object to print
 
 T4 - type of fourth object to print
 
 T5 - type of sixth object to print
 
 T6 - type of seventh object to print
 
 T7 - type of eighth object to print
 
 T8 - type of ninth object to print
 
 Parameters:
 
 object0 - first object to print
 
 object1 - second object to print
 
 object2 - third object to print
 
 object3 - fourth object to print
 
 object4 - fifth object to print
 
 object5 - sixth object to print
 
 object6 - seventh object to print
 
 object7 - eighth object to print
 
 object8 - ninth object to print
 - isTrue
```
public static boolean isTrue(java.lang.Object value)
```
 This static method evaluates an input object as true or false. An object is evaluates as true only in following cases: 1) It's an Boolean that equals to false 2) It's an Double that equals to 0.0 3) It's an Double that equals to 0.0 4) It's an Float that equals to 0.0 5) It's an empty String 6) It's an empty Iterable 7) It's a tuple0 8) It's a null 9) It's a Truthful whose isTrue() method returns false
 
 Parameters:
 
 value - the object for which we want to know whther it's true or not
 
 Returns:
 
 true or not
 - isFalse
```
public static boolean isFalse(java.lang.Object value)
```
 This static method evaluates an input object as false or true. An object is evaluates as true only in following cases: 1) It's an Boolean that equals to false 2) It's an Double that equals to 0.0 3) It's an Double that equals to 0.0 4) It's an Float that equals to 0.0 5) It's an empty String 6) It's an empty Iterable 7) It's a tuple0 8) It's a null 9) It's a Truthful whose isTrue() method returns false
 
 Parameters:
 
 value - the object for which we want to know whther it's false or not
 
 Returns:
 
 false or not
 - isEmpty
```
public static boolean isEmpty(java.lang.Object object)
```
 Checks if the input object is empty (does not contains any element).
 
 Parameters:
 
 object - an object to check for emptyness.
 
 Returns:
 
 true or false
 - isNotEmpty
```
public static boolean isNotEmpty(java.lang.Object object)
```
 Checks if the input object is empty (does not contains any element).
 
 Parameters:
 
 object - an object to check for emptyness.
 
 Returns:
 
 true or false
 - memo
```
public static <T> T memo(T object)
```
 Type Parameters:
 
 T - the type of object to memoize
 
 Parameters:
 
 object - an object to memoize
 
 Returns:
 Memoizes an object and returns its memoized version. As a quick example, let
 xerox
 be a Function object whose method
 apply
 copies the string
 "hello"
 the given number
 count
 of times:
 Function<Integer, String> xerox = new Function<Integer, String>() { public String apply(Integer count) { return x.String("hello").times(count); } };
 It's a long to execute function for large values of *count*. In order to avoid the long computation for the same value of *count*, we first create a cached version of xerox using
 x.memo
 :
 Function<Integer,String> cachedXerox = x.memo(xerox);
 The first call of the function. The computation takes a very long time:
 x.timer.start(); String copies = cachedXerox.apply(5000000); x.print(x.timer.stop()); Console: 18.898s
 The second call with the same value of *count*, the result is instantaneous:
 x.timer.start(); String moreCopies = cachedXerox.apply(5000000); x.print(x.timer.stop()); Console: 0.0s
 x.memo can be used to cache methods of object of any Java type, not only Function.
 - escape
```
public static java.lang.String escape(java.lang.String string)
```
 A synonym to x.String.escape(String)
 
 Parameters:
 
 string - a String to escape
 
 Returns:
 
 the escaped string
 - constant
```
public static <T> Function<java.lang.Object,T> constant(T obj)
```
 A Function that always returns the same object no matter the input of the
```
apply
```
 method.
 Type Parameters:
 
 T - the type of returned object
 
 Parameters:
 
 obj - the object to always return
 
 Returns:
 the same object
 obj
 no matter the input of the
 apply
 method.
 - invoke
```
public static <T> Function<java.lang.Object,T> invoke(java.lang.String methodName,
 java.lang.Object... methodParams)
```
 A Function that takes an object's method name and method's parameters values as input, invokes that method with those parameters and the output of invocation.
 
 Type Parameters:
 
 T - the output type
 
 Parameters:
 
 methodName - method name to invoke
 
 methodParams - parameters for the method to invoke
 
 Returns:
 
 the output of invocation
 - add
```
public static <T extends java.lang.Number> Function<tuple2<T,T>,T> add()
```
 A Function that takes a tuple of arguments an adds them up.
 
 Type Parameters:
 
 T - the output (and the input element) type
 
 Returns:
 
 the Function that sums two numbers
 - avg
```
public static <T extends java.lang.Number> Function<tuple2<T,T>,T> avg()
```
 A Function that takes a tuple of arguments an adds them up.
 
 Type Parameters:
 
 T - the output (and the input element) type
 
 Returns:
 
 the Function that averages two numbers
 - min
```
public static <T extends java.lang.Comparable<? super T>> Function<tuple2<T,T>,T> min()
```
 Type Parameters:
 
 T - the output (and the input element) type
 
 Returns:
 
 Function that takes a tuple of arguments an adds them up.
 - max
```
public static <T extends java.lang.Comparable<? super T>> Function<tuple2<T,T>,T> max()
```
 Type Parameters:
 
 T - the output (and the input element) type
 
 Returns:
 
 A Function that takes a tuple of arguments an adds them up.

Class x

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

Assert

String

str

Time

timer

Token

Random

Regex

escape

strip

trim

toLowerCase

lower

toUpperCase

upper

len

doNothing

FALSE

TRUE

empty

isEmpty

getHashCode

Constructor Detail

x

Method Detail

go

Channel

Channel

assertTrue

assertTrue

assertNotNull

assertNotNull

assertNotEmpty

assertNotEmpty

mysql

mysql

Object

open

open

csv

csv

csv

csv

String

String

String

String

str

str

str

set

set

set

set

setOf

list

listOf

list

list

list

yield

yield

yield

asKey

asKey

joinOn

NOT

in

in

in

lambdaP

lambdaP

lambdaF

lambdaF