// RegEx matches only numeric values
var numericPlaceholderRe = regexp.MustCompile(`\$\d+\$`)

func isNumeric(k reflect.Kind) bool {
	switch k {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return true
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return true
	case reflect.Float32, reflect.Float64:
		return true
	default:

	ErrorTest{"int 0/0", func() { use(i / j) }, "divide"},
	ErrorTest{"int8 0/0", func() { use(i8 / j8) }, "divide"},
	ErrorTest{"int16 0/0", func() { use(i16 / j16) }, "divide"},
	ErrorTest{"int32 0/0", func() { use(i32 / j32) }, "divide"},
	ErrorTest{"int64 0/0", func() { use(i64 / j64) }, "divide"},

	ErrorTest{"int 1/0", func() { use(k / j) }, "divide"},
	ErrorTest{"int8 1/0", func() { use(k8 / j8) }, "divide"},

// 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 Numeric interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
		~float32 | ~float64 |
		~complex64 | ~complex128
}

// numericAbs matches numeric types with an Abs method.
type numericAbs[T any] interface {

}

// proto-types for tests

type (
	_Basic     = int
	_Array     = [10]int
	_Slice     = []int
	_Struct    = struct{ f int }
	_Pointer   = *int
	_Func      = func(x int) string
	_Interface = interface{ m() int }
	_Map       = map[string]int
	_Chan      = chan int

	Basic     _Basic
	Array     _Array
	Slice     _Slice
	Struct    _Struct

package linalg

// Numeric is type bound that matches any numeric type.
// It would likely be in a constraints package in the standard library.
type Numeric interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
		~float32 | ~float64 |
		~complex64 | ~complex128
}

func DotProduct[T Numeric](s1, s2 []T) T {
	if len(s1) != len(s2) {

*/

package sets

// Int is a set of ints, implemented via map[int]struct{} for minimal memory consumption.
//
// Deprecated: use generic Set instead.
// new ways:
// s1 := Set[int]{}
// s2 := New[int]()
type Int map[int]Empty

// NewInt creates a Int from a list of values.
func NewInt(items ...int) Int {
	return Int(New[int](items...))
}

// IntKeySet creates a Int from a keys of a map[int](? extends interface{}).

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

package p

type Integer interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}

func shl[I Integer](n int) I {
	return 1 << n

Oliver Liu <******@****.***> 1520311744 -0800

import (
	. "fmt"
	"testing"
)

type TI int
type TI8 int8
type TI16 int16
type TI32 int32
type TI64 int64
type TU uint
type TU8 uint8
type TU16 uint16
type TU32 uint32
type TU64 uint64
type TUI uintptr
type TF float64
type TF32 float32
type TF64 float64
type TB bool
type TS string

func (v TI) String() string   { return Sprintf("I: %d", int(v)) }

	s = "def"
	ib = s
	if ia == ib {
		panic("9")
	}

	s = "abc"
	ib = s
	if ia != ib {
		panic("a")
	}
}

func main() {
	var ia [20]I0
	var b bool
	var s string
	var i8 int8
	var i16 int16
	var i32 int32
	var i64 int64
	var u8 uint8
	var u16 uint16
	var u32 uint32
	var u64 uint64

	f()

	ia[0] = "xxx"
	ia[1] = 12345
	ia[2] = true

	s = "now is"
	ia[3] = s