fj.Equal Maven / Gradle / Ivy
package fj;
import fj.data.*;
import fj.data.hamt.BitSet;
import fj.data.hlist.HList;
import fj.data.optic.Traversal;
import fj.data.vector.V2;
import fj.data.vector.V3;
import fj.data.vector.V4;
import fj.data.vector.V5;
import fj.data.vector.V6;
import fj.data.vector.V7;
import fj.data.vector.V8;
import fj.parser.Result;
import java.math.BigDecimal;
import java.math.BigInteger;
import static fj.Function.compose;
import static fj.Function.constant;
import static fj.Function.curry;
/**
* Tests for equality between two objects.
*
* @version %build.number%
*/
public final class Equal {
/**
* Primitives functions of Equal: minimal definition and overridable methods.
*/
public interface Definition {
F equal(A a);
default boolean equal(A a1, A a2) {
return equal(a1).f(a2);
}
/**
* Refine this equal definition, to tests equality of self and the mapped object in "and" manner.
* @see #equal()
*
* @param f The function to map the original object
* @param eq Equality for the mapped object
* @return A new equal definition
*/
default Definition then(final F f, final Equal eq) {
Definition bEqDef = eq.def;
return new Definition() {
@Override
public F equal(A a1) {
F fa = Definition.this.equal(a1);
F fb = bEqDef.equal(f.f(a1));
return a2 -> fa.f(a2) && fb.f(f.f(a2));
}
@Override
public boolean equal(A a1, A a2) {
return Definition.this.equal(a1, a2) && bEqDef.equal(f.f(a1), f.f(a2));
}
};
}
/**
* Build an equal instance from this definition.
* to be called after some successive {@link #then(F, Equal)} calls.
*/
default Equal equal() {
return equalDef(this);
}
}
/**
* Primitives functions of Equal: alternative minimal definition and overridable methods.
*/
public interface AltDefinition extends Definition {
@Override
boolean equal(A a1, A a2);
@Override
default F equal(A a) {
return a2 -> equal(a, a2);
}
}
private final Definition def;
private Equal(final Definition def) {
this.def = def;
}
/**
* Returns true if the two given arguments are equal, false otherwise.
*
* @param a1 An object to test for equality against another.
* @param a2 An object to test for equality against another.
* @return true if the two given arguments are equal, false otherwise.
*/
public boolean eq(final A a1, final A a2) {
return def.equal(a1, a2);
}
/**
* Returns true if the two given arguments are not equal, false otherwise.
*
* @param a1 An object to test for inequality against another.
* @param a2 An object to test for inequality against another.
* @return true if the two given arguments are not equal, false otherwise.
*/
public boolean notEq(final A a1, final A a2) {
return !def.equal(a1, a2);
}
/**
* First-class equality check.
*
* @return A function that returns true if the two given arguments are equal.
*/
public F2 eq() {
return def::equal;
}
/**
* Partially applied equality check.
*
* @param a An object to test for equality against another.
* @return A function that returns true if the given argument equals the argument to this method.
*/
public F eq(final A a) {
return def.equal(a);
}
/**
* Maps the given function across this equal as a contra-variant functor.
*
* @param f The function to map.
* @return A new equal.
*/
public Equal contramap(final F f) {
return equalDef(contramapDef(f, def));
}
/**
* An equal instance, which reverts equality for self
*
* @return A new equal instance
*/
public final Equal not() {
return equalDef((a1, a2) -> !def.equal(a1, a2));
}
private static Definition contramapDef(F f, Definition aEqDef) {
return new Definition(){
@Override
public F equal(B b) {
return compose(aEqDef.equal(f.f(b)), f);
}
@Override
public boolean equal(B b1, B b2) {
return aEqDef.equal(f.f(b1), f.f(b2));
}
};
}
/**
* Static version of {@link #contramap(F)}
*/
public static Equal contramap(final F f, final Equal eq) {
return eq.contramap(f);
}
/**
* Begin definition of an equal instance.
* @see Definition#then(F, Equal)
*/
public static Definition on(final F f, final Equal eq) {
return contramapDef(f, eq.def);
}
/**
* Constructs an equal instance from the given function.
*
* Java 8+ users: use {@link #equalDef(Definition)} instead.
*
* @param f The function to construct the equal with.
* @return An equal instance from the given function.
*/
public static Equal equal(final F> f) {
return new Equal<>(f::f);
}
/**
* Constructs an equal instance from the given function.
*
* Java 8+ users: use {@link #equalDef(AltDefinition)} instead.
*
* @param f The function to construct the equal with.
* @return An equal instance from the given function.
*/
public static Equal equal(final F2 f) {
return equalDef(f::f);
}
/**
* Constructs an equal instance from the given definition.
*
* @param definition a definition of the equal instance.
* @return An equal instance from the given function.
*/
public static Equal equalDef(final Definition definition) {
return new Equal<>(definition);
}
/**
* Constructs an equal instance from the given (alternative) definition.
*
* @param definition a definition of the equal instance.
* @return An equal instance from the given function.
*/
public static Equal equalDef(final AltDefinition definition) {
return new Equal<>(definition);
}
/**
* Returns an equal instance that uses the {@link Object#equals(Object)} method to test for
* equality.
*
* @return An equal instance that uses the {@link Object#equals(Object)} method to test for
* equality.
*/
public static Equal anyEqual() {
return equalDef(new Definition() {
@Override
public F equal(A a) {
return a::equals;
}
@Override
public boolean equal(A a1, A a2) {
return a1.equals(a2);
}
});
}
/**
* An equal instance for the boolean type.
*/
public static final Equal booleanEqual = anyEqual();
/**
* An equal instance for the byte type.
*/
public static final Equal byteEqual = anyEqual();
/**
* An equal instance for the char type.
*/
public static final Equal charEqual = anyEqual();
/**
* An equal instance for the double type.
*/
public static final Equal doubleEqual = anyEqual();
/**
* An equal instance for the float type.
*/
public static final Equal floatEqual = anyEqual();
/**
* An equal instance for the int type.
*/
public static final Equal intEqual = anyEqual();
/**
* An equal instance for the BigInteger type.
*/
public static final Equal bigintEqual = anyEqual();
/**
* An equal instance for the BigDecimal type.
*/
public static final Equal bigdecimalEqual = anyEqual();
/**
* An equal instance for the long type.
*/
public static final Equal longEqual = anyEqual();
/**
* An equal instance for the short type.
*/
public static final Equal shortEqual = anyEqual();
/**
* An equal instance for the Natural type.
*/
public static final Equal naturalEqual = bigintEqual.contramap(Natural::bigIntegerValue);
/**
* An equal instance for the {@link String} type.
*/
public static final Equal stringEqual = anyEqual();
/**
* An equal instance for the {@link StringBuffer} type.
*/
public static final Equal stringBufferEqual =
equalDef((sb1, sb2) -> {
if (sb1.length() == sb2.length()) {
for (int i = 0; i < sb1.length(); i++)
if (sb1.charAt(i) != sb2.charAt(i))
return false;
return true;
} else
return false;
});
/**
* An equal instance for the {@link StringBuilder} type.
*/
public static final Equal stringBuilderEqual =
equalDef((sb1, sb2) -> {
if (sb1.length() == sb2.length()) {
for (int i = 0; i < sb1.length(); i++)
if (sb1.charAt(i) != sb2.charAt(i))
return false;
return true;
} else
return false;
});
/**
* An equal instance for the {@link BitSet} type.
*/
public static final Equal bitSetSequal = equalDef((bs1, bs2) -> bs1.longValue() == bs2.longValue());
/**
* An equal instance for the {@link Either} type.
*
* @param ea Equality across the left side of {@link Either}.
* @param eb Equality across the right side of {@link Either}.
* @return An equal instance for the {@link Either} type.
*/
public static Equal> eitherEqual(final Equal ea, final Equal eb) {
Definition eaDef = ea.def;
Definition ebDef = eb.def;
return equalDef(e1 -> e1.either(
a1 -> Either.either_(eaDef.equal(a1), (B __) -> false),
b1 -> Either.either_((A __)-> false, ebDef.equal(b1))
));
}
public static Equal> resultEqual(final Equal ea, final Equal ei) {
Definition eaDef = ea.def;
Definition eiDef= ei.def;
return equalDef((r1, r2) -> eaDef.equal(r1.value(), r2.value()) && eiDef.equal(r1.rest(), r2.rest()));
}
/**
* An equal instance for the {@link Validation} type.
*
* @param ea Equality across the failing side of {@link Validation}.
* @param eb Equality across the succeeding side of {@link Validation}.
* @return An equal instance for the {@link Validation} type.
*/
public static Equal> validationEqual(final Equal ea, final Equal eb) {
return eitherEqual(ea, eb).contramap(Validation.either());
}
/**
* An equal instance for the {@link List} type.
*
* @param ea Equality across the elements of the list.
* @return An equal instance for the {@link List} type.
*/
public static Equal> listEqual(final Equal ea) {
Definition eaDef = ea.def;
return equalDef((a1, a2) -> {
List x1 = a1;
List x2 = a2;
while (x1.isNotEmpty() && x2.isNotEmpty()) {
if (!eaDef.equal(x1.head(), x2.head()))
return false;
x1 = x1.tail();
x2 = x2.tail();
}
return x1.isEmpty() && x2.isEmpty();
});
}
/**
* An equal instance for the {@link NonEmptyList} type.
*
* @param ea Equality across the elements of the non-empty list.
* @return An equal instance for the {@link NonEmptyList} type.
*/
public static Equal> nonEmptyListEqual(final Equal ea) {
return listEqual(ea).contramap(NonEmptyList.toList_());
}
/**
* An equal instance for the {@link Option} type.
*
* @param ea Equality across the element of the option.
* @return An equal instance for the {@link Option} type.
*/
public static Equal> optionEqual(final Equal ea) {
Definition eaDef = ea.def;
return equalDef(o1 -> o1.option(
Option.isNone_(),
a1 -> Option.option_(false, eaDef.equal(a1))
));
}
public static Equal> seqEqual(final Equal e) {
return streamEqual(e).contramap(Seq::toStream);
}
/**
* An equal instance for the {@link Stream} type.
*
* @param ea Equality across the elements of the stream.
* @return An equal instance for the {@link Stream} type.
*/
public static Equal> streamEqual(final Equal ea) {
Definition eaDef = ea.def;
return equalDef((a1, a2) -> {
Stream x1 = a1;
Stream x2 = a2;
while (x1.isNotEmpty() && x2.isNotEmpty()) {
if (!eaDef.equal(x1.head(), x2.head()))
return false;
x1 = x1.tail()._1();
x2 = x2.tail()._1();
}
return x1.isEmpty() && x2.isEmpty();
});
}
/**
* An equal instance for the {@link Zipper} type.
*
* @param ea Equality across the elements of the zipper.
* @return An equal instance for the {@link Zipper} type.
*/
public static Equal> zipperEqual(final Equal ea) {
Equal> se = Equal.streamEqual(ea);
return equalDef((a1, a2) ->
se.eq(a1.lefts(), a2.lefts()) &&
ea.eq(a1.focus(), a2.focus()) &&
se.eq(a1.rights(), a2.rights())
);
}
/**
* An equal instance for the {@link TreeZipper} type.
*
* @param ea Equality across the elements of the tree zipper.
* @return An equal instance for the {@link TreeZipper} type.
*/
public static Equal> treeZipperEqual(final Equal ea) {
final Equal> te = Equal.treeEqual(ea);
final Equal>> st = streamEqual(Equal.treeEqual(ea));
final Equal>, A, Stream>>>> sp =
streamEqual(p3Equal(streamEqual(treeEqual(ea)), ea, streamEqual(treeEqual(ea))));
return equalDef((a1, a2) ->
te.eq(a1.focus(), a2.focus()) &&
st.eq(a1.lefts(), a2.lefts()) &&
st.eq(a1.rights(), a2.rights()) &&
sp.eq(a1.parents(), a2.parents())
);
}
/**
* An equal instance for the {@link Array} type.
*
* @param ea Equality across the elements of the array.
* @return An equal instance for the {@link Array} type.
*/
public static Equal> arrayEqual(final Equal ea) {
Definition eaDef = ea.def;
return equalDef((a1, a2) -> {
if (a1.length() == a2.length()) {
for (int i = 0; i < a1.length(); i++) {
if (!eaDef.equal(a1.get(i), a2.get(i)))
return false;
}
return true;
} else
return false;
});
}
/**
* An equal instance for the {@link Tree} type.
*
* @param ea Equality across the elements of the tree.
* @return An equal instance for the {@link Tree} type.
*/
public static Equal> treeEqual(final Equal ea) {
Definition eaDef = ea.def;
return equalDef(new AltDefinition>() {
final Definition>>> subForestEqDef = p1Equal(streamEqual(equalDef(this))).def;
@Override
public boolean equal(Tree t1, Tree t2) {
return eaDef.equal(t1.root(), t2.root())
&& subForestEqDef.equal(t1.subForest(), t2.subForest());
}
});
}
/**
* An equal instance for a product-1.
*
* @param ea Equality across the first element of the product.
* @return An equal instance for a product-1.
*/
public static Equal> p1Equal(final Equal ea) {
return ea.contramap(P1.__1());
}
/**
* An equal instance for a product-2.
*
* @param ea Equality across the first element of the product.
* @param eb Equality across the second element of the product.
* @return An equal instance for a product-2.
*/
public static Equal> p2Equal(final Equal ea, final Equal eb) {
Definition eaDef = ea.def;
Definition ebDef = eb.def;
return equalDef((p1, p2)-> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()));
}
/**
* An equal instance for a product-3.
*
* @param ea Equality across the first element of the product.
* @param eb Equality across the second element of the product.
* @param ec Equality across the third element of the product.
* @return An equal instance for a product-3.
*/
public static Equal> p3Equal(final Equal ea, final Equal eb, final Equal ec) {
Definition eaDef = ea.def;
Definition ebDef = eb.def;
Definition ecDef = ec.def;
return equalDef((p1, p2) -> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()) && ecDef.equal(p1._3(), p2._3()));
}
/**
* An equal instance for a product-4.
*
* @param ea Equality across the first element of the product.
* @param eb Equality across the second element of the product.
* @param ec Equality across the third element of the product.
* @param ed Equality across the fourth element of the product.
* @return An equal instance for a product-4.
*/
public static Equal> p4Equal(final Equal ea, final Equal eb, final Equal ec,
final Equal ed) {
Definition eaDef = ea.def;
Definition ebDef = eb.def;
Definition ecDef = ec.def;
Definition edDef = ed.def;
return equalDef((p1, p2) -> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()) && ecDef.equal(p1._3(), p2._3()) &&
edDef.equal(p1._4(), p2._4()));
}
/**
* An equal instance for a product-5.
*
* @param ea Equality across the first element of the product.
* @param eb Equality across the second element of the product.
* @param ec Equality across the third element of the product.
* @param ed Equality across the fourth element of the product.
* @param ee Equality across the fifth element of the product.
* @return An equal instance for a product-5.
*/
public static Equal> p5Equal(final Equal ea, final Equal eb,
final Equal ec, final Equal ed,
final Equal ee) {
Definition eaDef = ea.def;
Definition ebDef = eb.def;
Definition ecDef = ec.def;
Definition edDef = ed.def;
Definition eeDef = ee.def;
return equalDef((p1, p2) -> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()) && ecDef.equal(p1._3(), p2._3()) &&
edDef.equal(p1._4(), p2._4()) && eeDef.equal(p1._5(), p2._5()));
}
/**
* An equal instance for a product-6.
*
* @param ea Equality across the first element of the product.
* @param eb Equality across the second element of the product.
* @param ec Equality across the third element of the product.
* @param ed Equality across the fourth element of the product.
* @param ee Equality across the fifth element of the product.
* @param ef Equality across the sixth element of the product.
* @return An equal instance for a product-6.
*/
public static Equal> p6Equal(final Equal ea, final Equal eb,
final Equal ec, final Equal ed,
final Equal ee, final Equal ef) {
Definition eaDef = ea.def;
Definition ebDef = eb.def;
Definition ecDef = ec.def;
Definition edDef = ed.def;
Definition eeDef = ee.def;
Definition efDef = ef.def;
return equalDef((p1, p2) -> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()) && ecDef.equal(p1._3(), p2._3()) &&
edDef.equal(p1._4(), p2._4()) && eeDef.equal(p1._5(), p2._5()) && efDef.equal(p1._6(), p2._6()));
}
/**
* An equal instance for a product-7.
*
* @param ea Equality across the first element of the product.
* @param eb Equality across the second element of the product.
* @param ec Equality across the third element of the product.
* @param ed Equality across the fourth element of the product.
* @param ee Equality across the fifth element of the product.
* @param ef Equality across the sixth element of the product.
* @param eg Equality across the seventh element of the product.
* @return An equal instance for a product-7.
*/
public static Equal> p7Equal(final Equal ea, final Equal eb,
final Equal ec, final Equal ed,
final Equal ee, final Equal ef,
final Equal eg) {
Definition eaDef = ea.def;
Definition ebDef = eb.def;
Definition ecDef = ec.def;
Definition edDef = ed.def;
Definition eeDef = ee.def;
Definition efDef = ef.def;
Definition egDef = eg.def;
return equalDef((p1, p2) -> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()) && ecDef.equal(p1._3(), p2._3()) &&
edDef.equal(p1._4(), p2._4()) && eeDef.equal(p1._5(), p2._5()) && efDef.equal(p1._6(), p2._6()) &&
egDef.equal(p1._7(), p2._7()));
}
/**
* An equal instance for a product-8.
*
* @param ea Equality across the first element of the product.
* @param eb Equality across the second element of the product.
* @param ec Equality across the third element of the product.
* @param ed Equality across the fourth element of the product.
* @param ee Equality across the fifth element of the product.
* @param ef Equality across the sixth element of the product.
* @param eg Equality across the seventh element of the product.
* @param eh Equality across the eighth element of the product.
* @return An equal instance for a product-8.
*/
public static Equal> p8Equal(final Equal ea,
final Equal eb,
final Equal ec,
final Equal ed,
final Equal ee,
final Equal ef,
final Equal eg,
final Equal eh) {
Definition eaDef = ea.def;
Definition ebDef = eb.def;
Definition ecDef = ec.def;
Definition edDef = ed.def;
Definition eeDef = ee.def;
Definition efDef = ef.def;
Definition egDef = eg.def;
Definition ehDef = eh.def;
return equalDef(
(p1, p2) -> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()) && ecDef.equal(p1._3(), p2._3()) &&
edDef.equal(p1._4(), p2._4()) && eeDef.equal(p1._5(), p2._5()) && efDef.equal(p1._6(), p2._6()) &&
egDef.equal(p1._7(), p2._7()) && ehDef.equal(p1._8(), p2._8()));
}
/**
* An equal instance for a vector-2.
*
* @param ea Equality across the elements of the vector.
* @return An equal instance for a vector-2.
*/
public static Equal> v2Equal(final Equal ea) {
return streamEqual(ea).contramap(V2.toStream_());
}
/**
* An equal instance for a vector-3.
*
* @param ea Equality across the elements of the vector.
* @return An equal instance for a vector-3.
*/
public static Equal> v3Equal(final Equal ea) {
return streamEqual(ea).contramap(V3.toStream_());
}
/**
* An equal instance for a vector-4.
*
* @param ea Equality across the elements of the vector.
* @return An equal instance for a vector-4.
*/
public static Equal> v4Equal(final Equal ea) {
return streamEqual(ea).contramap(V4.toStream_());
}
/**
* An equal instance for a vector-5.
*
* @param ea Equality across the elements of the vector.
* @return An equal instance for a vector-5.
*/
public static Equal> v5Equal(final Equal ea) {
return streamEqual(ea).contramap(V5.toStream_());
}
/**
* An equal instance for a vector-6.
*
* @param ea Equality across the elements of the vector.
* @return An equal instance for a vector-6.
*/
public static Equal> v6Equal(final Equal ea) {
return streamEqual(ea).contramap(V6.toStream_());
}
/**
* An equal instance for a vector-7.
*
* @param ea Equality across the elements of the vector.
* @return An equal instance for a vector-7.
*/
public static Equal> v7Equal(final Equal ea) {
return streamEqual(ea).contramap(V7.toStream_());
}
/**
* An equal instance for a vector-8.
*
* @param ea Equality across the elements of the vector.
* @return An equal instance for a vector-8.
*/
public static Equal> v8Equal(final Equal ea) {
return streamEqual(ea).contramap(V8.toStream_());
}
/**
* An equal instance for lazy strings.
*/
public static final Equal eq = streamEqual(charEqual).contramap(LazyString::toStream);
/**
* An equal instance for the empty heterogeneous list.
*/
public static final Equal hListEqual = anyEqual();
/**
* An equal instance for heterogeneous lists.
*
* @param e Equality for the first element of the list.
* @param l Equality for the rest of the list.
* @return an equal instance for a heterogeneous list.
*/
public static > Equal> hListEqual(final Equal e, final Equal l) {
Definition eDef = e.def;
Definition lDef = l.def;
return equalDef((c1, c2) -> eDef.equal(c1.head(), c2.head()) && lDef.equal(c1.tail(), c2.tail()));
}
/**
* Equal instance for sets.
*
* @param e Equality for the set elements.
* @return An equal instance for sets.
*/
public static Equal> setEqual(final Equal e) {
return streamEqual(e).contramap(Set::toStream);
}
public static Equal> treeMapEqual(Equal k, Equal v) {
return streamEqual(p2Equal(k, v)).contramap(TreeMap::toStream);
}
public static Equal> writerEqual(Equal eq1, Equal eq2) {
return p2Equal(eq1, eq2).contramap(Writer::run);
}
/**
* Helper method to implement {@link Object#equals(Object)} correctly. DO NOT USE it for any other purpose.
*
* @param clazz the class in which the {@link Object#equals(Object)} is implemented
* @param self a reference to 'this'
* @param other the other object of the comparison
* @param equal an equal instance for the type of self (that use {@link #anyEqual()} if generic type).
* @return true if self and other are equal
*/
@SuppressWarnings("unchecked")
public static boolean equals0(final java.lang.Class clazz, final A self, final Object other, final Equal equal) {
return self == other || clazz.isInstance(other) && equal.eq(self, (A) other);
}
/**
* Helper method to implement {@link Object#equals(Object)} correctly. DO NOT USE it for any other purpose.
*
* @param clazz the class in which the {@link Object#equals(Object)} is implemented
* @param self a reference to 'this'
* @param other the other object of the comparison
* @param equal a lazy equal instance for the type (that use {@link #anyEqual()} if generic type)..
* @return true if self and other are equal
*/
@SuppressWarnings("unchecked")
public static boolean equals0(final java.lang.Class clazz, final A self, final Object other, final F0> equal) {
return self == other || clazz.isInstance(other) && equal.f().eq(self, (A) other);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy