one.xingyi.optics.ILens Maven / Gradle / Ivy

Go to download
package one.xingyi.optics;

import one.xingyi.tuples.Tuple2;

import java.util.Optional;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Stream;

public interface ILens extends IOptional {

    static  ILens of(Function getFn, BiFunction setFn) {
        return new Lens<>(getFn, setFn);
    }

    Child get(Main main);

    Main set(Main main, Child child);

     ILens chainLens(ILens t);
     ILens merge(ILens other, IISO, Merged> iso);

}

abstract class AbstractLens extends AbstractOptional implements ILens {
    @Override
    public Stream all(Main main) {
        return Stream.of(get(main));
    }

    @Override
    public Main modify(Main main, Function fn) {
        return set(main, fn.apply(get(main)));
    }

    @Override
    public Optional optGet(Main main) {
        return Optional.of(get(main));
    }

    @Override
    public Optional optSet(Main main, Child child) {
        return Optional.of(set(main, child));
    }

    @Override
    public  ILens chainLens(ILens t) {
        return new Lens<>(
                main -> t.get(get(main)),
                (main, grandChild) -> set(main, t.set(get(main), grandChild))
        );
    }
}

final class Lens extends AbstractLens implements ILens {
    private final Function get;
    private final BiFunction set;

    Lens(Function get,
         BiFunction set) {
        this.get = get;
        this.set = set;
    }

    @Override
    public Child get(Main main) {
        return get.apply(main);
    }

    @Override
    public Main set(Main main, Child child) {
        return set.apply(main, child);
    }

    @Override
    public Main modify(Main main, Function fn) {
        return set.apply(main, fn.apply(get.apply(main)));
    }

    @Override
    public  ILens merge(ILens other, IISO, Merged> iso) {
        return new Lens<>(main -> iso.get(Tuple2.of(get(main), other.get(main))),
                (main, merged) -> {
                    Tuple2 tuple2 = iso.reverseGet(merged);
                    return set.apply(other.set(main, tuple2.t2), tuple2.t1);
                });
    }
}