jessebrault/groowt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove util/fp from project.

Browse Source
This commit is contained in:
Jesse Brault 2025-06-28 11:51:09 -05:00
parent 869bef51dd
commit 50b04d9c2c
21 changed files with 0 additions and 1054 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
util/fp/build.gradle
View File

@ -1,31 +0,0 @@
plugins {
id 'groowt-conventions'
id 'groowt-publish'
id 'java-library'
}
repositories {
mavenCentral()
}
dependencies {
api libs.groovy
compileOnlyApi libs.jetbrains.anotations
}
java {
withSourcesJar()
}
jar {
archiveBaseName = 'groowt-util-fp'
}
publishing {
publications {
create('fp', MavenPublication) {
artifactId = 'util-fp'
from components.java
}
}
}

90
util/fp/src/main/java/groowt/util/fp/either/Either.java
View File

@ -1,90 +0,0 @@
package groowt.util.fp.either;
import java.util.function.Function;
public sealed interface Either<E, T> {
@SuppressWarnings("unchecked")
static <E, T> Either<E, T> left(E error) {
return (Either<E, T>) new Left<>(error);
}
@SuppressWarnings("unchecked")
static <E, T> Either<E, T> right(T item) {
return (Either<E, T>) new Right<>(item);
}
final class Left<E> implements Either<E, Object> {
private final E error;
public Left(E error) {
this.error = error;
}
public E get() {
return this.error;
}
}
final class Right<T> implements Either<Object, T> {
private final T item;
public Right(T item) {
this.item = item;
}
public T get() {
return this.item;
}
}
default boolean isLeft() {
return this instanceof Either.Left;
}
default boolean isRight() {
return this instanceof Either.Right;
}
@SuppressWarnings("unchecked")
default Left<E> asLeft() {
return (Left<E>) this;
}
@SuppressWarnings("unchecked")
default Right<T> asRight() {
return (Right<T>) this;
}
default E getLeft() {
return this.asLeft().get();
}
default T getRight() {
return this.asRight().get();
}
@SuppressWarnings("unchecked")
default Either<E, T> mapLeft(Function<? super E, ? extends T> onLeft) {
if (this.isLeft()) {
return (Either<E, T>) new Right<>(onLeft.apply(this.getLeft()));
} else {
return this;
}
}
@SuppressWarnings("unchecked")
default Either<E, T> flatMapLeft(Function<? super E, Either<E, ? extends T>> onLeft) {
if (this.isLeft()) {
final var error = this.getLeft();
return (Either<E, T>) onLeft.apply(error);
} else {
return this;
}
}
}

31
util/fp/src/main/java/groowt/util/fp/hkt/Monoid.java
View File

@ -1,31 +0,0 @@
package groowt.util.fp.hkt;
import java.util.Objects;
public final class Monoid<T> {
private final SemiGroup<T> semiGroup;
private final Zero<T> zero;
public Monoid(SemiGroup<T> semiGroup, Zero<T> zero) {
this.semiGroup = Objects.requireNonNull(semiGroup);
this.zero = Objects.requireNonNull(zero);
}
public SemiGroup<T> getSemiGroup() {
return this.semiGroup;
}
public Zero<T> getZero() {
return this.zero;
}
public T concat(T left, T right) {
return this.semiGroup.concat(left, right);
}
public T empty() {
return this.zero.getEmpty();
}
}

17
util/fp/src/main/java/groowt/util/fp/hkt/SemiGroup.java
View File

@ -1,17 +0,0 @@
package groowt.util.fp.hkt;
import java.util.function.BinaryOperator;
public final class SemiGroup<T> {
private final BinaryOperator<T> concat;
public SemiGroup(BinaryOperator<T> concat) {
this.concat = concat;
}
public T concat(T left, T right) {
return this.concat.apply(left, right);
}
}

17
util/fp/src/main/java/groowt/util/fp/hkt/Zero.java
View File

@ -1,17 +0,0 @@
package groowt.util.fp.hkt;
import java.util.Objects;
public final class Zero<T> {
private final T empty;
public Zero(T empty) {
this.empty = Objects.requireNonNull(empty);
}
public T getEmpty() {
return this.empty;
}
}

159
util/fp/src/main/java/groowt/util/fp/option/Option.java
View File

@ -1,159 +0,0 @@
package groowt.util.fp.option;
import groowt.util.fp.hkt.Monoid;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
public abstract sealed class Option<T> {
private static EmptyOption<Object> emptyInstance;
public static <T> Option<T> lift(T value) {
return new ValueOption<>(Objects.requireNonNull(value));
}
public static <T> Option<T> liftNullable(@Nullable T value) {
return value == null ? empty() : lift(value);
}
public static <T> Option<T> liftLazy(Supplier<? extends @NotNull T> valueSupplier) {
return new SupplierOption<>(Objects.requireNonNull(valueSupplier));
}
@SuppressWarnings("unchecked")
public static <T> Option<T> empty() {
if (emptyInstance == null) {
emptyInstance = new EmptyOption<>();
}
return (Option<T>) emptyInstance;
}
private static final class EmptyOption<T> extends Option<T> {
@Override
public T get() {
throw new NullPointerException("Cannot get() on EmptyOption");
}
@Override
public boolean isPresent() {
return false;
}
}
private static final class ValueOption<T> extends Option<T> {
private final T value;
public ValueOption(T value) {
this.value = value;
}
@Override
public T get() {
return this.value;
}
}
private static final class SupplierOption<T> extends Option<T> {
private final Supplier<T> valueSupplier;
public SupplierOption(Supplier<? extends T> valueSupplier) {
this.valueSupplier = valueSupplier::get;
}
@Override
public T get() {
return Objects.requireNonNull(
this.valueSupplier.get(),
"Cannot get() when the given valueSupplier returns null."
);
}
}
public abstract T get();
public boolean isPresent() {
return true;
}
public @NotNull T getOrElse(T other) {
return this.isPresent() ? this.get() : Objects.requireNonNull(other);
}
public @Nullable T getOrElseNull() {
return this.isPresent() ? this.get() : null;
}
public Option<T> orElseLift(T other) {
return this.isPresent() ? this : new ValueOption<>(Objects.requireNonNull(other));
}
public Option<T> orElseLiftLazy(Supplier<? extends @NotNull T> lazyOther) {
return this.isPresent() ? this : new SupplierOption<>(Objects.requireNonNull(lazyOther));
}
public <U> Option<U> map(Function<? super T, ? extends @NotNull U> mapper) {
return new SupplierOption<>(() -> mapper.apply(this.get()));
}
public <U> Option<U> mapLazy(Function<? super T, ? extends Supplier<? extends @NotNull U>> lazyMapper) {
return new SupplierOption<>(() -> lazyMapper.apply(this.get()).get());
}
public <U> Option<U> flatMap(Function<? super T, Option<? extends U>> mapper) {
return new SupplierOption<>(() -> mapper.apply(this.get()).get());
}
public <U> Option<U> flatMapLazy(Function<? super T, Option<Supplier<? extends @NotNull U>>> lazyMapper) {
return new SupplierOption<>(() -> lazyMapper.apply(this.get()).get().get());
}
public void ifPresent(Consumer<T> onPresent) {
if (this.isPresent()) {
onPresent.accept(this.get());
}
}
public void ifPresentOrElse(Consumer<T> onPresent, Runnable orElse) {
if (this.isPresent()) {
onPresent.accept(this.get());
} else {
orElse.run();
}
}
public <R> R fold(Function<? super T, ? extends R> onPresent, Supplier<? extends R> onEmpty) {
if (this.isPresent()) {
return onPresent.apply(this.get());
} else {
return onEmpty.get();
}
}
public <R> R foldMap(Monoid<R> monoid, Function<? super T, ? extends R> onPresent) {
if (this.isPresent()) {
return onPresent.apply(this.get());
} else {
return monoid.empty();
}
}
public <R> R foldFlatMap(Monoid<R> monoid, Function<? super T, Option<? extends R>> onPresent) {
if (this.isPresent()) {
return onPresent.apply(this.get()).get();
} else {
return monoid.empty();
}
}
}

87
util/fp/src/main/java/groowt/util/fp/property/DefaultListProperty.java
View File

@ -1,87 +0,0 @@
package groowt.util.fp.property;
import groowt.util.fp.provider.DefaultListProvider;
import groowt.util.fp.provider.DefaultProvider;
import groowt.util.fp.provider.ListProvider;
import groowt.util.fp.provider.Provider;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.Function;
public class DefaultListProperty<T> implements ListProperty<T> {
public static <T> ListProperty<T> ofType(Class<T> type) {
return new DefaultListProperty<>(type);
}
private final Class<T> type;
private final List<Provider<T>> elementProviders = new ArrayList<>();
protected DefaultListProperty(Class<T> type) {
this.type = type;
}
@Override
public Class<T> getType() {
return this.type;
}
@Override
public void addElement(T element) {
this.elementProviders.add(DefaultProvider.of(element));
}
@SuppressWarnings("unchecked")
@Override
public void addProvider(Provider<? extends T> elementProvider) {
this.elementProviders.add((Provider<T>) elementProvider);
}
@Override
public void addAllElements(Collection<? extends T> elements) {
elements.forEach(this::addElement);
}
@Override
public void addAllProviders(Collection<? extends Provider<? extends T>> elementProviders) {
elementProviders.forEach(this::addProvider);
}
@Override
public <U> ListProvider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper) {
return DefaultListProvider.ofElementProviders(targetType, this.elementProviders.stream()
.map(elementProvider -> elementProvider.map(targetType, mapper))
.toList()
);
}
@Override
public <U> ListProvider<U> flatMap(
Class<U> targetType,
Function<? super T, ? extends Provider<? extends U>> flatMapper
) {
return DefaultListProvider.ofElementProviders(targetType, this.elementProviders.stream()
.map(elementProvider -> elementProvider.flatMap(targetType, flatMapper))
.toList()
);
}
@Override
public <U extends T> ListProvider<U> withType(Class<U> desiredType) {
return DefaultListProvider.ofElementProviders(desiredType, this.elementProviders.stream()
.filter(elementProvider -> desiredType.isAssignableFrom(elementProvider.getType()))
.map(elementProvider -> elementProvider.map(desiredType, desiredType::cast))
.toList()
);
}
@Override
public List<T> get() {
return this.elementProviders.stream()
.map(Provider::get)
.toList();
}
}

114
util/fp/src/main/java/groowt/util/fp/property/DefaultProperty.java
View File

@ -1,114 +0,0 @@
package groowt.util.fp.property;
import groovy.lang.Closure;
import groowt.util.fp.provider.DefaultProvider;
import groowt.util.fp.provider.Provider;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;
import static java.util.Objects.requireNonNull;
public class DefaultProperty<T> implements Property<T> {
public static <T> Property<T> empty(Class<T> type) {
return new DefaultProperty<>(type);
}
@SuppressWarnings("unchecked")
public static <T> Property<T> of(T t) {
final Property<T> property = new DefaultProperty<>((Class<T>) t.getClass());
property.set(t);
return property;
}
public static <T> Property<T> ofProvider(Class<T> type, Provider<T> tProvider) {
final Property<T> property = new DefaultProperty<>(type);
property.set(tProvider);
return property;
}
public static <T> Property<T> ofLazy(Class<T> type, Supplier<T> tSupplier) {
final Property<T> property = new DefaultProperty<>(type);
property.set(DefaultProvider.ofLazy(type, tSupplier));
return property;
}
private final Class<T> type;
private final List<Closure<?>> configureClosures = new ArrayList<>();
private Provider<? extends T> provider;
private Provider<? extends T> convention;
protected DefaultProperty(Class<T> type) {
this.type = type;
}
@Override
public Class<T> getType() {
return this.type;
}
@Override
public boolean isPresent() {
return this.provider != null || this.convention != null;
}
@Override
public boolean isEmpty() {
return this.provider == null && this.convention == null;
}
@Override
public void set(T t) {
requireNonNull(t);
this.provider = DefaultProvider.of(t);
}
@Override
public void set(Provider<? extends T> tProvider) {
requireNonNull(tProvider);
this.provider = tProvider;
}
@Override
public void setConvention(T convention) {
requireNonNull(convention);
this.convention = DefaultProvider.of(convention);
}
@Override
public void setConvention(Provider<? extends T> convention) {
requireNonNull(convention);
this.convention = convention;
}
@Override
public void configure(Closure<?> configureClosure) {
this.configureClosures.add(configureClosure);
}
private void doConfigures(T t) {
for (final var configureClosure : this.configureClosures) {
configureClosure.setDelegate(t);
configureClosure.call(t);
}
}
@Override
public T get() {
if (!this.isPresent()) {
throw new NullPointerException("Cannot get() from an empty Property. Set the value or set the convention.");
}
final T t;
if (this.provider != null) {
t = this.provider.get();
} else {
t = this.convention.get();
}
this.doConfigures(t);
return t;
}
}

36
util/fp/src/main/java/groowt/util/fp/property/ListProperty.java
View File

@ -1,36 +0,0 @@
package groowt.util.fp.property;
import groowt.util.fp.provider.ListProvider;
import groowt.util.fp.provider.Provider;
import java.util.Collection;
import java.util.Objects;
public interface ListProperty<T> extends ListProvider<T> {
void addElement(T element);
void addProvider(Provider<? extends T> elementProvider);
void addAllElements(Collection<? extends T> elements);
void addAllProviders(Collection<? extends Provider<? extends T>> elementProviders);
@SuppressWarnings("unchecked")
default void leftShift(Object object) {
Objects.requireNonNull(object);
if (object instanceof Provider<?> provider) {
if (!this.getType().isAssignableFrom(provider.getType())) {
throw new IllegalArgumentException(
"The type of the given Provider (" + provider.getType().getName() + ") is not compatible with" +
"the type of this ListProperty (" + this.getType().getName() + ")."
);
}
this.addProvider((Provider<? extends T>) provider);
} else if (this.getType().isAssignableFrom(object.getClass())) {
this.addElement((T) object);
} else {
throw new IllegalArgumentException("The type of the given object (" + object.getClass().getName() +
") is not compatible with the type of this ListProperty (" + this.getType().getName() + ")."
);
}
}
}

42
util/fp/src/main/java/groowt/util/fp/property/Property.java
View File

@ -1,42 +0,0 @@
package groowt.util.fp.property;
import groovy.lang.Closure;
import groovy.lang.DelegatesTo;
import groovy.transform.stc.ClosureParams;
import groovy.transform.stc.FromString;
import groowt.util.fp.provider.Provider;
import org.jetbrains.annotations.Nullable;
public interface Property<T> extends Provider<T> {
void set(T t);
void set(Provider<? extends T> tProvider);
void setConvention(T t);
void setConvention(Provider<? extends T> tProvider);
void configure(
@DelegatesTo(type = "T")
@ClosureParams(value = FromString.class, options = "T")
Closure<?> configureClosure
);
boolean isPresent();
boolean isEmpty();
default T fold(@Nullable T onEmpty) {
if (this.isPresent()) {
return this.get();
} else {
return onEmpty;
}
}
default T fold(Provider<? extends T> onEmpty) {
if (this.isPresent()) {
return this.get();
} else {
return onEmpty.get();
}
}
}

74
util/fp/src/main/java/groowt/util/fp/provider/DefaultListProvider.java
View File

@ -1,74 +0,0 @@
package groowt.util.fp.provider;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
public class DefaultListProvider<T> implements ListProvider<T> {
public static <T> ListProvider<T> ofElements(Class<T> elementType, List<? extends T> elements) {
return new DefaultListProvider<>(
elementType,
elements.stream()
.<Provider<T>>map(DefaultProvider::of)
.toList()
);
}
public static <T> ListProvider<T> ofElementProviders(
Class<T> elementType,
List<? extends Provider<T>> elementProviders
) {
return new DefaultListProvider<>(elementType, elementProviders);
}
private final Class<T> elementType;
private final List<Provider<T>> elementProviders;
private DefaultListProvider(Class<T> elementType, List<? extends Provider<T>> elementProviders) {
this.elementType = elementType;
this.elementProviders = new ArrayList<>(elementProviders);
}
@Override
public Class<T> getType() {
return this.elementType;
}
@Override
public <U> ListProvider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper) {
final List<Provider<U>> uProviders = this.elementProviders.stream()
.map(elementProvider -> elementProvider.map(targetType, mapper))
.toList();
return new DefaultListProvider<>(targetType, uProviders);
}
@Override
public <U> ListProvider<U> flatMap(
Class<U> targetType,
Function<? super T, ? extends Provider<? extends U>> flatMapper
) {
final List<Provider<U>> uProviders = this.elementProviders.stream()
.map(elementProvider -> elementProvider.flatMap(targetType, flatMapper))
.toList();
return new DefaultListProvider<>(targetType, uProviders);
}
@Override
public <U extends T> ListProvider<U> withType(Class<U> desiredType) {
return new DefaultListProvider<>(desiredType, this.elementProviders.stream()
.filter(elementProvider -> desiredType.isAssignableFrom(elementProvider.getType()))
.map(elementProvider -> elementProvider.map(desiredType, desiredType::cast))
.toList()
);
}
@Override
public List<T> get() {
final List<? extends T> filtered = this.elementProviders.stream()
.map(Provider::get)
.toList();
return new ArrayList<>(filtered);
}
}

37
util/fp/src/main/java/groowt/util/fp/provider/DefaultNamedProvider.java
View File

@ -1,37 +0,0 @@
package groowt.util.fp.provider;
class DefaultNamedProvider<T> implements NamedProvider<T> {
private final Class<T> type;
private final String name;
private final Provider<T> delegate;
@SuppressWarnings("unchecked")
public DefaultNamedProvider(String name, T element) {
this.type = (Class<T>) element.getClass();
this.name = name;
this.delegate = DefaultProvider.of(element);
}
public DefaultNamedProvider(Class<T> type, String name, Provider<T> delegate) {
this.type = type;
this.name = name;
this.delegate = delegate;
}
@Override
public Class<T> getType() {
return this.type;
}
@Override
public String getName() {
return this.name;
}
@Override
public T get() {
return this.delegate.get();
}
}

53
util/fp/src/main/java/groowt/util/fp/provider/DefaultNamedSetProvider.java
View File

@ -1,53 +0,0 @@
package groowt.util.fp.provider;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
class DefaultNamedSetProvider<T> extends DefaultSetProvider<T> implements NamedSetProvider<T> {
public static <T> NamedSetProvider<T> ofElementsAndNames(Class<T> type, Map<String, T> namesAndElements) {
return new DefaultNamedSetProvider<>(type, namesAndElements.entrySet().stream()
.map(entry -> new DefaultNamedProvider<>(entry.getKey(), entry.getValue()))
.collect(Collectors.toSet())
);
}
public static <T> NamedSetProvider<T> ofNamedProviders(Class<T> type, Set<? extends NamedProvider<T>> providers) {
return new DefaultNamedSetProvider<>(type, providers);
}
protected DefaultNamedSetProvider(Class<T> type, Set<? extends NamedProvider<T>> elementProviders) {
super(type, elementProviders);
}
@Override
public NamedSetProvider<T> withNames(Predicate<? super String> namePredicate) {
return new DefaultNamedSetProvider<>(this.getType(), this.getProviders().stream()
.map(provider -> (NamedProvider<T>) provider)
.filter(namedProvider -> namePredicate.test(namedProvider.getName()))
.collect(Collectors.toSet())
);
}
@Override
public NamedProvider<T> withName(String name) {
return this.getProviders().stream()
.map(provider -> (NamedProvider<T>) provider)
.filter(namedProvider -> name.equals(namedProvider.getName()))
.findFirst()
.orElseThrow(() -> new NullPointerException("There is no NamedProvider present with name " + name));
}
@SuppressWarnings("unchecked")
@Override
public NamedSetProvider<T> zipWithNames(NamedSetProvider<? extends T> other) {
final Set<NamedProvider<T>> combined = new HashSet<>();
this.getProviders().forEach(provider -> combined.add((NamedProvider<T>) provider));
other.getProviders().forEach(provider -> combined.add((NamedProvider<T>) provider));
return new DefaultNamedSetProvider<>(this.getType(), combined);
}
}

43
util/fp/src/main/java/groowt/util/fp/provider/DefaultProvider.java
View File

@ -1,43 +0,0 @@
package groowt.util.fp.provider;
import java.util.Objects;
import java.util.function.Supplier;
public class DefaultProvider<T> implements Provider<T> {
public static <T> Provider<T> of(T t) {
Objects.requireNonNull(t);
return new DefaultProvider<>(t);
}
public static <T> Provider<T> ofLazy(Class<T> type, Supplier<? extends T> tSupplier) {
Objects.requireNonNull(type);
Objects.requireNonNull(tSupplier);
return new DefaultProvider<>(type, tSupplier);
}
private final Class<T> type;
private final Supplier<T> tSupplier;
@SuppressWarnings("unchecked")
protected DefaultProvider(T t) {
this.tSupplier = () -> t;
this.type = (Class<T>) t.getClass();
}
protected DefaultProvider(Class<T> type, Supplier<? extends T> tSupplier) {
this.type = type;
this.tSupplier = tSupplier::get;
}
@Override
public Class<T> getType() {
return this.type;
}
@Override
public T get() {
return Objects.requireNonNull(this.tSupplier.get());
}
}

78
util/fp/src/main/java/groowt/util/fp/provider/DefaultSetProvider.java
View File

@ -1,78 +0,0 @@
package groowt.util.fp.provider;
import java.util.HashSet;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
public class DefaultSetProvider<T> implements SetProvider<T> {
public static <T> SetProvider<T> ofElements(Class<T> type, Set<? extends T> elements) {
return new DefaultSetProvider<>(type, elements.stream()
.<Provider<T>>map(DefaultProvider::of)
.collect(Collectors.toSet())
);
}
public static <T> SetProvider<T> ofElementProviders(Class<T> type, Set<? extends Provider<T>> providers) {
return new DefaultSetProvider<>(type, providers);
}
private final Class<T> type;
private final Set<Provider<T>> elementProviders;
protected DefaultSetProvider(Class<T> type, Set<? extends Provider<T>> elementProviders) {
this.type = type;
this.elementProviders = new HashSet<>(elementProviders);
}
@Override
public Class<T> getType() {
return this.type;
}
@Override
public Set<Provider<T>> getProviders() {
return this.elementProviders;
}
@Override
public <U> SetProvider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper) {
return new DefaultSetProvider<>(targetType, this.elementProviders.stream()
.map(elementProvider -> elementProvider.map(targetType, mapper))
.collect(Collectors.toSet())
);
}
@Override
public <U> SetProvider<U> flatMap(Class<U> targetType, Function<? super T, ? extends Provider<U>> mapper) {
return new DefaultSetProvider<>(targetType, this.elementProviders.stream()
.map(elementProvider -> elementProvider.flatMap(targetType, mapper))
.collect(Collectors.toSet())
);
}
@Override
public <U> SetProvider<U> withType(Class<U> desiredType) {
return new DefaultSetProvider<>(desiredType, this.elementProviders.stream()
.filter(elementProvider -> desiredType.isAssignableFrom(elementProvider.getType()))
.map(elementProvider -> elementProvider.map(desiredType, desiredType::cast))
.collect(Collectors.toSet())
);
}
@SuppressWarnings("unchecked")
@Override
public SetProvider<T> zip(SetProvider<? extends T> other) {
final Set<Provider<T>> combined = new HashSet<>();
combined.addAll(this.elementProviders);
other.getProviders().forEach(provider -> combined.add((Provider<T>) provider));
return new DefaultSetProvider<>(this.getType(), combined);
}
@Override
public Set<T> get() {
return this.elementProviders.stream().map(Provider::get).collect(Collectors.toSet());
}
}

17
util/fp/src/main/java/groowt/util/fp/provider/ListProvider.java
View File

@ -1,17 +0,0 @@
package groowt.util.fp.provider;
import java.util.List;
import java.util.function.Function;
public interface ListProvider<T> {
Class<T> getType();
<U> ListProvider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper);
<U> ListProvider<U> flatMap(Class<U> targetType, Function<? super T, ? extends Provider<? extends U>> flatMapper);
<U extends T> ListProvider<U> withType(Class<U> desiredType);
List<T> get();
}

21
util/fp/src/main/java/groowt/util/fp/provider/NamedProvider.java
View File

@ -1,21 +0,0 @@
package groowt.util.fp.provider;
import groowt.util.fp.hkt.SemiGroup;
public interface NamedProvider<T> extends Provider<T> {
String getName();
default NamedProvider<T> zipWithNames(
SemiGroup<T> tSemiGroup,
SemiGroup<String> nameSemiGroup,
NamedProvider<? extends T> other
) {
return new DefaultNamedProvider<>(
this.getType(),
nameSemiGroup.concat(this.getName(), other.getName()),
DefaultProvider.ofLazy(this.getType(), () -> tSemiGroup.concat(this.get(), other.get()))
);
}
}

12
util/fp/src/main/java/groowt/util/fp/provider/NamedSetProvider.java
View File

@ -1,12 +0,0 @@
package groowt.util.fp.provider;
import java.util.function.Predicate;
public interface NamedSetProvider<T> extends SetProvider<T> {
NamedSetProvider<T> withNames(Predicate<? super String> namePredicate);
NamedProvider<T> withName(String name);
NamedSetProvider<T> zipWithNames(NamedSetProvider<? extends T> other);
}

72
util/fp/src/main/java/groowt/util/fp/provider/Provider.java
View File

@ -1,72 +0,0 @@
package groowt.util.fp.provider;
import groowt.util.fp.hkt.SemiGroup;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/**
* @implSpec Must throw {@link NullPointerException} if the contained value is {@code null}
* when either created or when retrieved.
*
* @param <T> The type of the value contained within.
*/
public interface Provider<T> {
Class<T> getType();
/**
* @implSpec Must throw {@link NullPointerException} if the value is null.
*
* @throws NullPointerException if the value contained within this Provider is null.
* @return The value.
*/
T get();
default T get(Supplier<RuntimeException> onEmpty) {
try {
return this.get();
} catch (NullPointerException nullPointerException) {
final RuntimeException onEmptyException = onEmpty.get();
onEmptyException.initCause(nullPointerException);
throw onEmptyException;
}
}
default Provider<T> filter(Predicate<? super T> filter) {
Objects.requireNonNull(filter);
return new DefaultProvider<>(this.getType(), () -> {
final T t = this.get();
if (filter.test(t)) {
return t;
} else {
throw new NullPointerException("This Provider is empty (did not pass filter).");
}
});
}
default <U> Provider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper) {
Objects.requireNonNull(mapper);
return new DefaultProvider<>(targetType, () -> mapper.apply(this.get()));
}
default <U> Provider<U> flatMap(
Class<U> targetType,
Function<? super T, ? extends Provider<? extends U>> flatMapper
) {
Objects.requireNonNull(flatMapper);
return new DefaultProvider<>(targetType, () -> flatMapper.apply(this.get()).get());
}
default Provider<T> zip(
SemiGroup<T> semiGroup,
Provider<? extends T> other
) {
Objects.requireNonNull(semiGroup);
Objects.requireNonNull(other);
return new DefaultProvider<>(this.getType(), () -> semiGroup.concat(this.get(), other.get()));
}
}

22
util/fp/src/main/java/groowt/util/fp/provider/SetProvider.java
View File

@ -1,22 +0,0 @@
package groowt.util.fp.provider;
import java.util.Set;
import java.util.function.Function;
public interface SetProvider<T> {
Class<T> getType();
Set<Provider<T>> getProviders();
<U> SetProvider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper);
<U> SetProvider<U> flatMap(Class<U> targetType, Function<? super T, ? extends Provider<U>> mapper);
<U> SetProvider<U> withType(Class<U> desiredType);
Set<T> get();
SetProvider<T> zip(SetProvider<? extends T> other);
}

1
web-view-components-compiler/build.gradle
View File

@ -55,7 +55,6 @@ sourceSets {
dependencies { dependencies {
api project(':web-view-components') api project(':web-view-components')
api libs.antlr.runtime api libs.antlr.runtime
api project(':fp')
compileOnlyApi libs.jetbrains.anotations compileOnlyApi libs.jetbrains.anotations