Remove documentation and tests, focus on package structure only

Co-authored-by: Garciat <118277+Garciat@users.noreply.github.com>

Author: Copilot

README.md

@@ -1,96 +1,3 @@
-# Java Type Classes
+Conventions:
 
-A type class system for Java, inspired by Haskell's type classes.
-
-## Overview
-
-This library provides a way to define and use type classes in Java, enabling ad-hoc polymorphism through automatic instance resolution. It includes a rich set of predefined type classes and data types with higher-kinded type support.
-
-## Usage
-
-### Basic Example
-
-```java
-import static com.garciat.typeclasses.TypeClasses.witness;
-
-// Automatically resolve a Show instance for List<Integer>
-Show<List<Integer>> showListInt = witness(new Ty<>() {});
-String result = showListInt.show(List.of(1, 2, 3));
-// result: "[1, 2, 3]"
-```
-
-### Core Type Classes
-
-The library provides several built-in type classes:
-
-- **Show** - Convert values to strings
-- **Eq** - Equality testing
-- **Ord** - Ordering comparisons
-- **Monoid** - Associative binary operations with identity
-- **Functor** - Mappable type constructors
-- **Applicative** - Application of functions in a context
-- **Monad** - Sequential composition of computations
-- **Foldable** - Structures that can be folded
-- **Traversable** - Structures that can be traversed
-
-### Data Types
-
-The library includes functional data types with type class instances:
-
-- **Maybe** - Optional values (`Just` or `Nothing`)
-- **Either** - Sum types (`Left` or `Right`)
-- **JavaList** - List with type class instances
-- **FwdList** - Functional forward list
-- **Parser** - Parser combinators
-- **State** - State monad
-
-### Higher-Kinded Types
-
-The library supports higher-kinded types through a defunctionalization encoding:
-
-```java
-// Work with Functors abstractly
-Functor<Maybe.Tag> functorMaybe = witness(new Ty<>() {});
-TApp<Maybe.Tag, Integer> maybeInt = Maybe.just(42);
-TApp<Maybe.Tag, String> maybeStr = functorMaybe.map(Object::toString, maybeInt);
-```
-
-## Examples
-
-See the `Examples` class for comprehensive usage examples:
-
-```bash
-mvn compile exec:java -Dexec.mainClass="com.garciat.typeclasses.Examples"
-```
-
-## API Structure
-
-### Public API
-
-The main entry point is `TypeClasses.witness()` which resolves type class instances. All type classes (marked with `@TypeClass`) and data types are part of the public API.
-
-Key public components:
-- `TypeClasses.witness()` - Resolve type class instances
-- `Ty<T>` - Type token for capturing types
-- `Ctx<T>` - Context token for explicit instances
-- `@TypeClass` - Annotation for defining type classes
-- `Kind`, `TApp`, `TPar`, `TagBase` - Higher-kinded type infrastructure
-
-### Internal Implementation
-
-Internal implementation details (parsing, unification, witness resolution algorithms) are package-private and should not be relied upon by library users.
-
-## Building
-
-```bash
-mvn clean compile test
-```
-
-## Conventions
-
-- Use google-java-format for code formatting
-- Java 21 is required
-
-## License
-
-See repository for license information.
+- Use google-java-format

src/main/java/com/garciat/typeclasses/Main.java

@@ -36,15 +36,6 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-/**
- * Core type class infrastructure for Java.
- *
- * <p>This class has been retained for backward compatibility but is no longer the main entry point.
- * The library should be accessed through the public type classes and data types.
- *
- * @deprecated Use {@link Examples} for demonstration code, or the individual type classes directly.
- */
-@Deprecated
 public final class Main {
   private Main() {}
 }

src/main/java/com/garciat/typeclasses/TypeClasses.java

@@ -16,31 +16,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-/**
- * Central facility for type class witness resolution.
- *
- * <p><b>PUBLIC API</b>: The {@link #witness} method is the main entry point for the library.
- */
 public class TypeClasses {
-  /**
-   * Resolves and returns a witness (instance) of a type class for the given type.
-   *
-   * <p>This is the main entry point for using the type class system. It automatically finds and
-   * instantiates the appropriate type class instance based on the provided type token.
-   *
-   * <p>Example:
-   *
-   * <pre>{@code
-   * Show<List<Integer>> showListInt = TypeClasses.witness(new Ty<>() {});
-   * String result = showListInt.show(List.of(1, 2, 3));
-   * }</pre>
-   *
-   * @param <T> the type class instance type
-   * @param ty the type token capturing the desired type class instance
-   * @param context optional context instances to use in resolution
-   * @return the resolved type class instance
-   * @throws WitnessResolutionException if no suitable instance can be found
-   */
   public static <T> T witness(Ty<T> ty, Ctx<?>... context) {
     return switch (summon(ParsedType.parse(ty.type()), parseContext(context))) {
       case Either.Left<SummonError, Object>(SummonError error) ->
@@ -59,7 +35,6 @@ private static List<ContextInstance> parseContext(Ctx<?>[] context) {
         .toList();
   }
 
-  /** Exception thrown when a type class witness cannot be resolved. PUBLIC API. */
   public static class WitnessResolutionException extends RuntimeException {
     private WitnessResolutionException(SummonError error) {
       super(error.format());

src/main/java/com/garciat/typeclasses/api/Ctx.java

@@ -4,46 +4,17 @@
 import java.lang.reflect.Type;
 import java.util.Objects;
 
-/**
- * Context token for capturing type class instances at runtime.
- *
- * <p>Usage:
- *
- * <pre>{@code
- * Show<String> showString = ...;
- * Ctx<Show<String>> ctx = new Ctx<>(showString) {};
- * }</pre>
- *
- * <p><b>PUBLIC API</b>: Used for passing explicit type class instances to witness resolution.
- *
- * @param <T> the type class instance type
- */
 public abstract class Ctx<T> {
   private final T instance;
 
-  /**
-   * Constructs a context with the given instance.
-   *
-   * @param instance the type class instance
-   */
   public Ctx(T instance) {
     this.instance = instance;
   }
 
-  /**
-   * Returns the instance.
-   *
-   * @return the type class instance
-   */
   public T instance() {
     return instance;
   }
 
-  /**
-   * Returns the captured type.
-   *
-   * @return the Type object representing T
-   */
   public Type type() {
     return Objects.requireNonNull(
         ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]);

src/main/java/com/garciat/typeclasses/api/Kind.java

@@ -1,21 +1,9 @@
 package com.garciat.typeclasses.api;
 
-/**
- * Base interface for kind-level types, providing basic kind checking in Java.
- *
- * <p>This interface is used to represent type-level kinds, similar to kinds in Haskell's type
- * system.
- *
- * <p><b>PUBLIC API</b>: This is part of the library's public API. Users implementing custom data
- * types will need to use this interface.
- */
 public interface Kind<K extends Kind.Base> {
-  /** Base interface for all kinds. */
   sealed interface Base permits KStar, KArr {}
 
-  /** KStar represents the kind * (star) - the kind of proper types. */
   final class KStar implements Base {}
 
-  /** KArr k represents the kind * -> k - the kind of type constructors. */
   final class KArr<K extends Base> implements Base {}
 }

src/main/java/com/garciat/typeclasses/api/TApp.java

@@ -1,14 +1,3 @@
 package com.garciat.typeclasses.api;
 
-/**
- * Full application of a unary type constructor.
- *
- * <p>TApp :: (* -> *) -> * -> *
- *
- * <p><b>PUBLIC API</b>: This is part of the library's public API. Users will use this in type
- * signatures.
- *
- * @param <Tag> the type constructor tag
- * @param <A> the applied type argument
- */
 public interface TApp<Tag extends Kind<Kind.KArr<Kind.KStar>>, A> extends Kind<Kind.KStar> {}

src/main/java/com/garciat/typeclasses/api/TPar.java

@@ -1,15 +1,4 @@
 package com.garciat.typeclasses.api;
 
-/**
- * Partial application of a binary type constructor.
- *
- * <p>TPar :: (* -> * -> *) -> * -> (* -> *)
- *
- * <p><b>PUBLIC API</b>: This is part of the library's public API. Users will use this in type
- * signatures.
- *
- * @param <Tag> the type constructor tag
- * @param <A> the first applied type argument
- */
 public interface TPar<Tag extends Kind<Kind.KArr<Kind.KArr<Kind.KStar>>>, A>
     extends Kind<Kind.KArr<Kind.KStar>> {}

src/main/java/com/garciat/typeclasses/api/TagBase.java

@@ -1,12 +1,3 @@
 package com.garciat.typeclasses.api;
 
-/**
- * Base class for type-level tags. Subclasses of this class represent type constructor tags used in
- * higher-kinded type encoding.
- *
- * <p><b>PUBLIC API</b>: This is part of the library's public API. Users implementing custom data
- * types will need to extend this class.
- *
- * @param <K> the kind of this tag
- */
 public abstract class TagBase<K extends Kind.Base> implements Kind<K> {}

src/main/java/com/garciat/typeclasses/api/Ty.java

@@ -4,26 +4,7 @@
 import java.lang.reflect.Type;
 import java.util.Objects;
 
-/**
- * Type token for capturing type information at runtime.
- *
- * <p>Usage:
- *
- * <pre>{@code
- * Show<String> showString = TypeClasses.witness(new Ty<Show<String>>() {});
- * }</pre>
- *
- * <p><b>PUBLIC API</b>: This is the main interface users interact with to summon type class
- * instances.
- *
- * @param <T> the type being captured
- */
 public interface Ty<T> {
-  /**
-   * Returns the captured type.
-   *
-   * @return the Type object representing T
-   */
   default Type type() {
     return Objects.requireNonNull(
         ((ParameterizedType) getClass().getGenericInterfaces()[0]).getActualTypeArguments()[0]);

src/main/java/com/garciat/typeclasses/api/TypeClass.java

@@ -3,35 +3,15 @@
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
-/**
- * Marks an interface as a type class.
- *
- * <p>Type classes are interfaces that define a set of operations that can be implemented for
- * various types. The type class system uses compile-time and runtime reflection to automatically
- * resolve instances.
- *
- * <p><b>PUBLIC API</b>: This is part of the library's public API. Users define and implement type
- * classes using this annotation.
- */
 @Retention(RetentionPolicy.RUNTIME)
 public @interface TypeClass {
-  /** Marks a method as a witness (instance) of a type class. */
   @Retention(RetentionPolicy.RUNTIME)
   @interface Witness {
-    /**
-     * Specifies the overlap behavior for this witness.
-     *
-     * @return the overlap behavior
-     */
     Overlap overlap() default Overlap.NONE;
 
-    /** Defines how instances can overlap with other instances. */
     enum Overlap {
-      /** No overlap allowed (default). */
       NONE,
-      /** This instance can overlap and take precedence over others. */
       OVERLAPPING,
-      /** This instance can be overlapped by others. */
       OVERLAPPABLE
     }
   }