WriterExample.java

A pricing calculation that produces both a final price and a step-by-step receipt.

Step 1 -- Set up the Monoid and Monad

import static org.higherkindedj.hkt.writer.WriterKindHelper.*;

// Monoid that combines log strings by concatenation
Monoid<String> logMonoid = new Monoid<>() {
    public String empty() { return ""; }
    public String combine(String x, String y) { return x + y; }
};

var monad = new WriterMonad<>(logMonoid);

Step 2 -- Define pricing steps as functions

Each step returns a Writer: the result and a log entry. No log parameter needed.

// Each function: takes a price, returns Writer(log, newPrice)
Function<Double, Kind<WriterKind.Witness<String>, Double>> addTax = price -> {
    var taxed = price * 1.08;
    return WRITER.widen(new Writer<>(
        "Tax 8%%: $%.2f -> $%.2f; ".formatted(price, taxed), taxed));
};

Function<Double, Kind<WriterKind.Witness<String>, Double>> applyDiscount = price -> {
    var discounted = price * 0.90;
    return WRITER.widen(new Writer<>(
        "Discount 10%%: $%.2f -> $%.2f; ".formatted(price, discounted), discounted));
};

Function<Double, Kind<WriterKind.Witness<String>, Double>> addShipping = price -> {
    var shipped = price + 5.00;
    return WRITER.widen(new Writer<>(
        "Shipping: +$5.00 -> $%.2f; ".formatted(shipped), shipped));
};

Step 3 -- Compose the pipeline

flatMap threads the value forward and accumulates the log at each step.

// Start with subtotal $100, log the starting point
var start = monad.flatMap(
    ignored -> WRITER.value(logMonoid, 100.0),
    WRITER.tell("Subtotal: $100.00; ")
);

// Chain: tax -> discount -> shipping
var afterTax      = monad.flatMap(addTax, start);
var afterDiscount = monad.flatMap(applyDiscount, afterTax);
var finalPrice    = monad.flatMap(addShipping, afterDiscount);

Step 4 -- Extract the results

// Get just the final price
Double price = WRITER.run(finalPrice);
// --> 102.06

// Get just the receipt log
String receipt = WRITER.exec(finalPrice);
// --> "Subtotal: $100.00; Tax 8%: ... Discount 10%: ... Shipping: ..."

// Get both as a Writer record
var result = WRITER.runWriter(finalPrice);
System.out.println("Receipt: " + result.log());
System.out.println("Total:   $" + result.value());

Every step is a pure function. The log is never passed as a parameter -- Writer carries it invisibly. The receipt and the price arrive together at the end.

Writer has dedicated JMH benchmarks measuring log accumulation overhead, Monoid combination cost, and chain depth. Key expectations:

• Pure value operations (map, of) are fast -- they don't invoke the Monoid
• flatMap chains incur Monoid combination cost at each step -- use an efficient Monoid (e.g., StringBuilder or list append rather than string concatenation for long logs)
• Deep chains scale linearly with the Monoid's combine cost

./gradlew :hkj-benchmarks:jmh --includes=".*WriterBenchmark.*"

See Benchmarks & Performance for full details and how to interpret results.