Robert Griesemer <******@****.***> 1607048150 -0800

	if r.IsDefined() {
		return r
	}
	t := f()
	return Option[T]{&t}
}

type Func1[A1, R any] func(a1 A1) R

type Func2[A1, A2, R any] func(a1 A1, a2 A2) R

func (r Func2[A1, A2, R]) Curried() Func1[A1, Func1[A2, R]] {
	return func(a1 A1) Func1[A2, R] {
		return Func1[A2, R](func(a2 A2) R {
			return r(a1, a2)
		})
	}
}

type HList interface {
	sealed()
}

  %2 = func.call @simple_test(%arg0, %0, %1) {tac.interface_name = "func1"} : (tensor<4x384x32xf32>, tensor<3xi32>, tensor<3xi32>) -> tensor<1x384x32xf32>
  func.return %2 : tensor<1x384x32xf32>
}

// PARTIAL-LABEL: @simple_test
func.func @simple_test(%arg0: tensor<4x384x32xf32>, %arg1: tensor<3xi32>, %arg2: tensor<3xi32>) -> tensor<1x384x32xf32> attributes {tac.interface_name = "func1"} {

        file("src/main/headers/funcs.h") << """
            int func1();
            int func2();
"""
        file("src/main/cpp/main.cpp") << """
            #include <iostream>
            #include "funcs.h"
            int main () {
                std::cout << func1() << func2() << std::endl;
                return 0;
            }
"""
        file("src/main/cpp/func1.cpp") << """
            #include "lib.h"

	Type1_foo int
	type2     int

	Embed struct { Type1 }
	Uembed struct { type2 }
)

func Func1()     {}
func Func1_Foo() {}
func Func1_foo() {}
func func2()     {}

func (Type1) Func1() {}
func (Type1) Func1_Foo() {}
func (Type1) Func1_foo() {}
func (Type1) func2() {}

func (type2) Func1() {}

type (
	Conflict          int
	Conflict_Conflict int
	Conflict_conflict int
)

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

package main

func run() { // ERROR "cannot inline run: recursive"
	f := func() { // ERROR "can inline run.func1 with cost .* as:.*" "func literal does not escape"
		g() // ERROR "inlining call to g"
	}
	f() // ERROR "inlining call to run.func1" "inlining call to g"
	run()
}

func g() { // ERROR "can inline g with cost .* as:.*"
}

	g(2)()

	// amd64:"LEAQ\tcommand-line-arguments\\.main\\.h\\.func1"
	h(3)()

	// amd64:"LEAQ\tcommand-line-arguments\\.main\\.f\\.g\\.h\\.func4"
	f(4)()
}

func f(x int) func() {
	// amd64:"LEAQ\tcommand-line-arguments\\.f\\.g\\.h\\.func1"
	return g(x)
}

func g(x int) func() {
	// amd64:"LEAQ\tcommand-line-arguments\\.g\\.h\\.func1"
	return h(x)
}

func h(x int) func() {

}

func q(x int) int { // ERROR "can inline q"
	foo := func() int { return x * 2 } // ERROR "can inline q.func1" "func literal does not escape"
	return foo()                       // ERROR "inlining call to q.func1"
}

func r(z int) int {
	foo := func(x int) int { // ERROR "can inline r.func1" "func literal does not escape"
		return x + z
	}

}

func q(x int) int { // ERROR "can inline q"
	foo := func() int { return x * 2 } // ERROR "can inline q.func1" "func literal does not escape"
	return foo()                       // ERROR "inlining call to q.func1"
}

func r(z int) int { // ERROR "can inline r"
	foo := func(x int) int { // ERROR "can inline r.func1" "func literal does not escape"

/*
#cgo CFLAGS: -fsanitize=thread
#cgo LDFLAGS: -fsanitize=thread

int Func1() {
	return 0;
}

void Func2(int x) {
	(void)x;
}
*/
import "C"

func main() {
	const N = 10000
	done := make(chan bool, N)
	for i := 0; i < N; i++ {
		go func() {
			C.Func1()
			done <- true
		}()
		go func() {
			C.Func2(0)
			done <- true
		}()
	}