|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
NumberType.abs(Object)
NumberType.add(Object, Object)
NumberType.add(Object, Object).
Predicate's Evaluable.eval(Object) and other
Predicate2's Evaluable2.eval(Object,Object) and other
false if its argument is null, or evaluates this predicate,
otherwise.
Applicables are transformations that take one argument and have a
return value, by implementing an Applicable.apply(Object) method.Applicable2s are transformations that take two arguments and have a
return value, by implementing an Applicable2.apply(Object, Object) methodApplicable3s are transformations that take three arguments and have a
return value, by implementing an Applicable3.apply(Object, Object, Object)
methodApplicable is an annotation for abstract types that have
code-block/command/strategy/closure/lambda semantics, with an only abstract
method that implements such code, called applicative method.element
container that is aware of the concept of
contain elements, contains the given element
ContainsAware.contains(Object) message.Delayables are delayed transformations that take one argument and
return a thunk that will perform the processing when evaluated, by
implementing a Delayable.delayed(Object) method.Delayable2s are delayed transformations that two arguments and return
a thunk that will perform the actual processing when evaluated, by
implementing a Delayable2.delayed(Object, Object) method.Delayable3s are delayed transformations that take three arguments and
return a thunk that will perform the actual processing when evaluated, by
implementing a Delayable3.delayed(Object, Object, Object) method.Delayable, by returning a Thunk
that will perform the actual transformation each time it is evaluated.
Delayable2, by returning a
Thunk that will perform the actual transformation each time it is
evaluated.
Delayable3, by returning a
Thunk that will perform the actual transformation each time it is
evaluated.
Delayable on the thunk's value, by
returning a Thunk that will perform the actual transformation each
time it is evaluated.
Delayable2, by returning a
Thunk that will perform the actual transformation on the given
thunk's values each time it is evaluated.
Delayable3, by returning a
Thunk that will perform the actual transformation on the given
thunk's values each time it is evaluated.
EmptyAware.isEmpty() message.Evaluables are boolean conditions over an argument that can be tested
using its Evaluable.eval(Object) message.Evaluable2s are boolean conditions over two argument that can be
tested using its Evaluable2.eval(Object, Object) message.Executables are computations that take one argument and whose result
is a side effect, instead of a return value.Executable2s are computations that take two arguments and whose
result is a side effect, instead of a return value.Executable3s are computations that take three arguments and whose
result is a side effect, instead of a return value.predicate
Executable for each element in this
ProtoMonad.
NumberType
Functions are rich interfaced Applicables - one argument
composable, Delayable and NullSafeAware tranformations.Function2s are rich interfaced Applicable2s - two arguments
Delayable2 and NullSafeAware transformations.Function3s are rich interfaced Applicable3s - two arguments
Delayable3 and NullSafeAware transformations.Number x, a side-effect-free NumberTypes nt
must grant that
nt.increment(x) == nt.add(x, nt.one())
As a particular case, it must grant that
nt.compare(nt.one(), nt.increment(nt.zero())) == 0
NumberType with extra messages restricted to integral types like
integers and BigIntegersn^-1
For any number x for which division is defined, a NumberType nt
must grant that
nt.divide(nt.one(), x).compareTo(nt.inverse(x)) == 0
NumberType.inverse(Object)
EmptyAware is empty.
SizeAware is empty.
IntegralType.isEven(Object)
Number x, a NumberTypes nt must
grant that nt.isZero(x) == (nt.compare(x, zero()) < 0)
IntegralType.isOdd(Object)
Number x, a NumberTypes nt must
grant that nt.isZero(x) == (nt.compare(x, zero()) > 0)
NumberType.multiply(Object, Object)
NumberType.negate(Object)
Predicate
Predicate
NullSafe restriction annotates Applicatives that can handle
nulls as arguments, that is, that will not throw a
NullPointerException or IllegalArgumentException if any of
its arguments is nullApplicative of type A that accepts nulls for
its applicative method, that is, it will not throw any exception if any of
its arguments is null.
Predicate2 that returns true if both
arguments are null, false if only one of them is
null, or evalutes this predicate, otherwise.
NullSafeAwares are object that may be converted to an
Applicative object of type A that is NullSafe, that
is, that accepts nulls in its applicative method.Numbers is a polymorphic way.Applicable, resulting in a new
Function that when applied returns
this.apply(other.apply(arg)
Applicable2, resulting in a new
Function2 that when applied returns
this.apply(other.apply(arg0, arg1)
Applicable3, resulting in a new
Function3 that when applied returns
this.apply(other.apply(arg0,arg1,arg2)
Applicable, resulting in a new
Predicate that when applied returns
this.eval(other.apply(arg)
Reduction that will apply this reduction to the results of
applying the given function to each element
For example, the following code:
Reductions.
NumberType
Predicate's Evaluable.eval(Object) and other
Predicate2's Evaluable2.eval(Object,Object) and other
true if its argument is null, or evaluates this predicate,
otherwise.
EvaluableEvaluable2Reduction are aggregate-functions-like objects that encapsulates a
computation with effect that processes each element of a sequence of objects,
calculating intermediate, accumulative results.IntegralType.remainder(Object, Object)
replacement
replacement
Tuple3 components to left, creating a new one where
the first component is placed at the third position, an the rests, shifted
right.
Tuple3 components to right, creating a new one where
the third component is placed at the first position, an the rests, shifted
right.
SizeAware.size() message.filter(Predicates.notNull())
Tuple2, with swaped components
Predicate.of(Applicable), but with
receptor and argument interchanged.
Function.of(Applicable2), but with
receptor and argument interchanged.
this function with
other function, using a binaryFunction to merge
the results.
Reduction that applies the function to the resulting
element of the reduction
For example, the following code:
Reductions.
Thunk is a computation that takes no arguments a returns a value.Function that takes a
single pair, being its components each of the original function parameters
Function that takes a
single triple, being its components each of the original function
parameters
Predicate that takes a single pair, being
its components each of the original predicate parameters
false
true
NumberType
FirstAware.first()
SecondAware.second()
ThirdAware.third()
FourthAware.fourth()
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||