### Question:
FreeAp implements FreeApOf<F, A> { public static <F extends Witness, T> FreeAp<F, T> pure(T value) { return new FreeAp.Pure<>(value); } private  FreeAp(); abstract FreeAp<F, B> map(Function1<? super A, ? extends B> mapper); FreeAp<F, B> ap(FreeAp<F, Function1<? super A, ? extends B>> apply); Kind<F, A> fold(Applicative<F> applicative); FreeAp<G, A> compile(FunctionK<F, G> transformer); FreeAp<G, A> flatCompile(
      FunctionK<F, Kind<FreeAp_, G>> functionK, Applicative<Kind<FreeAp_, G>> applicative); M analyze(FunctionK<F, Kind<Const_, M>> functionK, Applicative<Kind<Const_, M>> applicative); Free<F, A> monad(); @SuppressWarnings({"rawtypes", "unchecked"}) Kind<G, A> foldMap(FunctionK<F, G> functionK, Applicative<G> applicative); static FreeAp<F, T> pure(T value); static FreeAp<F, T> lift(Kind<F, T> value); static FreeAp<F, R> apply(FreeAp<F, ? extends T> value, 
      FreeAp<F, ? extends Function1<? super T, ? extends R>> mapper); static FunctionK<F, Kind<FreeAp_, G>> functionKF(FunctionK<F, G> functionK); @SuppressWarnings("unchecked") static Applicative<Kind<FreeAp_, F>> applicativeF();  }### Answer:
@Test public void pure() { FreeAp<DSL_, Tuple5<Integer, String, Double, Boolean, Unit>> tuple = applicative.mapN( applicative.pure(1), applicative.pure("string"), applicative.pure(1.1), applicative.pure(true), applicative.pure(unit()), Tuple::of ).fix(toFreeAp()); Kind<Id_, Tuple5<Integer, String, Double, Boolean, Unit>> map = tuple.foldMap(idTransform(), IdInstances.applicative()); assertEquals(Id.of(Tuple.of(1, "string", 1.1, true, unit())), map.fix(toId())); }