register

package
v2.41.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 17, 2022 License: Apache-2.0, BSD-3-Clause, MIT Imports: 10 Imported by: 36

Documentation

Overview

Package register contains functions for registering and optimizing your DoFn.

This package contains generic register/optimization function for each possible combination of input and output arities in a DoFn's ProcessElement function. For example, given a DoFn with a ProcessElement function that takes 4 inputs and returns 3 outputs, you can call register.DoFn4x3[input1 type, input2 type, input3 type, input4 type, output1 type, output2 type, output3 type](&doFn{}) during pipeline construction. This will register your DoFn and produce optimized callers for your DoFn to significantly speed up execution at runtime.

See DoFn2x1 for a full example.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Combiner1 

func Combiner1[T0 any](accum interface{})

Combiner1 registers a CombineFn's structural functions and types and optimizes their runtime execution. There are 3 different Combiner functions, each of which should be used for a different situation. Combiner1 should be used when your accumulator, input, and output are all of the same type. It can be called with register.Combiner1[T](&CustomCombiner{}) where T is the type of the input/accumulator/output.

func Combiner2 

func Combiner2[T0, T1 any](accum interface{})

Combiner2 registers a CombineFn's structural functions and types and optimizes their runtime execution. There are 3 different Combiner functions, each of which should be used for a different situation. Combiner2 should be used when your accumulator, input, and output are 2 distinct types. It can be called with register.Combiner2[T1, T2](&CustomCombiner{}) where T1 is the type of the accumulator and T2 is the other type.

func Combiner3 

func Combiner3[T0, T1, T2 any](accum interface{})

Combiner3 registers a CombineFn's structural functions and types and optimizes their runtime execution. There are 3 different Combiner functions, each of which should be used for a different situation. Combiner3 should be used when your accumulator, input, and output are 3 distinct types. It can be called with register.Combiner3[T1, T2, T3](&CustomCombiner{}) where T1 is the type of the accumulator, T2 is the type of the input, and T3 is the type of the output.

func DoFn0x0 

func DoFn0x0(doFn genericDoFn0x0)

DoFn0x0 registers your structural DoFn to optimize execution at runtime.

func DoFn0x1 

func DoFn0x1[R0 any](doFn genericDoFn0x1[R0])

DoFn0x1[R0 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn0x2 

func DoFn0x2[R0, R1 any](doFn genericDoFn0x2[R0, R1])

DoFn0x2[R0, R1 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn0x3 

func DoFn0x3[R0, R1, R2 any](doFn genericDoFn0x3[R0, R1, R2])

DoFn0x3[R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn0x4 

func DoFn0x4[R0, R1, R2, R3 any](doFn genericDoFn0x4[R0, R1, R2, R3])

DoFn0x4[R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn0x5 

func DoFn0x5[R0, R1, R2, R3, R4 any](doFn genericDoFn0x5[R0, R1, R2, R3, R4])

DoFn0x5[R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn10x0 

func DoFn10x0[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 any](doFn genericDoFn10x0[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9])

DoFn10x0[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn10x1 

func DoFn10x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0 any](doFn genericDoFn10x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0])

DoFn10x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn10x2 

func DoFn10x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1 any](doFn genericDoFn10x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1])

DoFn10x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn10x3 

func DoFn10x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2 any](doFn genericDoFn10x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2])

DoFn10x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn10x4 

func DoFn10x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3 any](doFn genericDoFn10x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3])

DoFn10x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn10x5 

func DoFn10x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4 any](doFn genericDoFn10x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4])

DoFn10x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn1x0 

func DoFn1x0[I0 any](doFn genericDoFn1x0[I0])

DoFn1x0[I0 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn1x1 

func DoFn1x1[I0, R0 any](doFn genericDoFn1x1[I0, R0])

DoFn1x1[I0, R0 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn1x2 

func DoFn1x2[I0, R0, R1 any](doFn genericDoFn1x2[I0, R0, R1])

DoFn1x2[I0, R0, R1 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn1x3 

func DoFn1x3[I0, R0, R1, R2 any](doFn genericDoFn1x3[I0, R0, R1, R2])

DoFn1x3[I0, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn1x4 

func DoFn1x4[I0, R0, R1, R2, R3 any](doFn genericDoFn1x4[I0, R0, R1, R2, R3])

DoFn1x4[I0, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn1x5 

func DoFn1x5[I0, R0, R1, R2, R3, R4 any](doFn genericDoFn1x5[I0, R0, R1, R2, R3, R4])

DoFn1x5[I0, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn2x0 

func DoFn2x0[I0, I1 any](doFn genericDoFn2x0[I0, I1])

DoFn2x0[I0, I1 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn2x1 

func DoFn2x1[I0, I1, R0 any](doFn genericDoFn2x1[I0, I1, R0])

DoFn2x1[I0, I1, R0 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

Example 
// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements.  See the NOTICE file distributed with
// this work for additional information regarding copyright ownership.
// The ASF licenses this file to You under the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with
// the License.  You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package main

import (
	"context"

	"github.com/apache/beam/sdks/v2/go/pkg/beam"
	"github.com/apache/beam/sdks/v2/go/pkg/beam/core/graph/mtime"
	"github.com/apache/beam/sdks/v2/go/pkg/beam/register"
)

type myDoFn struct{}

func (fn *myDoFn) ProcessElement(word string, iter func(*string) bool, emit func(int)) int {
	var s string
	for iter(&s) {
		emit(len(s))
	}
	return len(word)
}

func (fn *myDoFn) StartBundle(_ context.Context, emit func(int)) {
	emit(2)
}

func (fn *myDoFn) FinishBundle(_ context.Context, emit func(int)) error {
	emit(2)
	return nil
}

func (fn *myDoFn) Setup(_ context.Context) error {
	return nil
}

func (fn *myDoFn) Teardown() error {
	return nil
}

type myDoFn2 struct{}

type Foo struct {
	s string
}

func (fn *myDoFn2) ProcessElement(word string, iter func(**Foo, *beam.EventTime) bool, emit func(beam.EventTime, string, int)) (beam.EventTime, string, int) {
	var f *Foo
	var et beam.EventTime
	for iter(&f, &et) {
		emit(et, f.s, len(f.s))
	}
	return mtime.Now(), word, len(word)
}

func main() {
	// Since myDoFn's ProcessElement call has 2 inputs and 1 output, call DoFn2x1.
	// Since the inputs to ProcessElement are (string, func(int)), and the output
	// is int, we pass those parameter types to the function.
	register.DoFn3x1[string, func(*string) bool, func(int), int](&myDoFn{})

	// Any function parameters (iters or emitters) must be registered separately
	// as well to get the fully optimized experience. Since ProcessElement has
	// an emitter with the signature func(int) we can register it. This must be
	// done by passing in the type parameters of all inputs as constraints.
	register.Emitter1[int]()
	register.Iter1[string]()

	register.DoFn3x3[string, func(**Foo, *beam.EventTime) bool, func(beam.EventTime, string, int), beam.EventTime, string, int](&myDoFn2{})

	// More complex iter/emitter registration work in the same way, even when
	// timestamps or pointers are involved.
	register.Emitter3[beam.EventTime, string, int]()
	register.Iter2[*Foo, beam.EventTime]()
}

Output:

func DoFn2x2 

func DoFn2x2[I0, I1, R0, R1 any](doFn genericDoFn2x2[I0, I1, R0, R1])

DoFn2x2[I0, I1, R0, R1 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn2x3 

func DoFn2x3[I0, I1, R0, R1, R2 any](doFn genericDoFn2x3[I0, I1, R0, R1, R2])

DoFn2x3[I0, I1, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn2x4 

func DoFn2x4[I0, I1, R0, R1, R2, R3 any](doFn genericDoFn2x4[I0, I1, R0, R1, R2, R3])

DoFn2x4[I0, I1, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn2x5 

func DoFn2x5[I0, I1, R0, R1, R2, R3, R4 any](doFn genericDoFn2x5[I0, I1, R0, R1, R2, R3, R4])

DoFn2x5[I0, I1, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn3x0 

func DoFn3x0[I0, I1, I2 any](doFn genericDoFn3x0[I0, I1, I2])

DoFn3x0[I0, I1, I2 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn3x1 

func DoFn3x1[I0, I1, I2, R0 any](doFn genericDoFn3x1[I0, I1, I2, R0])

DoFn3x1[I0, I1, I2, R0 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn3x2 

func DoFn3x2[I0, I1, I2, R0, R1 any](doFn genericDoFn3x2[I0, I1, I2, R0, R1])

DoFn3x2[I0, I1, I2, R0, R1 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn3x3 

func DoFn3x3[I0, I1, I2, R0, R1, R2 any](doFn genericDoFn3x3[I0, I1, I2, R0, R1, R2])

DoFn3x3[I0, I1, I2, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn3x4 

func DoFn3x4[I0, I1, I2, R0, R1, R2, R3 any](doFn genericDoFn3x4[I0, I1, I2, R0, R1, R2, R3])

DoFn3x4[I0, I1, I2, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn3x5 

func DoFn3x5[I0, I1, I2, R0, R1, R2, R3, R4 any](doFn genericDoFn3x5[I0, I1, I2, R0, R1, R2, R3, R4])

DoFn3x5[I0, I1, I2, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn4x0 

func DoFn4x0[I0, I1, I2, I3 any](doFn genericDoFn4x0[I0, I1, I2, I3])

DoFn4x0[I0, I1, I2, I3 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn4x1 

func DoFn4x1[I0, I1, I2, I3, R0 any](doFn genericDoFn4x1[I0, I1, I2, I3, R0])

DoFn4x1[I0, I1, I2, I3, R0 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn4x2 

func DoFn4x2[I0, I1, I2, I3, R0, R1 any](doFn genericDoFn4x2[I0, I1, I2, I3, R0, R1])

DoFn4x2[I0, I1, I2, I3, R0, R1 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn4x3 

func DoFn4x3[I0, I1, I2, I3, R0, R1, R2 any](doFn genericDoFn4x3[I0, I1, I2, I3, R0, R1, R2])

DoFn4x3[I0, I1, I2, I3, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn4x4 

func DoFn4x4[I0, I1, I2, I3, R0, R1, R2, R3 any](doFn genericDoFn4x4[I0, I1, I2, I3, R0, R1, R2, R3])

DoFn4x4[I0, I1, I2, I3, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn4x5 

func DoFn4x5[I0, I1, I2, I3, R0, R1, R2, R3, R4 any](doFn genericDoFn4x5[I0, I1, I2, I3, R0, R1, R2, R3, R4])

DoFn4x5[I0, I1, I2, I3, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn5x0 

func DoFn5x0[I0, I1, I2, I3, I4 any](doFn genericDoFn5x0[I0, I1, I2, I3, I4])

DoFn5x0[I0, I1, I2, I3, I4 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn5x1 

func DoFn5x1[I0, I1, I2, I3, I4, R0 any](doFn genericDoFn5x1[I0, I1, I2, I3, I4, R0])

DoFn5x1[I0, I1, I2, I3, I4, R0 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn5x2 

func DoFn5x2[I0, I1, I2, I3, I4, R0, R1 any](doFn genericDoFn5x2[I0, I1, I2, I3, I4, R0, R1])

DoFn5x2[I0, I1, I2, I3, I4, R0, R1 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn5x3 

func DoFn5x3[I0, I1, I2, I3, I4, R0, R1, R2 any](doFn genericDoFn5x3[I0, I1, I2, I3, I4, R0, R1, R2])

DoFn5x3[I0, I1, I2, I3, I4, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn5x4 

func DoFn5x4[I0, I1, I2, I3, I4, R0, R1, R2, R3 any](doFn genericDoFn5x4[I0, I1, I2, I3, I4, R0, R1, R2, R3])

DoFn5x4[I0, I1, I2, I3, I4, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn5x5 

func DoFn5x5[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4 any](doFn genericDoFn5x5[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4])

DoFn5x5[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn6x0 

func DoFn6x0[I0, I1, I2, I3, I4, I5 any](doFn genericDoFn6x0[I0, I1, I2, I3, I4, I5])

DoFn6x0[I0, I1, I2, I3, I4, I5 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn6x1 

func DoFn6x1[I0, I1, I2, I3, I4, I5, R0 any](doFn genericDoFn6x1[I0, I1, I2, I3, I4, I5, R0])

DoFn6x1[I0, I1, I2, I3, I4, I5, R0 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn6x2 

func DoFn6x2[I0, I1, I2, I3, I4, I5, R0, R1 any](doFn genericDoFn6x2[I0, I1, I2, I3, I4, I5, R0, R1])

DoFn6x2[I0, I1, I2, I3, I4, I5, R0, R1 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn6x3 

func DoFn6x3[I0, I1, I2, I3, I4, I5, R0, R1, R2 any](doFn genericDoFn6x3[I0, I1, I2, I3, I4, I5, R0, R1, R2])

DoFn6x3[I0, I1, I2, I3, I4, I5, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn6x4 

func DoFn6x4[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3 any](doFn genericDoFn6x4[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3])

DoFn6x4[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn6x5 

func DoFn6x5[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4 any](doFn genericDoFn6x5[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4])

DoFn6x5[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn7x0 

func DoFn7x0[I0, I1, I2, I3, I4, I5, I6 any](doFn genericDoFn7x0[I0, I1, I2, I3, I4, I5, I6])

DoFn7x0[I0, I1, I2, I3, I4, I5, I6 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn7x1 

func DoFn7x1[I0, I1, I2, I3, I4, I5, I6, R0 any](doFn genericDoFn7x1[I0, I1, I2, I3, I4, I5, I6, R0])

DoFn7x1[I0, I1, I2, I3, I4, I5, I6, R0 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn7x2 

func DoFn7x2[I0, I1, I2, I3, I4, I5, I6, R0, R1 any](doFn genericDoFn7x2[I0, I1, I2, I3, I4, I5, I6, R0, R1])

DoFn7x2[I0, I1, I2, I3, I4, I5, I6, R0, R1 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn7x3 

func DoFn7x3[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2 any](doFn genericDoFn7x3[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2])

DoFn7x3[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn7x4 

func DoFn7x4[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3 any](doFn genericDoFn7x4[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3])

DoFn7x4[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn7x5 

func DoFn7x5[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4 any](doFn genericDoFn7x5[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4])

DoFn7x5[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn8x0 

func DoFn8x0[I0, I1, I2, I3, I4, I5, I6, I7 any](doFn genericDoFn8x0[I0, I1, I2, I3, I4, I5, I6, I7])

DoFn8x0[I0, I1, I2, I3, I4, I5, I6, I7 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn8x1 

func DoFn8x1[I0, I1, I2, I3, I4, I5, I6, I7, R0 any](doFn genericDoFn8x1[I0, I1, I2, I3, I4, I5, I6, I7, R0])

DoFn8x1[I0, I1, I2, I3, I4, I5, I6, I7, R0 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn8x2 

func DoFn8x2[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1 any](doFn genericDoFn8x2[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1])

DoFn8x2[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn8x3 

func DoFn8x3[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2 any](doFn genericDoFn8x3[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2])

DoFn8x3[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn8x4 

func DoFn8x4[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3 any](doFn genericDoFn8x4[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3])

DoFn8x4[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn8x5 

func DoFn8x5[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4 any](doFn genericDoFn8x5[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4])

DoFn8x5[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn9x0 

func DoFn9x0[I0, I1, I2, I3, I4, I5, I6, I7, I8 any](doFn genericDoFn9x0[I0, I1, I2, I3, I4, I5, I6, I7, I8])

DoFn9x0[I0, I1, I2, I3, I4, I5, I6, I7, I8 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn9x1 

func DoFn9x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0 any](doFn genericDoFn9x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0])

DoFn9x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn9x2 

func DoFn9x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1 any](doFn genericDoFn9x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1])

DoFn9x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn9x3 

func DoFn9x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2 any](doFn genericDoFn9x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2])

DoFn9x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn9x4 

func DoFn9x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3 any](doFn genericDoFn9x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3])

DoFn9x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func DoFn9x5 

func DoFn9x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4 any](doFn genericDoFn9x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4])

DoFn9x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime. DoFn input and output parameter types should be provided in order as the generic constraints.

func Emitter1 

func Emitter1[T1 any]()

Emitter1 registers parameters from your DoFn with a signature func(T) and optimizes their execution. This must be done by passing in type parameters of your input as a constraint, aka: register.Emitter1[T]()

func Emitter2 

func Emitter2[T1, T2 any]()

Emitter2 registers parameters from your DoFn with a signature func(T1, T2) and optimizes their execution. This must be done by passing in type parameters of all inputs (including EventTime) as constraints, aka: register.Emitter2[T1, T2](), where T2 is the type of your value and T2 is either the type of your key or the eventTime.

func Emitter3 

func Emitter3[T1 typex.EventTime, T2, T3 any]()

Emitter3 registers parameters from your DoFn with a signature func(T1, T2, T3) and optimizes their execution. This must be done by passing in type parameters of all inputs as constraints, aka: register.Emitter3[beam.EventTime, T1, T2](), where T1 is the type of your key and T2 is the type of your value.

func Function0x0 

func Function0x0(doFn func())

Function0x0 registers your functional DoFn to optimize execution at runtime.

func Function0x1 

func Function0x1[R0 any](doFn func() R0)

Function0x1[R0 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function0x2 

func Function0x2[R0, R1 any](doFn func() (R0, R1))

Function0x2[R0, R1 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function0x3 

func Function0x3[R0, R1, R2 any](doFn func() (R0, R1, R2))

Function0x3[R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function0x4 

func Function0x4[R0, R1, R2, R3 any](doFn func() (R0, R1, R2, R3))

Function0x4[R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function0x5 

func Function0x5[R0, R1, R2, R3, R4 any](doFn func() (R0, R1, R2, R3, R4))

Function0x5[R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function10x0 

func Function10x0[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9))

Function10x0[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function10x1 

func Function10x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) R0)

Function10x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function10x2 

func Function10x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1))

Function10x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function10x3 

func Function10x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1, R2))

Function10x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function10x4 

func Function10x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1, R2, R3))

Function10x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function10x5 

func Function10x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1, R2, R3, R4))

Function10x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function1x0 

func Function1x0[I0 any](doFn func(I0))

Function1x0[I0 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function1x1 

func Function1x1[I0, R0 any](doFn func(I0) R0)

Function1x1[I0, R0 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function1x2 

func Function1x2[I0, R0, R1 any](doFn func(I0) (R0, R1))

Function1x2[I0, R0, R1 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function1x3 

func Function1x3[I0, R0, R1, R2 any](doFn func(I0) (R0, R1, R2))

Function1x3[I0, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function1x4 

func Function1x4[I0, R0, R1, R2, R3 any](doFn func(I0) (R0, R1, R2, R3))

Function1x4[I0, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function1x5 

func Function1x5[I0, R0, R1, R2, R3, R4 any](doFn func(I0) (R0, R1, R2, R3, R4))

Function1x5[I0, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function2x0 

func Function2x0[I0, I1 any](doFn func(I0, I1))

Function2x0[I0, I1 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function2x1 

func Function2x1[I0, I1, R0 any](doFn func(I0, I1) R0)

Function2x1[I0, I1, R0 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function2x2 

func Function2x2[I0, I1, R0, R1 any](doFn func(I0, I1) (R0, R1))

Function2x2[I0, I1, R0, R1 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function2x3 

func Function2x3[I0, I1, R0, R1, R2 any](doFn func(I0, I1) (R0, R1, R2))

Function2x3[I0, I1, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function2x4 

func Function2x4[I0, I1, R0, R1, R2, R3 any](doFn func(I0, I1) (R0, R1, R2, R3))

Function2x4[I0, I1, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function2x5 

func Function2x5[I0, I1, R0, R1, R2, R3, R4 any](doFn func(I0, I1) (R0, R1, R2, R3, R4))

Function2x5[I0, I1, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function3x0 

func Function3x0[I0, I1, I2 any](doFn func(I0, I1, I2))

Function3x0[I0, I1, I2 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function3x1 

func Function3x1[I0, I1, I2, R0 any](doFn func(I0, I1, I2) R0)

Function3x1[I0, I1, I2, R0 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function3x2 

func Function3x2[I0, I1, I2, R0, R1 any](doFn func(I0, I1, I2) (R0, R1))

Function3x2[I0, I1, I2, R0, R1 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function3x3 

func Function3x3[I0, I1, I2, R0, R1, R2 any](doFn func(I0, I1, I2) (R0, R1, R2))

Function3x3[I0, I1, I2, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function3x4 

func Function3x4[I0, I1, I2, R0, R1, R2, R3 any](doFn func(I0, I1, I2) (R0, R1, R2, R3))

Function3x4[I0, I1, I2, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function3x5 

func Function3x5[I0, I1, I2, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2) (R0, R1, R2, R3, R4))

Function3x5[I0, I1, I2, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function4x0 

func Function4x0[I0, I1, I2, I3 any](doFn func(I0, I1, I2, I3))

Function4x0[I0, I1, I2, I3 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function4x1 

func Function4x1[I0, I1, I2, I3, R0 any](doFn func(I0, I1, I2, I3) R0)

Function4x1[I0, I1, I2, I3, R0 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function4x2 

func Function4x2[I0, I1, I2, I3, R0, R1 any](doFn func(I0, I1, I2, I3) (R0, R1))

Function4x2[I0, I1, I2, I3, R0, R1 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function4x3 

func Function4x3[I0, I1, I2, I3, R0, R1, R2 any](doFn func(I0, I1, I2, I3) (R0, R1, R2))

Function4x3[I0, I1, I2, I3, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function4x4 

func Function4x4[I0, I1, I2, I3, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3) (R0, R1, R2, R3))

Function4x4[I0, I1, I2, I3, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function4x5 

func Function4x5[I0, I1, I2, I3, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3) (R0, R1, R2, R3, R4))

Function4x5[I0, I1, I2, I3, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function5x0 

func Function5x0[I0, I1, I2, I3, I4 any](doFn func(I0, I1, I2, I3, I4))

Function5x0[I0, I1, I2, I3, I4 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function5x1 

func Function5x1[I0, I1, I2, I3, I4, R0 any](doFn func(I0, I1, I2, I3, I4) R0)

Function5x1[I0, I1, I2, I3, I4, R0 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function5x2 

func Function5x2[I0, I1, I2, I3, I4, R0, R1 any](doFn func(I0, I1, I2, I3, I4) (R0, R1))

Function5x2[I0, I1, I2, I3, I4, R0, R1 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function5x3 

func Function5x3[I0, I1, I2, I3, I4, R0, R1, R2 any](doFn func(I0, I1, I2, I3, I4) (R0, R1, R2))

Function5x3[I0, I1, I2, I3, I4, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function5x4 

func Function5x4[I0, I1, I2, I3, I4, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3, I4) (R0, R1, R2, R3))

Function5x4[I0, I1, I2, I3, I4, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function5x5 

func Function5x5[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3, I4) (R0, R1, R2, R3, R4))

Function5x5[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function6x0 

func Function6x0[I0, I1, I2, I3, I4, I5 any](doFn func(I0, I1, I2, I3, I4, I5))

Function6x0[I0, I1, I2, I3, I4, I5 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function6x1 

func Function6x1[I0, I1, I2, I3, I4, I5, R0 any](doFn func(I0, I1, I2, I3, I4, I5) R0)

Function6x1[I0, I1, I2, I3, I4, I5, R0 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function6x2 

func Function6x2[I0, I1, I2, I3, I4, I5, R0, R1 any](doFn func(I0, I1, I2, I3, I4, I5) (R0, R1))

Function6x2[I0, I1, I2, I3, I4, I5, R0, R1 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function6x3 

func Function6x3[I0, I1, I2, I3, I4, I5, R0, R1, R2 any](doFn func(I0, I1, I2, I3, I4, I5) (R0, R1, R2))

Function6x3[I0, I1, I2, I3, I4, I5, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function6x4 

func Function6x4[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3, I4, I5) (R0, R1, R2, R3))

Function6x4[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function6x5 

func Function6x5[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3, I4, I5) (R0, R1, R2, R3, R4))

Function6x5[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function7x0 

func Function7x0[I0, I1, I2, I3, I4, I5, I6 any](doFn func(I0, I1, I2, I3, I4, I5, I6))

Function7x0[I0, I1, I2, I3, I4, I5, I6 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function7x1 

func Function7x1[I0, I1, I2, I3, I4, I5, I6, R0 any](doFn func(I0, I1, I2, I3, I4, I5, I6) R0)

Function7x1[I0, I1, I2, I3, I4, I5, I6, R0 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function7x2 

func Function7x2[I0, I1, I2, I3, I4, I5, I6, R0, R1 any](doFn func(I0, I1, I2, I3, I4, I5, I6) (R0, R1))

Function7x2[I0, I1, I2, I3, I4, I5, I6, R0, R1 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function7x3 

func Function7x3[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2 any](doFn func(I0, I1, I2, I3, I4, I5, I6) (R0, R1, R2))

Function7x3[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function7x4 

func Function7x4[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3, I4, I5, I6) (R0, R1, R2, R3))

Function7x4[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function7x5 

func Function7x5[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3, I4, I5, I6) (R0, R1, R2, R3, R4))

Function7x5[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function8x0 

func Function8x0[I0, I1, I2, I3, I4, I5, I6, I7 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7))

Function8x0[I0, I1, I2, I3, I4, I5, I6, I7 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function8x1 

func Function8x1[I0, I1, I2, I3, I4, I5, I6, I7, R0 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7) R0)

Function8x1[I0, I1, I2, I3, I4, I5, I6, I7, R0 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function8x2 

func Function8x2[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1))

Function8x2[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function8x3 

func Function8x3[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1, R2))

Function8x3[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function8x4 

func Function8x4[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1, R2, R3))

Function8x4[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function8x5 

func Function8x5[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1, R2, R3, R4))

Function8x5[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function9x0 

func Function9x0[I0, I1, I2, I3, I4, I5, I6, I7, I8 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8))

Function9x0[I0, I1, I2, I3, I4, I5, I6, I7, I8 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function9x1 

func Function9x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8) R0)

Function9x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function9x2 

func Function9x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1))

Function9x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function9x3 

func Function9x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1, R2))

Function9x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function9x4 

func Function9x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1, R2, R3))

Function9x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Function9x5 

func Function9x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1, R2, R3, R4))

Function9x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime. Function input and output parameter types should be provided in order as the generic constraints.

func Iter1 

func Iter1[T any]()

Iter1 registers parameters from your DoFn with a signature func(*T) bool and optimizes their execution. This must be done by passing in type parameters of all inputs as constraints, aka: register.Iter1[T]()

func Iter2 

func Iter2[T1, T2 any]()

Iter1 registers parameters from your DoFn with a signature func(*T1, *T2) bool and optimizes their execution. This must be done by passing in type parameters of all inputs as constraints, aka: register.Iter2[T1, T2]()

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.