// between a and b, where a and b are of an ordered type.
func OrderedAbsDifference[T orderedNumeric](a, b T) T {
	return absDifference(orderedAbs[T]{a}, orderedAbs[T]{b})
}

// ComplexAbsDifference returns the absolute value of the difference
// between a and b, where a and b are of a complex type.
func ComplexAbsDifference[T Complex](a, b T) T {
	return absDifference(complexAbs[T]{a}, complexAbs[T]{b})

// }
//
// // complexAbs is a helper type that defines an Abs method for
// // complex types.
// type complexAbs[T Complex] T
//
// func (a complexAbs[T]) Abs() complexAbs[T] {
// 	r := float64(real(a))
// 	i := float64(imag(a))
// 	d := math.Sqrt(r*r + i*i)
// 	return complexAbs[T](complex(d, 0))
// }
//
// // OrderedAbsDifference returns the absolute value of the difference

		println(s)
	}
	if strings.Contains(s, "autogenerated") {
		panic("autogenerated code in traceback")
	}
	if !strings.Contains(s, "a.go:15") {
		panic("missing a.go:15")
	}
	if !strings.Contains(s, "a.go:19") {
		panic("missing a.go:19")
	}
	if !strings.Contains(s, "a.init") {
		panic("missing a.init")
	}

	// Check the CallersFrames results.
	if debug {
		iter := runtime.CallersFrames(pcs[:n])
		for {

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type A[T any] struct{}

func (_ A[T]) Method() {}

func DoSomething[P any]() {
	a := A[*byte]{}
	a.Method()

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type T struct{ p *int64 }

type i struct{}

func G() *T { return &T{nil} }

func (j i) F(a, b *T) *T {
	n := *a.p + *b.p
	return &T{&n}
}

func (j i) G() *T {
	return &T{}
}

type I[Idx any] interface {
	G() Idx
	F(a, b Idx) Idx
}

func Gen() I[*T] {
	return i{}

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type A struct{}

func (a *A) f() bool {
	return true

from fastapi import APIRouter, Body

router = APIRouter()


@router.post("/compute")
def compute(a: int = Body(), b: str = Body()):

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

import (
	"reflect"
	"sync"
)

type addressableValue struct{ reflect.Value }

type arshalers[Options, Coder any] struct {
	fncVals  []typedArshaler[Options, Coder]
	fncCache sync.Map // map[reflect.Type]unmarshaler
}
type typedArshaler[Options, Coder any] struct {

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type T[P any] struct {
	x P
}

type U struct {
	a,b int

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type (
	A[P any]               [10]P
	S[P any]               struct{ f P }
	P[P any]               *P
	M[K comparable, V any] map[K]V