package main

import "fmt"

func main() {
	fmt.Println("Hello printf")
}

const anyname = require('util');

import util from 'node:util';

package main

import (
	"fmt"
	"time"
	"math"
	"math/rand" // convention is: the files providing that say `package rand`
)

// (individual import statements are legal but not recommended)

func main() {
	fmt.Println("Hello", time.Now(), math.Pi, math.Sqrt(4), rand.Intn(10))
}

import (
	localname "package_name"
)

package lib

func Thisexports() {
}

func this_doesnt() {
}

module.exports = {f};
function f() {}

export function f() {}

func f(a int, b int) int {
	return a+b
}

func point3d(x, y, z int) {
}

func indecisive(a string, b string) (string, string) {
	return (
		fmt.Sprint("I like ", a),
		fmt.Sprint("but I also like ", b),
	)
}
func main() {
	a, b := indecisive("cats", "dogs")
}

function f(a, b) {
	return a+b;
}
const fatarrow_statement_body = (a, b) => {return a+b;};
const fatarrow_expression_body = (a, b) => a+b;

function f(a: number, b: number) {
	return a+b;
}

function b(adder: (a: number, b: number) => number) {
	return adder(1,2);
}

type BinaryOpFunc = (a: number, b: number) => number;
function b(adder: BinaryOpFunc) {}

func returnsTuple() (x, y int) {
	x = 12
	y = 42
	return // "(x, y)" is implied
}

func main() {
	x, y := returnsTuple()
}

function returnsArray() {
	return [12, 42];
}
function main() {
	const [a,b] = returnsArray();
}

package main

import "fmt"

func main() {
	TestCheck()
	TestCommaErr()
}

func Check(err error) {
	if err != nil {
		panic(err)
	}
}

func CommaErr[T any](v T, err error) T {
	if err != nil {
		panic(err)
	}
	return v
}

func Parse(str string) (i int, err error) {
	if str == "42" {
		i = 42
	} else {
		err = fmt.Errorf("cannot parse %v", i)
	}
	return
}

func Ping() error {
	return fmt.Errorf("nothing to ping")
}

func recovery() {
	if err := recover(); err != nil {
		fmt.Println("recover said", err)
	}
}

func TestCheck() {
	defer recovery()
	Check(Ping())
}

func TestCommaErr() {
	defer recovery()
	fmt.Println("test42", CommaErr(Parse("42"))) // passes; CommaErr returns int(42)
	fmt.Println("test20", CommaErr(Parse("20"))) // works as designed: CommaErr panics with Parse's error.
}

func main() {
	var name string // without an initial value, decl must have a type
	var job = "pope"
	job := "pope" // _inside a function but not at top scope,_ pascal-assign is shorthand for "var {name}={val}"

	var x,y,z int; // just like in signatures, repetitive types can be collapsed.

	var x,y,z int = 1,2,3; // Go list-decls have a typle-based initializer syntax

	const a = 42; // sounds limited to char, string, bool, and numbers? really?

	// consts are compile-type _values_ without a firm type, so this works without a cast:
	b int8 := a
	c float32 := a
}

function main() {
	var old_fashioned_let; // don't use var. var has peculiar scoping rules and should be left in the trashbin with the other early-century rubbish.
	const this = "is a constant pointer/ref to unconstant data";
	let normal_var;

	const x=1, y=2, z=3; // JS initializer syntax are based on comma delimited expressions.
}

import (
	"fmt"
	"math/cmplx"
)

var z complex128 = cmplx.Sqrt(-5 + 12i)

func main() {
	fmt.Printf("Type: %T Value: %v\n", z, z)
}

import (
	"fmt"
	"strings"
)

func main() {
	list := []string{"a", "b", "c"}
	fmt.Println(strings.Join(list, ",")) // result "a,b,c"
}

function main() {
	const list = ['a', 'b', 'c'];
	console.log(list.join(','));
}

func main() {
	if a < b {
		doStuff()
	}

	for i := 0; i < 10; ++i {
		fmt.Print(i)
	}

	// can leave init/inc out:
	i := 0
	for i < 10 {
		i += 1
	}

	// or "while(true) {}" with no terms:
	for {
		doForever();
	}

	// switch statements GET AN AUTOMATIC BREAK.
	switch "a"+"b" {
	case "ab":
		fmt.Println("I run")
	case "cd":
		fmt.Println("I do not")
	default:
		fmt.Println("not a chance.")
	}
}

t := time.Now()
	hr := t.Hour()
	switch {
	case hr <12:
		t = "morning"
	case hr <17:
		t = "afternoon"
	default:
		t = "evening"
	}

function main() {
	if (a < b) doStuff();

	for (let i = 0; i < 10; ++i) console.log(i);

	for (let i = 0; i < 10; ++i) {
		console.log(i);
	}
}

const a = 42;

switch (a) {
	case guess() - 1:
		console.log("yay -1");
		break;
	case guess():
		console.log("yay +0");
		break;
	case guess() + 1:
		console.log("yay +1");
		break;
}

function guess() {
	console.log("guessing");
	return 42;
}

func main() {
	if a := 42; a < 50 {
		fmt.Println(a, " is less than 50")
	} else {
		// still accessible here
		fmt.Println(a, " is more than or equal to 50")
	}
	// "a" is _not_ accessible here
}

function main() {
	{ // create an extra scope
		const a = 42;
		if (a < 50) console.log(`${a} is less than 50`);
	}

	// but both languages support this in conditionals, where it's been the norm for decades. See above for loops.
}

func closeFile(handle) {
	fmt.Println("closing", handle.filename)
}

func main() {
	file := openFile('foo')
	defer closeFile(file)
	// do work with file, knowing close will be called at main-exit. (even during panic)
}

function main() {
	let file;
	try {
		file = openFileSync('foo');
		// do work.
	} catch (e) {
		closeFile(file);
		throw e;
	}
	closeFile(file);
}

func ptrmuckery() {
	i := 42
	pointer_to_i = &i
	*pointer_to_i = 24
}

func setThisPtr(val int, dest *int) {
	*dest = int
}

func main() {
	var i int
	setThisPtr(42, &i)
}

function setThisPtr(val, dumb_handle) {
	dumb_handle.ptr = val;
}
function main() {
	const handle = {}; // I don't even _have_ to declare ptr if I don't want to.
	setThisPtr(42, handle);
	console.log(handle.ptr);
}

type Coord3 struct {
	x,y,z float32
}
func main() {
	fmt.Println(Coord3{1,2,3}) // result: `{1 2 3}`

	// named terms also work, and unset fields follow the zeroish initialization rule:
	other := Coord3{y: 42}
	fmt.Println(other) // result: `{0 42 0}`
}

function main() {
	const home = {x: 1, y: 2, z: 3};
	console.log(home); // results: `{ x: 1, y: 2, z: 3 }`
}

// though there's a nice syntactic sugar that makes it look more OOP:

class Coord3 {
	constructor(x, y, z) {
		this.x = x;
		this.y = y;
		this.z = z;
	}
}

function main() {
	const home = new Coord3(1,2,3);
	console.log(home); // results: `Coord3 { x: 1, y: 2, z: 3 }`
}

func main() {
	c := Coord3{1,2,3}
	p := &c
	c.x, (*p).x and p.x are the same thing.
}

package main

import (
	"errors"
	"fmt"
)

type GenericAccount interface {
	Deposit(amount float64)
	Withdraw(amount float64) error
}

type BankAccount struct {
	balance float64
}

func (this *BankAccount) Deposit(amount float64) {
	if this == nil {
		fmt.Printf("BankAccount::Deposit(%v) called on a nil ptr\n", amount)
		return
	}
	this.balance += amount
}

func (this *BankAccount) Accrue(percent float64) {
	if this == nil {
		fmt.Printf("BankAccount::Accrue(%v) called on a nil ptr\n", percent)
		return
	}
	this.balance *= 1+percent
}

func (this *BankAccount) Withdraw(amount float64) error {
	if this == nil {
		return fmt.Errorf("BankAccount::Withdraw(%v) called on a nil ptr\n", amount)
	}
	if amount <= 0 {
		// errors.New() is best suited for creating static, simple error messages that do not require dynamic content or wrapping other errors.
		// For more complex error messages or error wrapping, fmt.Errorf() is often preferred.
		return errors.New("can't be negative")
	}
	if this.balance < amount {
		return errors.New("not enough to make withdrawal")
	}
	this.balance -= amount
	return nil // if there are error returns, you can't leave the last one implicit.
}

func main() {
	var real_account = BankAccount{balance: 100}
	// since the methods are mutators, they're pointer-receivers.
	// Because of that, it's only "*BankAccount" that implements GenericAccount, not plain value "BankAccount".
	var acct GenericAccount = &real_account

	// instance of interface ref will call the right concrete method
	if e := acct.Withdraw(50); e != nil {
		fmt.Println("error:", e)
	}
	fmt.Println("should be 50:", real_account.balance)

	// but you have to dynamic cast to get at a leaf-only bit like Accrue(), and you can't cast to a value or it'll fail the interface's spec.
	if ptr, ok := acct.(*BankAccount); ok {
		ptr.Accrue(.1)
		fmt.Println("should be ~55:", real_account.balance)
	} else {
		fmt.Println("we'd get here if it wasn't this concrete type")

	}
}

type Acct struct {
	Email string
	Pass string
	Name string
	Age  int
}
func (this Acct) String() string {
	// return fmt.Sprintf("%v (%v years)", p.Name, p.Age)
	this.Pass = "[redacted]" // since this method is a value-receiver, we're not mutating the main copy
	str, _ := json.Marshal(this)
	return str
}

if sproing, err := func(); err != nil {
	return nil, fmt.Errorf("could not func: %w", err)
}
}

if errors.Is(err, package.ErrorClass) {
}

var pErrorClass *package.ErrorClass // As() needs a pointer as an output ref
if errors.As(err, &pErrorClass) {
	// use pErrorClass
}

var (
	ErrFubar = errors.New("first lib error")
)
func LibDo() {
	return nil, ErrMyPackageErrar
	// or
	return nil, fmt.Errorf("stuff happened: %w", ErrMyPackageErrar)
}

func caller() {
	derp, err := lib.LibDo()
	if errors.Is(err, lib.ErrFubar) {
		// handle case
	}
}

type error interface {
    Error() string
}

import (
	"fmt"
	"os"
)

type PebkacError struct {
	Who string
	Keystrokes string
}
func (this PebkacError) Error() string {
	return fmt.Sprintf("it's %v's fault because they pressed %v", this.Who, this.Keystrokes)
}

func fallableFunc() error {
	return PebkacError{"Bob", "roflbbq"}
}

func main() {
	if err := fallableFunc(); err != nil {
		fmt.Println("FAIL:", err)
		os.Exit(1)
	}
}

package main

import (
	"fmt"
	"errors"
)

func indecisive(question string) (resp string, err error) {
	defer func() {
		resp = "no! wait! yellow!"
		err = errors.New("can't decide")
	}()
	switch (question) {
		case "what... is your favorite color?":
			resp = "blue!"
		default:
			resp = "I don't know"
	}
	return // mandatory, but implictly uses locals declared in the retval sig.
}

func main() {
	if ans, err := indecisive("what... is your favorite color?"); err == nil {
		fmt.Println("ans:", ans);
	} else {
		fmt.Println("err:", err, "answer given was:", ans);
	}
}

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println(time.Date(1933, 11, 22, 12, 34, 56, 78, time.UTC)) // 1933-11-22 12:34:56.000000078 +0000 UTC

	start := time.Now()
	tick := time.Tick(100 * time.Millisecond)
	boom := time.After(500 * time.Millisecond)
	elapsed := func() time.Duration {
		return time.Since(start).Round(time.Millisecond)
	}
	for {
		select {
		case <-tick:
			fmt.Printf("[%6s] tick.\n", elapsed())
		case <-boom:
			fmt.Printf("[%6s] BOOM!\n", elapsed())
			return
		default:
			fmt.Printf("[%6s]     .\n", elapsed())
			time.Sleep(50 * time.Millisecond)
		}
	}
}

func MyFunc[Name rule, Name2 rule](var Name) Name {
	return var
}

package main

import "fmt"

type Addable interface {
    int | int8 | int16 | int32 | int64 | float32 |
    uint | uint8 | uint16 | uint32 | uint64 | float64 |
    string
}


func Sum[T Addable](nums ...T) T {
    var sum T
    for _, v := range nums {
        sum += v
    }
    return sum
}

type List[T comparable] struct {
    list []T
}
func (this *List[T]) indexOf(ref interface{}) int {
	switch specific := ref.(type) {
	case T:
		return this.indexOf(&specific)
	case *T:
		for i, v := range this.list {
			if v == *specific {
				return i
			}
		}
	default:
		fmt.Println("didn't get a good type", ref)
	}
    return -1
}

func main() {
	total := Sum(1,2,3)
	fmt.Println("total:", total)

	cats := List[string]{[]string{"Chaos","Soot","Spaz"}}
	// testing *string, which was my original simple implementation:
	ref := "Soot"
	fmt.Println("should be 1:", cats.indexOf(&ref))
	ref = "Monkey"
	fmt.Println("should be -1:", cats.indexOf(&ref))

	// testing "also takes string by value"
	fmt.Println("should be 2:", cats.indexOf("Spaz"))
}

import (
	"encoding/json"
	"fmt"
)

func main() {
	// Go arrays have a unique declaration order, but after that are normal
	var ten_ints [10]int // arrays are immutable and the length is technically part of the type.
	ten_ints[0] = 5

	// array literals have curlies, just like structs
	luggage_password := [5]int{1,2,3,4,5}
	// a constructor w/o length is mostly the same, but you're technically constructing a _slice_ not an array
	luggage_password := []int{1,2,3,4,5}
	// to auto-length a real array, use ellipsis (https://rtbell.dev/blog/golang/three-dots)
	luggage_password := [...]int{1,2,3,4,5}

	// slicing into a list-like with a pythonesque syntax:
	subset := luggage_password[1:2]
	// this results in a REF TO ORIGINALS; go slices are documented as not copying anything.

	// which is end-exclusive zero based:
	json,_ := json.Marshal(subset)
	fmt.Printf("json string was %s\n", json) // result: [2], because it starts at offset 1 and ENDS-BEFORE offset 2.

	// unspecified terms in a slicer default to "zero" and "array length"
	// luggage_password[2:] VS luggage_password[:2] VS luggage_password[:]
}

function main() {
	const luggage_password = [1,2,3,4,5];
	const subset = luggage_password.slice(1,2); // N.B! SLICE is like go slicing; array.splice is a mutator with an unrelated signature!
	console.log(subset); // [2]
}

package main

import (
	"fmt"
)

func main() {
	luggage_password := [5]int{1,2,3,4,5}
	temp := luggage_password[1:3]
	fmt.Println("full array:", luggage_password, "sliced to [1:3]:", temp)
	fmt.Println("len() respects the current end marker:", temp, "has len()", len(temp))
	fmt.Println("cap() reports on currently unused elements:", temp, "has cap()", cap(temp))

	temp = temp[:cap(temp)] // [:] respects the current length of the slice, so to grab all out-of-window elements...

	fmt.Println("after extension, len() is", len(temp), "because" temp)

	// you can't back a slice up past its current zero-point; trying [-1:] just errors with "invalid argument: index -1 (constant of type int) must not be negative"

	// while an empty slice on an array is not nil, a slice without a foundation is nil testable:
	var nil_slice []int
	fmt.Println(nil_slice, len(nil_slice), cap(nil_slice), nil_slice == nil) // results: [] 0 0 true
	empty_slice := luggage_password[len(luggage_password):len(luggage_password)]
	fmt.Println(empty_slice, len(empty_slice), cap(empty_slice), empty_slice == nil) // results: [] 0 0 false

	// Iterating a slice using for-range. (Also works on maps.)
	for index, val := range luggage_password {
		fmt.Println("offset", index, "is", val)
	}

	// don't need index?
	for _, val := range luggage_password {
		fmt.Println(val)
	}

	// don't need value in the loop control itself?
	// unlike a func like Marshal()'s returnval of {bytes[], error?}, a for-range statement can work without terminal dummy "_"
	for index := range luggage_password {
		fmt.Println("testing offset", index)
	}
}

function main() {
	// notice "for-in" vs "for-of"!

	// POJOs as MAPS

	const a_map = {a: 'val', another: 'value'};
	for (const key in a_map) {
		const val = a_map[key];
		console.log({val, key});
	}

	// before the days of for-in, we had Object.entries() and its friends. Still valid but I wouldn't dupe a large dataset in perf-sensitive code.
	for (const [key, val] of Object.entries(a_map)) {
		console.log({val, key});
	}

	// ARRAYS

	const a_list = [1,2,3,4,5];
	for (const val of a_list) {
		console.log("for-of a list", val);
	}
	// or if you want the index as well, use the primordial forms:
	for (let i = 0; i < a_list.length; ++i) {
		const val = a_list[i];
		console.log({i, val});
	}
	a_list.forEach((val, i) => console.log({i, val}));
}

func main() {
	// a convenience for making what another lang would call a dynamically sized array, initialized to zeroish:
	// make(${SLICE TYPE}, ${len}, ${optional_capacity_parameter}) // cap defaults to len
	nums := make([]int, 5, 10)

	// WARN: append reserves the right to allocate a new array if space runs out, so it MAY mutate original's backing array.
	// append(${orig_array}, ${more_elements...})

	more_nums := append(nums, 12) // since spare cap was allocated in make(), the backing array for more_nums is the same as nums.
}

func main() {
	// an array of structs initialized in the decl looks like:
	// []struct {def} {initializers}
	// note that def is comma-free but initializers is comma delimited and comma terminated if multiline. Yay consistency!

	pairs := [] struct {
		name string
		age int
	} {
		{"bob", 42},
		{"sue", 24},
		{age: 100},
	}
	fmt.Println(pairs)
}

// map[KeyType]ValueType{Key1: Value1, Key2: Value2, ...}

menu := map[string]float64{
	"eggs":    1.75,
	"bacon":   3.22,
	"sausage": 1.89,
}

type Coord struct {
	x, y float32
}

var global_places = map[string]Coord {
	"house": Coord{1,2},

	// if the map-keytype is fixed, you can shorten the literal:
	"other": {3,4},
}

func main() {
	// "make()" can create empty maps
	places := make(map[string]Coord)
	places["home"] = Coord{1,2}
	fmt.Println(places)

	// delete() to delete an entry
	delete(places, "home")

	// an exist test is hidden on the getter:

	_, home_exists_bool := places["home"]
}

import "fmt"

var verbose = true

func dbgPrint(stuff ...any) {
	if (verbose) {
		fmt.Println(stuff...)
	}
}

func main() {
	dbgPrint("hello world")
}

func compute_inlined(fn func(float64, float64) float64) float64 {
	return fn(3, 4)
}

type FloatyOp func(float64, float64) float64

func compute_typed(fn FloatyOp) float64 {
	return fn(3, 4)
}

func main() {
	salt := 3
	summer := func(a, b float64) float64 {
		return a+b + salt;
	}
	if compute_typed(summer) == 10 {
		fmt.Println("pass")
	}
}

package main

import "fmt"

type Person struct {
	name string
	age  int
}

type Robot struct {
	serial int
	mission string
}

func main() {
	var p interface{}

	// Static-ish casts:
	var x int = 42
	x2 := uint8(x)
	fmt.Println(x, "as byte:", x2)

	// dynamic casts work on interface{}s, not primitives:
	// so you can't say
	// x3 := x.(string)
	// fmt.Println(x, "as string:", x3)

	// panics if error is not explicitly caught:
	if false {
		p = x
		x3 := p.(string) // THROWS FATAL `panic: interface conversion: interface {} is int, not string`
		fmt.Println(p, "as string:", x3)
	}

	// catching the ok/error output prevents panics:
	x4, was_stringable := p.(string)
	fmt.Println(x, "is string?", was_stringable)
	fmt.Printf("typeof x4=%T but len()=%d\n", x4, len(x4))

	p = Person{name: "Alice", age: 25}

	// would not work because "interface{}" has no fields
	// fmt.Println(p.name)
	// fmt.Println(p.age)

	// if I activate this, all raw Person casts would fail with "panic: interface conversion: interface {} is main.Robot, not main.Person"
	if false {
		p = Robot{42, "murder"}
	} else {
		// so cast p inline:
		fmt.Println(p.(Person).name)

		p2 := p.(Person) // or hold the ref
		fmt.Println(p2.age)
	}

	// conversely, I can trigger the default block: and it'll say "type unknown: int"
	if false {
		p = 42
	}

	// using the prelude statement trick that statements like "if" support provides a succinct (if ugly) way to fork on dynamic casts:
	if person, valid := p.(Person); valid {
		fmt.Printf("Person path: is a %T\n", person) // %T says "main.Person"
		fmt.Println(person.name)
		fmt.Println(person.age)
	} else if robot, valid := p.(Robot); valid {
		fmt.Printf("Robot path: is a %T\n", robot) // %T says "main.Robot"
		fmt.Println("object:", robot) // {42 murder}
	} else {
		fmt.Printf("type unknown: %T\n", p)
	}

	// though using the keyword 'type' is more elegant than the above:
	switch actual := p.(type) {
		case Robot:
			fmt.Println("switch says robot", actual)
		case Person:
			fmt.Println("switch says person")
	}
}

import "reflect"
func main() {
	str := reflect.TypeOf([]int{1,2,3})
}

package main

import (
	"encoding/json"
	"fmt"
)

// ALTERNATIVELY, skip the tags and just use go-fields that are case-insensitive-matches for the JSON.
type CoverageExample struct {
	Str  string  `json:"stringValue"`
	Num  float32 `json:"numberValue"`
	Int  int     `json:"integerValue"`
	Bt   bool    `json:"booleanTrueValue"`
	Bf   bool    `json:"booleanFalseValue"`
	Null any     `json:"nullValue"`
	Arr  []any   `json:"arrayValue"`
	Obj  struct {
		Str string  `json:"nestedString"`
		Num float32 `json:"nestedNumber"`
	} `json:"objectValue"`
}

var sample []byte = []byte(`
	{
		"stringValue": "This is a string",
		"numberValue": 123.45,
		"integerValue": 42,
		"booleanTrueValue": true,
		"booleanFalseValue": false,
		"nullValue": null,
		"objectValue": {
			"nestedString": "Another string",
			"nestedNumber": 99
		},
		"arrayValue": [
			"first element",
			2,
			true,
			null,
			{ "arrayObject": "inside array" },
			[ "nested", "array" ]
		]
	}
`)

func main() {
	var data CoverageExample
	err := json.Unmarshal(sample, &data)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", data)

	bytes, err := json.Marshal(data)
	if err != nil {
		panic(err)
	}
	fmt.Printf("simply stringed: %#s\n", bytes)

	bytes, err = json.MarshalIndent(data, "", "\t")
	if err != nil {
		panic(err)
	}
	fmt.Printf("prettyprinted:%#s\n", bytes)

	bytes, err = json.MarshalIndent(data, ">", "\t")
	if err != nil {
		panic(err)
	}
	// note that I manually added the first line's prefix here:
	fmt.Printf("example of prefix field: \n>%#s\n", bytes)
}

package main

import (
	"encoding/json"
	"fmt"
	"reflect"
)

func DecodeStrangeJSON(bytes []byte) (out map[string]any, err error) {
	err = json.Unmarshal(bytes, &out)
	return
}
func DecodeJSON[Serializable any](bytes []byte) (out Serializable, err error) {
	err = json.Unmarshal(bytes, &out)
	return
}

type CoverageExample struct {
	Str string `json:"stringValue"`
	Num float32 `json:"numberValue"`
	Int int `json:"integerValue"`
	Bt bool `json:"booleanTrueValue"`
	Bf bool `json:"booleanFalseValue"`
	Null any `json:"nullValue"`
	Obj struct {
		Str string `json:"nestedString"`
		Num float32 `json:"nestedNumber"`
	} `json:"objectValue"`
	Arr []any `json:"arrayValue"`
}

func main() {
	sample := []byte(`
	{
		"stringValue": "This is a string",
		"numberValue": 123.45,
		"integerValue": 42,
		"booleanTrueValue": true,
		"booleanFalseValue": false,
		"nullValue": null,
		"objectValue": {
			"nestedString": "Another string",
			"nestedNumber": 99
		},
		"arrayValue": [
			"first element",
			2,
			true,
			null,
			{ "arrayObject": "inside array" },
			[ "nested", "array" ]
		]
	}
	`)
	fmt.Printf("sample: %s\n", sample)
	raw, err := DecodeStrangeJSON(sample)
	if err != nil {
		panic(err)
	}
	for k, v := range raw {
		fmt.Printf("top level [%s]<%T> = %v\n", k, v, v);
	}

	structured, err := DecodeJSON[CoverageExample](sample)
	if err != nil {
		panic(err)
	}
	fmt.Printf("structured? %#v\n", structured)
	/*for k, v := range structured {
		fmt.Printf("top level [%s]<%T> = %v\n", k, v, v);
	}
	*/
	stru := reflect.ValueOf(structured) // we're working with the concrete side of the ptr, hence "value"
	if stru.Kind() != reflect.Struct {
		panic("this is a constant in the sample, just illustrating how to chekc")
	}
	ShowKeysInStruct("structured", structured)
	return
	for i := 0; i < stru.NumField(); i++ {
		field := stru.Type().Field(i)
		fmt.Println(field) // Print the field name
		ShowKeysInStruct("field", field)
	}
}

func ShowKeysInStruct(name string, thing any) {
	meta := reflect.ValueOf(thing)
	k := meta.Kind()
	switch k {
	case reflect.Struct:
		for i := 0; i < meta.NumField(); i++ {
			field := meta.Type().Field(i)
			other := meta.Field(i)
			fmt.Printf("%s.%s<%v> = %#v\n", name, field.Name, other.Kind(), other)
		}
	default:
		fmt.Printf("%s is a %v (%T)\n", name, k, thing)
	}
}

package main

// using a magic docstring: it can contain literal declarations, or linker flags for the cgo tool like
// #cgo LDFLAGS: -lm

/*
#include <stdio.h>
#include "your_custom_code.h"
*/
import "C"

func main() {
	C.puts(C.CString("Hello from C called by Go!"))
}

func naiveHelper() {
	// do work
}

import "sync"

type Pool struct {
	adder func()
	sync.WaitGroup // embedded so you can say Pool.Wait
}
func (this *Pool) Add() {
	this.Add(1) // inc the wg
	go this.wrapper()
}
func (this *Pool) wrapper() {
}

func RunPool(launcherFunc func()) {
}

func main() {
	wg := sync.WaitGroup // this example never passed it around, but be sure to pass by pointer to avoid mutating copies.



}