type Recv <-chan int

type sliceOf[E any] interface {
	~[]E
}

func _Append[S sliceOf[T], T any](s S, t ...T) S {
	return append(s, t...)
}

func main() {
	recv := make(Recv)
	a := _Append([]Recv{recv}, recv)
	if len(a) != 2 || a[0] != recv || a[1] != recv {
		panic(a)
	}

	recv2 := make(chan<- int)
	a2 := _Append([]chan<- int{recv2}, recv2)
	if len(a2) != 2 || a2[0] != recv2 || a2[1] != recv2 {
		panic(a)

	// if sweepgen == h->sweepgen, the span is swept and ready to use
	// if sweepgen == h->sweepgen + 1, the span was cached before sweep began and is still cached, and needs sweeping
	// if sweepgen == h->sweepgen + 3, the span was swept and then cached and is still cached
	// h->sweepgen is incremented by 2 after every GC

	sweepgen              uint32
	divMul                uint32        // for divide by elemsize

	{"byte c", append([]byte{}, 0, 1, 2, 3), []byte{0, 1, 2, 3}},

	{"byte d", append([]byte{0, 1, 2}), []byte{0, 1, 2}},
	{"byte e", append([]byte{0, 1, 2}, 3), []byte{0, 1, 2, 3}},
	{"byte f", append([]byte{0, 1, 2}, 3, 4, 5), []byte{0, 1, 2, 3, 4, 5}},

	{"byte g", append([]byte{}, []byte{0}...), []byte{0}},
	{"byte h", append([]byte{}, []byte{0, 1, 2, 3}...), []byte{0, 1, 2, 3}},

 * whose result must be cached even (or specially) at serialization time.
 *
 * @param <T> the resulting type
 */
public abstract class Cached<T> {

    public static <T> Cached<T> of(Callable<T> computation) {
        return new Deferred<>(computation);
    }

    public abstract T get();

    private static class Deferred<T> extends Cached<T> implements java.io.Serializable {

func NewEquivalentResourceRegistry() EquivalentResourceRegistry {
	return &equivalentResourceRegistry{}
}

// NewEquivalentResourceRegistryWithIdentity creates a resource mapper with a custom identity function.
// If "" is returned by the function, GroupResource#String is used as the identity.
// GroupResources with the same identity string are considered equivalent.

import (
	"fmt"
	"reflect"

	"k8s.io/apimachinery/pkg/api/meta"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
)

// Mapper is a convenience struct for holding references to the interfaces
// needed to create Info for arbitrary objects.
type mapper struct {
	// localFn indicates the call can't make server requests
	localFn func() bool

	restMapperFn RESTMapperFunc

*/

package cel

import (
	"context"
	"fmt"

	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
)

var _ ClaimsMapper = &mapper{}
var _ UserMapper = &mapper{}

// mapper implements the ClaimsMapper and UserMapper interface.
type mapper struct {
	compilationResults []CompilationResult
}

// CELMapper is a struct that holds the compiled expressions for

  <artifactId>inheritance</artifactId>
  <version>11-SNAPSHOT</version>
  <name>Model urls inheritance test child</name>

  <scm child.scm.connection.inherit.append.path="true"
       child.scm.developerConnection.inherit.append.path="true"
       child.scm.url.inherit.append.path="true">
    <connection>scm:my-scm:http://domain.org/base</connection>
    <developerConnection>scm:my-scm:https://domain.org/base/</developerConnection>

  </modules>

  <!-- 5 urls in the pom to configure for not adding path -->
  <url>http://www.apache.org/path/to/parent/</url>
  <scm child.scm.connection.inherit.append.path="false"
       child.scm.developerConnection.inherit.append.path="false"
       child.scm.url.inherit.append.path="false">
    <connection>scm:my-scm:http://domain.org/base</connection>
    <developerConnection>scm:my-scm:https://domain.org/base/</developerConnection>

  <name>Model urls inheritance test child</name>

  <scm child.scm.connection.inherit.append.path="true"
       child.scm.developerConnection.inherit.append.path="true"
       child.scm.url.inherit.append.path="true" />
  <distributionManagement>
    <site child.site.url.inherit.append.path="true" />
  </distributionManagement>