Jinzhu <******@****.***> 1756991596 +0800

		},
		{
			Name:     "generics-nested-joins-2",
			Manager:  GetUser("generics-nested-joins-manager-2", Config{Company: true, NamedPet: true}),
			NamedPet: &Pet{Name: "generics-nested-joins-namepet-2", Toy: Toy{Name: "generics-nested-joins-namepet-toy-2"}},
		},
	}

	ctx := context.Background()
	db := gorm.G[User](DB)

And then you won't have to worry about names like `Optional` and `Union`. 😎

#### Generic types { #generic-types }

These types that take type parameters in square brackets are called **Generic types** or **Generics**, for example:

//// tab | Python 3.10+

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

* `list`
* `tuple`
* `set`
* `dict`

#### Generische Typen

Diese Typen, die Typ-Parameter in eckigen Klammern akzeptieren, werden **generische Typen** oder **Generics** genannt.

//// tab | Python 3.10+

Sie können die eingebauten Typen als Generics verwenden (mit eckigen Klammern und Typen darin):

* `list`
* `tuple`
* `set`
* `dict`

Verwenden Sie für den Rest, wie unter Python 3.8, das `typing`-Modul:

- **Type safety** - Extensive use of generics and null-safe operations throughout the API
- **Resource management** - Proper handling of resources with utilities like `CloseableUtil` and `DisposableUtil`

### Key Architectural Patterns
- **Factory Pattern** - `BeanDescFactory` for creating bean descriptors, `ParameterizedClassDescFactory` for generic type handling

   * 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

#### Generieke typen

De types die typeparameters in vierkante haakjes gebruiken, worden **Generieke types** of **Generics** genoemd, bijvoorbeeld:

//// tab | Python 3.10+

Je kunt dezelfde ingebouwde types gebruiken als generics (met vierkante haakjes en types erin):

* `list`
* `tuple`
* `set`
* `dict`

Hetzelfde als bij Python 3.8, uit de `typing`-module:

#### Generic-типы

Эти типы принимают параметры в квадратных скобках:

* `List`
* `Tuple`
* `Set`
* `Dict`
* `Optional`
* ...и др.

называются **Generic-типами** или **Generics**.

### Классы как типы

Вы также можете объявить класс как тип переменной.

    // 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());

    Class<? super T> rawType = type.getRawType();
    @SuppressWarnings("unchecked") // Assume all default values are generics safe.
    T defaultValue = (T) defaultValues.getInstance(rawType);
    if (defaultValue != null) {
      return defaultValue;
    }
    @SuppressWarnings("unchecked") // ArbitraryInstances always returns generics-safe dummies.
    T value = (T) ArbitraryInstances.get(rawType);
    if (value != null) {
      return value;