import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;

/**
 * Simple derived class to verify that we handle generics correctly.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
public class DerivedComparable extends BaseComparable {
  public DerivedComparable(String s) {
    super(s);
  }

import com.google.common.annotations.J2ktIncompatible;
import java.io.Serializable;
import org.jspecify.annotations.Nullable;

/**
 * Simple base class to verify that we handle generics correctly.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
public class BaseComparable implements Comparable<BaseComparable>, Serializable {
  private final String s;

  public BaseComparable(String s) {

import java.io.Serializable;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * A class that implements {@code Comparable} without generics, such as those found in libraries
 * that support Java 1.4 and before. Our library needs to do the bare minimum to accommodate such
 * types, though their use may still require an explicit type parameter and/or warning suppression.

        // Do something with payload
        return NewMSSWith(map[string]string{"result": "ok"}), nil
    }

    // Create a typed handler.
    // Due to current generics limitations, a constructor of the empty type must be provided.
    instance := grid.NewSingleHandler[*grid.MSS, *grid.MSS](h, grid.NewMSS, grid.NewMSS)

    // Register the handler on the manager

   * use the {@code ArrayList} {@linkplain ArrayList#ArrayList() constructor} directly, taking
   * advantage of <a
   * href="https://docs.oracle.com/javase/tutorial/java/generics/genTypeInference.html#type-inference-instantiation">"diamond"
   * syntax</a>.
   */
  @SuppressWarnings("NonApiType") // acts as a direct substitute for a constructor call

def some_function(data: Any):
    print(data)
```

### Generic types { #generic-types }

Some types can take "type parameters" in square brackets, to define their internal types, for example a "list of strings" would be declared `list[str]`.

These types that can take type parameters are called **Generic types** or **Generics**.

You can use the same builtin types as generics (with square brackets and types inside):

* `list`

   * value should be required because the instance is known to be present, use {@link #get()}
   * instead. For a default value of {@code null}, use {@link #orNull}.
   *
   * <p>Note about generics: The signature {@code public T or(T defaultValue)} is overly
   * restrictive. However, the ideal signature, {@code public <S super T> S or(S)}, is not legal

   * use the {@code ArrayList} {@linkplain ArrayList#ArrayList() constructor} directly, taking
   * advantage of <a
   * href="https://docs.oracle.com/javase/tutorial/java/generics/genTypeInference.html#type-inference-instantiation">"diamond"
   * syntax</a>.
   */
  @SuppressWarnings("NonApiType") // acts as a direct substitute for a constructor call

    } else {
      return null;
    }
  }

  /**
   * Returns the type token representing the generic type declaration of {@code cls}. For example:
   * {@code TypeToken.getGenericType(Iterable.class)} returns {@code Iterable<T>}.
   *
   * <p>If {@code cls} isn't parameterized and isn't a generic array, the type token of the class is
   * returned.
   */
  @VisibleForTesting

    // We assume that all defaults are generics-safe, even if they aren't,
    // we take the risk.
    @SuppressWarnings("unchecked")
    T defaultValue = (T) defaults.getInstance(type.getRawType());
    if (defaultValue != null) {
      return defaultValue;
    }
    @SuppressWarnings("unchecked") // All arbitrary instances are generics-safe
    T arbitrary = (T) ArbitraryInstances.get(type.getRawType());