golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546: constraints

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify golang.org/x/exp/constraints in pkg:golang/golang.org/x/exp@v0.0.0-20251023183803-a4bb9ffd2546
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/golang.org/x/exp@v0.0.0-20251023183803-a4bb9ffd2546
Demonstrate these symbols/APIs:
  - golang.org/x/exp/constraints

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:5333a8888e64aa7b31a69ee95fa8cd0f3f9cb295a94efe91890b20825fac2941","contract":["constraints.Ordered permits generic comparison on integers, floats, and strings","constraints.Integer constrains type parameters to signed and unsigned integer types","constraints.Float constrains type parameters to float32 and float64"],"goal":"verify golang.org/x/exp/constraints in pkg:golang/golang.org/x/exp@v0.0.0-20251023183803-a4bb9ffd2546","kind":"HOW","packages":["pkg:golang/golang.org/x/exp@v0.0.0-20251023183803-a4bb9ffd2546"],"schemaVersion":1,"symbols":["golang.org/x/exp/constraints"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/golang.org/x/exp@v0.0.0-20251023183803-a4bb9ffd2546"],"schemaVersion":1,"subject":"pkg:golang/golang.org/x/exp@v0.0.0-20251023183803-a4bb9ffd2546","symbols":["golang.org/x/exp/constraints"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

require golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546

golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 h1:mgKeJMpvi0yx/sU5GsxQ7p6s2wtOnGAHZWCHUM4KGzY=
golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546/go.mod h1:j/pmGrbnkbPtQfxEe5D0VQhZC6qKbfKifgD0oM7sR70=

package main

import (
	"fmt"

	"golang.org/x/exp/constraints"
)

// Min returns the minimum of two ordered values.
func Min[T constraints.Ordered](a, b T) T {
	if a < b {
		return a
	}
	return b
}

// Max returns the maximum of two ordered values.
func Max[T constraints.Ordered](a, b T) T {
	if a > b {
		return a
	}
	return b
}

// Sum returns the sum of a slice of numbers.
func Sum[T constraints.Integer | constraints.Float](vals []T) T {
	var total T
	for _, v := range vals {
		total += v
	}
	return total
}

func main() {
	fmt.Printf("Min(10, 20) = %d\n", Min(10, 20))
	fmt.Printf("Max(\"apple\", \"banana\") = %s\n", Max("apple", "banana"))
	fmt.Printf("Sum([]float64{1.5, 2.5, 3.0}) = %f\n", Sum([]float64{1.5, 2.5, 3.0}))
}

{
  "schemaVersion": 1,
  "goal": "verify golang.org/x/exp/constraints in pkg:golang/golang.org/x/exp@v0.0.0-20251023183803-a4bb9ffd2546",
  "kind": "HOW",
  "packages": [
    "pkg:golang/golang.org/x/exp@v0.0.0-20251023183803-a4bb9ffd2546"
  ],
  "symbols": [
    "golang.org/x/exp/constraints"
  ]
}

package main

import (
	"fmt"
	"os"

	"golang.org/x/exp/constraints"
)

// Min returns the smaller of two values conforming to constraints.Ordered.
func Min[T constraints.Ordered](a, b T) T {
	if a < b {
		return a
	}
	return b
}

// Max returns the larger of two values conforming to constraints.Ordered.
func Max[T constraints.Ordered](a, b T) T {
	if a > b {
		return a
	}
	return b
}

// SumIntegers sums integer elements satisfying constraints.Integer.
func SumIntegers[T constraints.Integer](vals []T) T {
	var total T
	for _, v := range vals {
		total += v
	}
	return total
}

// ScaleFloat scales a floating-point value satisfying constraints.Float.
func ScaleFloat[T constraints.Float](val T, factor T) T {
	return val * factor
}

func main() {
	// Assertion 1: constraints.Ordered permits generic comparison on integers, floats, and strings
	if Min(3, 7) != 3 {
		fmt.Fprintf(os.Stderr, "assertion 1a failed\n")
		os.Exit(1)
	}
	if Max(uint(15), uint(9)) != uint(15) {
		fmt.Fprintf(os.Stderr, "assertion 1b failed\n")
		os.Exit(1)
	}
	if Min(3.14, 2.71) != 2.71 {
		fmt.Fprintf(os.Stderr, "assertion 1c failed\n")
		os.Exit(1)
	}
	if Max("beta", "alpha") != "beta" {
		fmt.Fprintf(os.Stderr, "assertion 1d failed\n")
		os.Exit(1)
	}

	// Assertion 2: constraints.Integer constrains type parameters to signed and unsigned integer types
	intSlice := []int{-5, 10, 15}
	if SumIntegers(intSlice) != 20 {
		fmt.Fprintf(os.Stderr, "assertion 2a failed\n")
		os.Exit(1)
	}
	uintSlice := []uint64{100, 200, 300}
	if SumIntegers(uintSlice) != 600 {
		fmt.Fprintf(os.Stderr, "assertion 2b failed\n")
		os.Exit(1)
	}

	// Assertion 3: constraints.Float constrains type parameters to float32 and float64
	var f32 float32 = 2.5
	if ScaleFloat(f32, 2.0) != 5.0 {
		fmt.Fprintf(os.Stderr, "assertion 3a failed\n")
		os.Exit(1)
	}
	var f64 float64 = 4.25
	if ScaleFloat(f64, 4.0) != 17.0 {
		fmt.Fprintf(os.Stderr, "assertion 3b failed\n")
		os.Exit(1)
	}

	fmt.Println("All constraints contract assertions passed.")
}