public class ImpureToggle<T> implements Supplier<T> {
    //false represents state a, true represents state b
    private boolean state;
    private final T a;
    private final T b;

    public ImpureToggle(T a, T b) {
        this.a = a;
        this.b = b;
    }

    // returns a different reference depending on internal state
    @Override
    public T get() {
        return state ? b : a;
    }

    public void toggle() {
        state = state ? false : true;
    }
}

public class ConsumerToggle<T> implements Consumer<Consumer<T>> {
    private final T a;
    private final T b;
    //false represents state a, true represents state b
    private boolean state;

    public ConsumerToggle(T a, T b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public void accept(Consumer<T> t) {
        t.accept(state ? b : a);
    }

    public void toggle() {
        state = state ? false : true;
    }
}

public interface ImpureStaticToggle {
    // reassigns parameter n
    static <T> void toggle(T state, T a, T b) {
        state = state == a ? b : a;
    }
}

public interface PureStaticToggle {
    // returns a different reference depending exclusively on external input
    static <T> T toggle(boolean state, T a, T b) {
        //false represents state a, true represents state b
        return state ? b : a;
    }
}

/*
Just as an example of an unarguably bad implementation:
*/
public class MutableToggle<T> implements Supplier<T> {
    private T state;
    private final T a;
    private final T b;

    public MutableToggle(T a, T b) {
        state = a;
        this.a = a;
        this.b = b;
    }

    // exposes a mutable reference, which could completely break the logic of this
    // object and others
    @Override
    public T get() {
        return state;
    }

    public void toggle() {
        state = state == a ? b : a;
    }
}