Helping out ssg.

util/di/build.gradle

@@ -13,6 +13,10 @@ dependencies {
     implementation libs.slf4j.api, libs.groovy
 }
 
+java {
+    withSourcesJar()
+}
+
 jar {
     archiveBaseName = 'groowt-util-di'
 }

util/di/src/main/java/groowt/util/di/BindingUtil.java

@@ -27,6 +27,10 @@ public final class BindingUtil {
         return bc -> {};
     }
 
+    public static <T> KeyHolder<NamedRegistryExtension, String, T> named(String name, Class<T> type) {
+        return new SimpleKeyHolder<>(NamedRegistryExtension.class, type, name);
+    }
+
     private BindingUtil() {}
 
 }

util/di/src/main/java/groowt/util/di/NamedRegistryExtension.java

@@ -1,9 +1,3 @@
 package groowt.util.di;
 
-public interface NamedRegistryExtension extends RegistryExtension, KeyBinder<String>, QualifierHandlerContainer {
+public interface NamedRegistryExtension extends RegistryExtension, KeyBinder<String>, QualifierHandlerContainer {}
-
-    static <T> KeyHolder<NamedRegistryExtension, String, T> named(String name, Class<T> type) {
-        return new SimpleKeyHolder<>(NamedRegistryExtension.class, type, name);
-    }
-
-}

util/di/src/main/java/groowt/util/di/RegistryObjectFactory.java

@@ -2,8 +2,6 @@ package groowt.util.di;
 
 import groovy.lang.Closure;
 import groovy.lang.DelegatesTo;
-import groovy.transform.stc.ClosureParams;
-import groovy.transform.stc.FromString;
 import groowt.util.di.filters.FilterHandler;
 import groowt.util.di.filters.IterableFilterHandler;
 import jakarta.inject.Provider;
@@ -20,10 +18,22 @@ import java.util.function.Consumer;
 public interface RegistryObjectFactory extends ObjectFactory {
 
     interface Builder<T extends RegistryObjectFactory> {
+
         void configureRegistry(Consumer<? super Registry> configure);
+
+        default void configureRegistry(@DelegatesTo(Registry.class) Closure<?> configureClosure) {
+            this.configureRegistry(registry -> {
+                configureClosure.setDelegate(registry);
+                configureClosure.call();
+            });
+        }
+
         void addFilterHandler(FilterHandler<?, ?> handler);
+
         void addIterableFilterHandler(IterableFilterHandler<?, ?> handler);
+
         T build();
+
     }
 
     Registry getRegistry();
@@ -33,13 +43,12 @@ public interface RegistryObjectFactory extends ObjectFactory {
     }
 
     default void configureRegistry(
-            @DelegatesTo(Registry.class)
+            @DelegatesTo(value = Registry.class)
-            @ClosureParams(value = FromString.class, options = "groowt.util.di.Registry")
             Closure<?> configureClosure
     ) {
         final Registry registry = this.getRegistry();
         configureClosure.setDelegate(registry);
-        configureClosure.call(registry);
+        configureClosure.call();
     }
 
     <A extends Annotation> @Nullable ScopeHandler<A> findScopeHandler(Class<A> scopeType);

util/di/src/test/java/groowt/util/di/DefaultRegistryObjectFactoryTests.java

@@ -5,7 +5,6 @@ import jakarta.inject.Named;
 import org.junit.jupiter.api.Test;
 
 import static groowt.util.di.BindingUtil.*;
-import static groowt.util.di.NamedRegistryExtension.named;
 import static org.junit.jupiter.api.Assertions.*;
 
 public class DefaultRegistryObjectFactoryTests {

util/extensible/build.gradle

@@ -8,6 +8,10 @@ dependencies {
     compileOnlyApi libs.jetbrains.anotations
 }
 
+java {
+    withSourcesJar()
+}
+
 jar {
     archiveBaseName = 'groowt-util-extensible'
 }
@@ -16,6 +20,7 @@ publishing {
     publications {
         create('extensible', MavenPublication) {
             artifactId = 'groowt-util-extensible'
+            from components.java
         }
     }
 }

util/fp/build.gradle

@@ -13,6 +13,10 @@ dependencies {
     compileOnlyApi libs.jetbrains.anotations
 }
 
+java {
+    withSourcesJar()
+}
+
 jar {
     archiveBaseName = 'groowt-util-fp'
 }

util/fp/src/main/java/groowt/util/fp/property/DefaultListProperty.java

@@ -1,6 +1,7 @@
 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;
 
@@ -8,15 +9,28 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.function.Function;
-import java.util.function.Predicate;
 
 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(Provider.of(element));
+        this.elementProviders.add(DefaultProvider.of(element));
     }
 
     @SuppressWarnings("unchecked")
@@ -36,26 +50,31 @@ public class DefaultListProperty<T> implements ListProperty<T> {
     }
 
     @Override
-    public <U> ListProvider<U> mapElements(Function<? super T, ? extends U> mapper) {
+    public <U> ListProvider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper) {
-        return new DefaultListProvider<>(
+        return DefaultListProvider.ofElementProviders(targetType, this.elementProviders.stream()
-                this.elementProviders.stream()
+                .map(elementProvider -> elementProvider.map(targetType, mapper))
-                        .<Provider<U>>map(elementProvider -> elementProvider.map(mapper))
+                .toList()
-                        .toList()
         );
     }
 
     @Override
-    public <U> ListProvider<U> flatMapElements(Function<? super T, ? extends Provider<? extends U>> flatMapper) {
+    public <U> ListProvider<U> flatMap(
-        return new DefaultListProvider<>(
+            Class<U> targetType,
-                this.elementProviders.stream()
+            Function<? super T, ? extends Provider<? extends U>> flatMapper
-                        .map(elementProvider -> elementProvider.flatMap(flatMapper))
+    ) {
-                        .toList()
+        return DefaultListProvider.ofElementProviders(targetType, this.elementProviders.stream()
+                .map(elementProvider -> elementProvider.flatMap(targetType, flatMapper))
+                .toList()
         );
     }
 
     @Override
-    public ListProvider<T> filterElements(Predicate<? super T> predicate) {
+    public <U extends T> ListProvider<U> withType(Class<U> desiredType) {
-        return new DefaultListProvider<>(this.elementProviders, List.of(predicate));
+        return DefaultListProvider.ofElementProviders(desiredType, this.elementProviders.stream()
+                .filter(elementProvider -> desiredType.isAssignableFrom(elementProvider.getType()))
+                .map(elementProvider -> elementProvider.map(desiredType, desiredType::cast))
+                .toList()
+        );
     }
 
     @Override

util/fp/src/main/java/groowt/util/fp/property/DefaultProperty.java

@@ -1,19 +1,55 @@
 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.Objects;
+import java.util.function.Supplier;
 
-final class SimpleProperty<T> implements Property<T> {
+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;
@@ -26,25 +62,25 @@ final class SimpleProperty<T> implements Property<T> {
 
     @Override
     public void set(T t) {
-        Objects.requireNonNull(t);
+        requireNonNull(t);
-        this.provider = Provider.of(t);
+        this.provider = DefaultProvider.of(t);
     }
 
     @Override
     public void set(Provider<? extends T> tProvider) {
-        Objects.requireNonNull(tProvider);
+        requireNonNull(tProvider);
         this.provider = tProvider;
     }
 
     @Override
     public void setConvention(T convention) {
-        Objects.requireNonNull(convention);
+        requireNonNull(convention);
-        this.convention = Provider.of(convention);
+        this.convention = DefaultProvider.of(convention);
     }
 
     @Override
     public void setConvention(Provider<? extends T> convention) {
-        Objects.requireNonNull(convention);
+        requireNonNull(convention);
         this.convention = convention;
     }
 

util/fp/src/main/java/groowt/util/fp/property/ListProperty.java

@@ -4,10 +4,33 @@ 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() + ")."
+            );
+        }
+    }
+
 }

util/fp/src/main/java/groowt/util/fp/property/Property.java

@@ -7,32 +7,8 @@ import groovy.transform.stc.FromString;
 import groowt.util.fp.provider.Provider;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.function.Supplier;
-
 public interface Property<T> extends Provider<T> {
 
-    static <T> Property<T> empty() {
-        return new SimpleProperty<>();
-    }
-
-    static <T> Property<T> of(T t) {
-        final Property<T> property = new SimpleProperty<>();
-        property.set(t);
-        return property;
-    }
-
-    static <T> Property<T> ofProvider(Provider<T> tProvider) {
-        final Property<T> property = new SimpleProperty<>();
-        property.set(tProvider);
-        return property;
-    }
-
-    static <T> Property<T> ofLazy(Supplier<T> tSupplier) {
-        final Property<T> property = new SimpleProperty<>();
-        property.set(Provider.ofLazy(tSupplier));
-        return property;
-    }
-
     void set(T t);
     void set(Provider<? extends T> tProvider);
     void setConvention(T t);

util/fp/src/main/java/groowt/util/fp/provider/DefaultListProvider.java

@@ -3,65 +3,71 @@ package groowt.util.fp.provider;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Function;
-import java.util.function.Predicate;
 
 public class DefaultListProvider<T> implements ListProvider<T> {
 
-    private final List<Provider<T>> elementProviders;
+    public static <T> ListProvider<T> ofElements(Class<T> elementType, List<? extends T> elements) {
-    private final List<Predicate<? super T>> filters;
+        return new DefaultListProvider<>(
-
+                elementType,
-    public DefaultListProvider(List<? extends Provider<T>> elementProviders) {
+                elements.stream()
-        this.elementProviders = new ArrayList<>(elementProviders);
+                        .<Provider<T>>map(DefaultProvider::of)
-        this.filters = List.of();
+                        .toList()
+        );
     }
 
-    public DefaultListProvider(
+    public static <T> ListProvider<T> ofElementProviders(
-            List<? extends Provider<T>> elementProviders,
+            Class<T> elementType,
-            List<? extends Predicate<? super T>> filters
+            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);
-        this.filters = new ArrayList<>(filters);
-    }
-
-    private DefaultListProvider(DefaultListProvider<T> old, Predicate<? super T> filterToAdd) {
-        this.elementProviders = new ArrayList<>(old.elementProviders);
-        this.filters = new ArrayList<>(old.filters);
-        this.filters.add(filterToAdd);
     }
 
     @Override
-    public ListProvider<T> filterElements(Predicate<? super T> predicate) {
+    public Class<T> getType() {
-        return new DefaultListProvider<>(this, predicate);
+        return this.elementType;
     }
 
     @Override
-    public <U> ListProvider<U> mapElements(Function<? super T, ? extends U> mapper) {
+    public <U> ListProvider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper) {
         final List<Provider<U>> uProviders = this.elementProviders.stream()
-                .<Provider<U>>map(elementProvider -> elementProvider.map(mapper))
+                .map(elementProvider -> elementProvider.map(targetType, mapper))
                 .toList();
-        return new DefaultListProvider<>(uProviders);
+        return new DefaultListProvider<>(targetType, uProviders);
     }
 
     @Override
-    public <U> ListProvider<U> flatMapElements(Function<? super T, ? extends Provider<? extends U>> flatMapper) {
+    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(flatMapper))
+                .map(elementProvider -> elementProvider.flatMap(targetType, flatMapper))
                 .toList();
-        return new DefaultListProvider<>(uProviders);
+        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)
-                .filter(element -> {
+                .toList();
-                    for (final var filter : this.filters) {
-                        if (!filter.test(element)) {
-                            return false;
-                        }
-                    }
-                    return true;
-                }).toList();
         return new ArrayList<>(filtered);
     }
 

util/fp/src/main/java/groowt/util/fp/provider/DefaultNamedProvider.java

@@ -1,20 +1,29 @@
 package groowt.util.fp.provider;
 
-public class DefaultNamedProvider<T> implements NamedProvider<T> {
+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 = Provider.of(element);
+        this.delegate = DefaultProvider.of(element);
     }
 
-    public DefaultNamedProvider(String name, Provider<T> delegate) {
+    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;

util/fp/src/main/java/groowt/util/fp/provider/DefaultNamedSetProvider.java

@@ -0,0 +1,53 @@
+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);
+    }
+
+}

util/fp/src/main/java/groowt/util/fp/provider/DefaultProvider.java

@@ -0,0 +1,43 @@
+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());
+    }
+
+}

util/fp/src/main/java/groowt/util/fp/provider/DefaultSetProvider.java

@@ -0,0 +1,78 @@
+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());
+    }
+
+}

util/fp/src/main/java/groowt/util/fp/provider/ListProvider.java

@@ -2,17 +2,16 @@ package groowt.util.fp.provider;
 
 import java.util.List;
 import java.util.function.Function;
-import java.util.function.Predicate;
 
-public interface ListProvider<T> extends Provider<List<T>> {
+public interface ListProvider<T> {
 
-    <U> ListProvider<U> mapElements(Function<? super T, ? extends U> mapper);
+    Class<T> getType();
-    <U> ListProvider<U> flatMapElements(Function<? super T, ? extends Provider<? extends U>> flatMapper);
 
-    ListProvider<T> filterElements(Predicate<? super T> predicate);
+    <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);
 
-    default <R extends T> ListProvider<R> filterElementsByType(Class<? extends R> type) {
+    <U extends T> ListProvider<U> withType(Class<U> desiredType);
-        return this.filterElements(type::isInstance).mapElements(type::cast);
+
-    }
+    List<T> get();
 
 }

util/fp/src/main/java/groowt/util/fp/provider/NamedProvider.java

@@ -12,8 +12,9 @@ public interface NamedProvider<T> extends Provider<T> {
             NamedProvider<? extends T> other
     ) {
         return new DefaultNamedProvider<>(
+                this.getType(),
                 nameSemiGroup.concat(this.getName(), other.getName()),
-                Provider.ofLazy(() -> tSemiGroup.concat(this.get(), other.get()))
+                DefaultProvider.ofLazy(this.getType(), () -> tSemiGroup.concat(this.get(), other.get()))
         );
     }
 

util/fp/src/main/java/groowt/util/fp/provider/NamedSetProvider.java

@@ -0,0 +1,12 @@
+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);
+
+}

util/fp/src/main/java/groowt/util/fp/provider/Provider.java

@@ -13,18 +13,9 @@ import java.util.function.Supplier;
  *
  * @param <T> The type of the value contained within.
  */
-@FunctionalInterface
 public interface Provider<T> {
 
-    static <T> Provider<T> of(T t) {
+    Class<T> getType();
-        Objects.requireNonNull(t);
-        return () -> t;
-    }
-
-    static <T> Provider<T> ofLazy(Supplier<? extends T> tSupplier) {
-        Objects.requireNonNull(tSupplier);
-        return () -> Objects.requireNonNull(tSupplier.get(), "This Provider is empty.");
-    }
 
     /**
      * @implSpec Must throw {@link NullPointerException} if the value is null.
@@ -34,32 +25,48 @@ public interface Provider<T> {
      */
     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 () -> {
+        return new DefaultProvider<>(this.getType(), () -> {
             final T t = this.get();
             if (filter.test(t)) {
                 return t;
             } else {
-                throw new NullPointerException("This Provider is empty.");
+                throw new NullPointerException("This Provider is empty (did not pass filter).");
             }
-        };
+        });
     }
 
-    default <U> Provider<U> map(Function<? super T, ? extends U> mapper) {
+    default <U> Provider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper) {
         Objects.requireNonNull(mapper);
-        return () -> mapper.apply(this.get());
+        return new DefaultProvider<>(targetType, () -> mapper.apply(this.get()));
     }
 
-    default <U> Provider<U> flatMap(Function<? super T, ? extends Provider<? extends U>> flatMapper) {
+    default <U> Provider<U> flatMap(
+            Class<U> targetType,
+            Function<? super T, ? extends Provider<? extends U>> flatMapper
+    ) {
         Objects.requireNonNull(flatMapper);
-        return () -> flatMapper.apply(this.get()).get();
+        return new DefaultProvider<>(targetType, () -> flatMapper.apply(this.get()).get());
     }
 
-    default Provider<T> zip(SemiGroup<T> semiGroup, Provider<? extends T> other) {
+    default Provider<T> zip(
+            SemiGroup<T> semiGroup,
+            Provider<? extends T> other
+    ) {
         Objects.requireNonNull(semiGroup);
         Objects.requireNonNull(other);
-        return () -> semiGroup.concat(this.get(), other.get());
+        return new DefaultProvider<>(this.getType(), () -> semiGroup.concat(this.get(), other.get()));
     }
 
 }

util/fp/src/main/java/groowt/util/fp/provider/SetProvider.java

@@ -0,0 +1,22 @@
+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);
+
+}

view-components/build.gradle

@@ -18,10 +18,15 @@ dependencies {
     implementation libs.slf4j.api
 }
 
+java {
+    withSourcesJar()
+}
+
 publishing {
     publications {
         create('viewComponents', MavenPublication) {
             artifactId = 'groowt-view-components'
+            from components.java
         }
     }
 }

views/build.gradle

@@ -21,6 +21,10 @@ test {
     testLogging.showStandardStreams = true
 }
 
+java {
+    withSourcesJar()
+}
+
 publishing {
     publications {
         create('views', MavenPublication) {

web-views/build.gradle

@@ -195,6 +195,10 @@ test {
     jvmArgs '-XX:+EnableDynamicAgentLoading' // for mockito/bytebuddy
 }
 
+java {
+    withSourcesJar()
+}
+
 publishing {
     publications {
         create('webViews', MavenPublication) {

web-views/src/main/java/groowt/view/web/compiler/DefaultWebViewComponentTemplateCompiler.java

@@ -163,7 +163,13 @@ public class DefaultWebViewComponentTemplateCompiler
         final var allClasses = compileUnit.getGroovyCompilationUnit().getClasses();
         GroovyClass templateGroovyClass = null;
         final Set<GroovyClass> otherClasses = new HashSet<>();
-        final String templateClassFqn = sourceUnit.getAST().getPackageName() + "." + templateClassSimpleName;
+        final String actualPackageName = sourceUnit.getAST().getPackageName();
+        final String templateClassFqn;
+        if (actualPackageName.endsWith(".")) {
+            templateClassFqn = actualPackageName + templateClassSimpleName;
+        } else {
+            templateClassFqn = actualPackageName + "." + templateClassSimpleName;
+        }
         for (final GroovyClass groovyClass : allClasses) {
             if (groovyClass.getName().equals(templateClassFqn)) {
                 if (templateGroovyClass != null) {

web-views/src/main/java/groowt/view/web/compiler/WebViewComponentTemplateCompileUnit.java

@@ -63,7 +63,7 @@ public class WebViewComponentTemplateCompileUnit extends AbstractComponentTempla
 
     @Override
     public @Nullable String getLine(int lineNumber, Janitor janitor) {
-        if (this.getSource().canReopen()) {
+        if (lineNumber > -1 && this.getSource().canReopen()) {
             return this.getSource().getLines().get(lineNumber);
         } else {
             return null;

web-views/src/main/java/groowt/view/web/transpile/DefaultGroovyTranspiler.java

@@ -106,7 +106,7 @@ public class DefaultGroovyTranspiler implements GroovyTranspiler {
 
         if (convertResult.moduleNode().hasPackage()) {
             moduleNode.setPackage(convertResult.moduleNode().getPackage());
-            mainClassNode.setName(moduleNode.getPackageName() + "." + templateClassName);
+            mainClassNode.setName(moduleNode.getPackageName() + templateClassName);
         }
 
         final BlockStatement preambleBlock = convertResult.blockStatement();

web-views/src/main/java/groowt/view/web/transpile/DefaultTranspilerConfiguration.java

@@ -1,6 +1,6 @@
 package groowt.view.web.transpile;
 
-import groowt.util.fp.provider.Provider;
+import groowt.util.fp.provider.DefaultProvider;
 import groowt.view.web.transpile.resolve.ComponentClassNodeResolver;
 
 public class DefaultTranspilerConfiguration implements TranspilerConfiguration {
@@ -14,10 +14,10 @@ public class DefaultTranspilerConfiguration implements TranspilerConfiguration {
         final var jStringTranspiler = new DefaultJStringTranspiler(positionSetter);
         final var gStringTranspiler = new DefaultGStringTranspiler(positionSetter, jStringTranspiler);
         final var componentTranspiler = new DefaultComponentTranspiler(
-                Provider.of(this.appendOrAddStatementFactory),
+                DefaultProvider.of(this.appendOrAddStatementFactory),
-                Provider.of(classNodeResolver),
+                DefaultProvider.of(classNodeResolver),
-                Provider.ofLazy(this::getValueNodeTranspiler),
+                DefaultProvider.ofLazy(ValueNodeTranspiler.class, this::getValueNodeTranspiler),
-                Provider.ofLazy(this::getBodyTranspiler)
+                DefaultProvider.ofLazy(BodyTranspiler.class, this::getBodyTranspiler)
         );
         this.valueNodeTranspiler = new DefaultValueNodeTranspiler(componentTranspiler);
         this.bodyTranspiler = new DefaultBodyTranspiler(gStringTranspiler, jStringTranspiler, componentTranspiler);