public InvariantLawsTests(IInvariant <TF> invariant, IEqK <TF> eqK)
{
var invariantLaws = new InvariantLaws <TF>(invariant);
Add("Invariant Identity", args =>
invariantLaws.InvariantIdentity(args.LiftedA).Holds(eqK));
Add("Invariant Composition", args =>
invariantLaws
.InvariantComposition(args.LiftedA, args.FuncAtoB, args.FuncBtoA, args.FuncBtoC, args.FuncCtoB)
.Holds(eqK));
}
public FlatMapLawsTests(IFlatMap <TF> flatMap, IEqK <TF> eqK) : base(flatMap, eqK)
{
var flatMapLaws = new FlatMapLaws <TF>(flatMap);
Add("FlatMap Associativity", args =>
flatMapLaws.FlatMapAssociativity(args.LiftedA, args.FuncAtoLiftedB, args.FuncBtoLiftedC).Holds(eqK));
Add("FlatMap Consistent Apply", args =>
flatMapLaws.FlatMapConsistentApply(args.LiftedA, args.LiftedFuncAtoB).Holds(eqK));
Add("MProduct Consistency", args =>
flatMapLaws.MProductConsistency(args.LiftedA, args.FuncAtoLiftedB).Holds(eqK));
}
public MonadLawsTests(IMonad <TF> monad, IEqK <TF> eqK) : base(monad, eqK)
{
AddRange(new ApplicativeLawsTests <TF, TA, TB, TC>(monad, eqK));
var monadLaws = new MonadLaws <TF>(monad);
Add("Monad Left Identity", args =>
monadLaws.MonadLeftIdentity(args.A, args.FuncAtoLiftedB).Holds(eqK));
Add("Monad Right Identity", args =>
monadLaws.MonadRightIdentity(args.LiftedA).Holds(eqK));
Add("Map and FlatMap Coherence", args =>
monadLaws.MapFlatMapCoherence(args.LiftedA, args.FuncAtoB).Holds(eqK));
}
public ApplyLawsTests(IApply <TF> apply, IEqK <TF> eqK) : base(apply, eqK)
{
var applyLaws = new ApplyLaws <TF>(apply);
Add("Apply Composition", args =>
applyLaws.ApplyComposition(args.LiftedA, args.LiftedFuncAtoB, args.LiftedFuncBtoC).Holds(eqK));
Add("Map2 Product Consistency", args =>
applyLaws
.Map2ProductConsistency(args.LiftedA, args.LiftedB, (a, b) => a.GetHashCode() == b.GetHashCode())
.Holds(eqK));
Add("ProductL Consistency", args =>
applyLaws.ProductLConsistency(args.LiftedA, args.LiftedB).Holds(eqK));
Add("ProductR Consistency", args =>
applyLaws.ProductRConsistency(args.LiftedA, args.LiftedB).Holds(eqK));
}
public ApplicativeLawsTests(IApplicative <TF> applicative, IEqK <TF> eqK) : base(applicative, eqK)
{
var applicativeLaws = new ApplicativeLaws <TF>(applicative);
Add("Applicative Identity", args =>
applicativeLaws.ApplicativeIdentity(args.LiftedA).Holds(eqK));
Add("Applicative Homomorphism", args =>
applicativeLaws.ApplicativeHomomorphism(args.A, args.FuncAtoB).Holds(eqK));
Add("Applicative Interchange", args =>
applicativeLaws.ApplicativeInterchange(args.A, args.LiftedFuncAtoB).Holds(eqK));
Add("Applicative Map", args =>
applicativeLaws.ApplicativeMap(args.LiftedA, args.FuncAtoB).Holds(eqK));
Add("Ap Product Consistent", args =>
applicativeLaws.ApProductConsistent(args.LiftedA, args.LiftedFuncAtoB).Holds(eqK));
}
public FunctorLawsTests(IFunctor <TF> functor, IEqK <TF> eqK) : base(functor, eqK)
{
var functorLaws = new FunctorLaws <TF>(functor);
Add("Covariant Identity", args =>
functorLaws.CovariantIdentity(args.LiftedA).Holds(eqK));
Add("CovariantComposition", args =>
functorLaws.CovariantComposition(args.LiftedA, args.FuncAtoB, args.FuncBtoC).Holds(eqK));
Add("Lift Identity", args =>
functorLaws.LiftIdentity(args.LiftedA).Holds(eqK));
Add("Lift Composition", args =>
functorLaws.LiftComposition(args.LiftedA, args.FuncAtoB, args.FuncBtoC).Holds(eqK));
Add("Void Identity", args =>
functorLaws.VoidIdentity(args.LiftedA).Holds(eqK));
Add("Void Composition", args =>
functorLaws.VoidComposition(args.LiftedA).Holds(eqK));
Add("FProduct Identity", args =>
functorLaws.FProductIdentity(args.LiftedA, args.B).Holds(eqK));
Add("FProduct Composition", args =>
functorLaws
.FProductComposition(args.LiftedA, args.FuncAtoB, ((TA a, TB b)ab) => args.FuncBtoC(ab.b))
.Holds(eqK));
Add("FProductLeft Identity", args =>
functorLaws.FProductLeftIdentity(args.LiftedA, args.B).Holds(eqK));
Add("FProductLeft Composition", args =>
functorLaws
.FProductLeftComposition(args.LiftedA, args.FuncAtoB, ((TB b, TA a)ba) => args.FuncBtoC(ba.b))
.Holds(eqK));
Add("As Identity", args =>
functorLaws.AsIdentity(args.LiftedA, args.B).Holds(eqK));
Add("As Composition", args =>
functorLaws.AsComposition(args.LiftedA, args.B, args.C).Holds(eqK));
Add("TupleLeft Identity", args =>
functorLaws.TupleLeftIdentity(args.LiftedA, args.B).Holds(eqK));
Add("TupleLeft Composition", args =>
functorLaws.TupleLeftComposition(args.LiftedA, args.B, args.C).Holds(eqK));
Add("TupleRight Identity", args =>
functorLaws.TupleRightIdentity(args.LiftedA, args.B).Holds(eqK));
Add("TupleRight Composition", args =>
functorLaws.TupleRightComposition(args.LiftedA, args.B, args.C).Holds(eqK));
Add("Unzip Identity", args =>
functorLaws.UnzipIdentity(args.LiftedA, args.FuncAtoB) switch
{
var(a, b) => a.Holds(eqK) && b.Holds(eqK)
}
public static bool Holds <TF, T>(this IsEq <IKind <TF, T> > self, IEqK <TF> eqK) =>
self switch
{