*
   * {@snippet :
   * for (B b0 : lists.get(0)) {
   *   for (B b1 : lists.get(1)) {
   *     ...
   *     ImmutableList<B> tuple = ImmutableList.of(b0, b1, ...);
   *     // operate on tuple
   *   }
   * }
   * }
   *
   * <p>Note that if any input list is empty, the Cartesian product will also be empty. If no lists

// functionality of `gradient_checker` by comparing the result with expected
// manual user-provided gradients.
class GradientCheckerTest
    : public ::testing::TestWithParam<std::tuple<const char*, bool, bool>> {
 protected:
  void SetUp() override {
    TF_StatusPtr status(TF_NewStatus());
    TF_SetTracingImplementation(std::get<0>(GetParam()), status.get());

    {

| ...header_n     | msgp bin array              | Header of last version
| ...metadata_n   | msgp bin array              | Metadata of last version

Each header contains a mspg array (tuple) encoded object:

xlHeaderVersion version == 1:

```
//msgp:tuple xlMetaV2VersionHeader
type xlMetaV2VersionHeader struct {
 VersionID [16]byte  // Version UUID, raw.

pkg go/types, func Instantiate(*Context, Type, []Type, bool) (Type, error)
pkg go/types, func NewContext() *Context
pkg go/types, func NewSignature //deprecated
pkg go/types, func NewSignatureType(*Var, []*TypeParam, []*TypeParam, *Tuple, *Tuple, bool) *Signature
pkg go/types, func NewTerm(bool, Type) *Term
pkg go/types, func NewTypeParam(*TypeName, Type) *TypeParam
pkg go/types, func NewUnion([]*Term) *Union
pkg go/types, method (*ArgumentError) Error() string

    return blocks


def _split_hash_comment(line: str) -> tuple[str, str | None]:
    match = HASH_COMMENT_RE.match(line)
    if match:
        code = match.group("code").rstrip()
        comment = match.group("comment")
        return code, comment
    return line.rstrip(), None


def _split_slashes_comment(line: str) -> tuple[str, str | None]:
    match = SLASHES_COMMENT_RE.match(line)
    if match:

   *
   * {@snippet :
   * for (B b0 : lists.get(0)) {
   *   for (B b1 : lists.get(1)) {
   *     ...
   *     ImmutableList<B> tuple = ImmutableList.of(b0, b1, ...);
   *     // operate on tuple
   *   }
   * }
   * }
   *
   * <p>Note that if any input list is empty, the Cartesian product will also be empty. If no lists

     * Creates a thumbnail generation task for the specified document.
     *
     * @param path the file path or URL of the document
     * @param docMap the document metadata map containing field values
     * @return a tuple containing the generator name, thumbnail ID, and path
     */
    @Override
    public Tuple3<String, String, String> createTask(final String path, final Map<String, Object> docMap) {

## 타입 매개변수가 있는 리스트 필드 { #list-fields-with-type-parameter }

하지만 파이썬에는 내부 타입, 즉 "타입 매개변수"를 사용해 리스트를 선언하는 특정한 방법이 있습니다:

### 타입 매개변수로 `list` 선언 { #declare-a-list-with-a-type-parameter }

`list`, `dict`, `tuple`처럼 타입 매개변수(내부 타입)를 갖는 타입을 선언하려면,
대괄호 `[` 및 `]`를 사용해 내부 타입(들)을 "타입 매개변수"로 전달하세요.

```Python
my_list: list[str]
```

이 모든 것은 타입 선언을 위한 표준 파이썬 문법입니다.

내부 타입을 갖는 모델 어트리뷰트에 대해 동일한 표준 문법을 사용하세요.

### Declare a `list` with a type parameter { #declare-a-list-with-a-type-parameter }

To declare types that have type parameters (internal types), like `list`, `dict`, `tuple`,
pass the internal type(s) as "type parameters" using square brackets: `[` and `]`

```Python
my_list: list[str]
```

That's all standard Python syntax for type declarations.

                Tuple3<String, String, String>[] result = new Tuple3[paths.length];
                for (int i = 0; i < paths.length; i++) {
                    // Remove leading slash for the tuple value
                    String path = paths[i].startsWith("/") ? paths[i].substring(1) : paths[i];
                    result[i] = new Tuple3<>("Host", "host" + i + ".example.com", path);
                }