// license that can be found in the LICENSE file.

package p

// simplified test case

type transform[T any] struct{}
type pair[S any] struct {}

var _ transform[step]

type box transform[step]
type step = pair[box]

// test case from issue

type Transform[T any] struct{ hold T }
type Pair[S, T any] struct {
	First  S
	Second T
}

var first Transform[Step]

    classes.asSequence().map { classEntryFor(it) }


fun classEntriesFor(vararg classes: Class<*>): Sequence<Pair<String, ByteArray>> =
    classes.asSequence().map { classEntryFor(it) }


fun classEntryFor(clazz: KClass<*>): Pair<String, ByteArray> =
    classEntryFor(clazz.java)


fun classEntryFor(clazz: Class<*>): Pair<String, ByteArray> {

import spock.lang.Specification

import static Pair.unpackLeft
import static Pair.unpackRight

class PairTest extends Specification {

  def "can create and transform pair"() {
    given:
    def t = Pair.of(1, "a")

    expect:
    t.nestLeft(2).left == Pair.of(2, 1)
    t.nestLeft(2).right == "a"
    t.nestRight(2).left == 1
    t.nestRight(2).right == Pair.of(2, "a")

    t.pushLeft(2).left == 2

        private List<Pair<OptionDescriptor, OptionDescriptor>> mutuallyExclusiveOptions;
        private TaskOptions() {}

        public List<OptionDescriptor> getAll() {
            return allTaskOptions;
        }

        public void addMutualExclusions(CommandLineParser parser) {
            mutuallyExclusiveOptions.forEach(pair -> parser.allowOneOf(pair.getLeft().getName(), pair.getRight().getName()));

                            result.getSearchFieldLogList().add(new Pair<>(e.getKey(), v));
                        }
                    } else if (e.getValue() instanceof List) {
                        final List<String> values = (List<String>) e.getValue();
                        for (final String v : values) {
                            result.getSearchFieldLogList().add(new Pair<>(e.getKey(), v));
                        }

            result.setAttributes(source.entrySet().stream().filter(e -> !"name".equals(e.getKey()))
                    .map(e -> new Pair<>(e.getKey(), (String) e.getValue())).collect(Collectors.toMap(Pair::getFirst, Pair::getSecond)));
            return result;
        } catch (InstantiationException | IllegalAccessException e) {

            final Pair<String, Float> pair = new Pair<>();
            final String[] values = s.split(":");
            if (values.length == 1) {
                pair.setFirst(values[0].trim());
                pair.setSecond(1.0f);
            } else if (values.length > 1) {
                pair.setFirst(values[0]);
                pair.setSecond(Float.parseFloat(values[1]));
            } else {

impl::NodeMatcherProperties Attr(std::pair<string, AttrValue> attrs);
impl::NodeMatcherProperties Attr(string name);

std::pair<string, AttrValue> AttrLiteralHelper(
    const std::pair<string, bool>& bool_attr);

std::pair<string, AttrValue> AttrLiteralHelper(
    const std::pair<string, absl::Span<const int>>& int_list_attr);

std::pair<string, AttrValue> AttrLiteralHelper(

        final String[] pairs = queryString.split("&");
        try {
            for (final String pair : pairs) {
                final int pos = pair.indexOf('=');
                if (pos >= 0) {
                    final String key = urlCodec.decode(pair.substring(0, pos), enc);
                    List<String> list = paramListMap.get(key);
                    if (list == null) {

    private static final List<Pair<String, String>> RENAMED_TYPE_INTERNAL_NAMES = asList(
        Pair.of("org/gradle/logging/LoggingManagerInternal", "org/gradle/api/logging/LoggingManager"),
        Pair.of("org/gradle/logging/StandardOutputCapture", "org/gradle/internal/logging/StandardOutputCapture")
    );