How to write a func that returns a func that returns a Generic type

I have the following go code which DOES NOT COMPILE

What I am looking for is how to write a func that returns a func that returns a generic type

package main

import (
	"log"

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

type logAndReturnDefault[T constraints.Ordered] func(input T) T

func iWillRewturnAFunc(name string) logAndReturnDefault{
	return func(input string){
		log.Println("I am in the func that will be returned as a returned value")
	}
}

func Add[T constraints.Ordered](a T, b T) T {
	i := iWillRewturnAFunc("ABC")
	return a + b + i
}

func main() {
	result := Add(1, 2)
	result2 := Add(1.2, 3.4)
	log.Printf("", result)
	log.Printf("", result2)
}

My intention is to use iWillRewturnAFunc to return a func that can return a generic type.

But of-course I am failing, as I am not able to identify the syntax for the declaration of iWillRewturnAFunc func.

There is some mismatch between what you want to achieve and your code.

A generic function is nothing but a generic type, so a function returning a generic type must be generic:

func iWillRewturnAFunc[T constraints.Ordered](name string) logAndReturnDefault[T] {
	return logAndReturnDefault[T](func(input T) T {
        var t T
        ...
		return t
	})
}

But what you are trying to do is to return a specific instance for string, which can be done:

func iWillRewturnAStrFunc(name string) logAndReturnDefault[string] {
	return func(input string) string {
		log.Println("I am in the func that will be returned as a returned value")
		return ""
	}
}

Answering my own question. In the below code NOW COMPILES AND RUNS.

The return Type of generic is decided by the Add function. will be provided to the nested function as both are using the same generic interface T constraints.Ordered .

Just like this, There is a way to work with 2 different Generic type as well. by defining U constraints.Ordered (or any other interface) .

package main

import (
	"log"
	"golang.org/x/exp/constraints"
)

type LogAndReturnDefaultFunc[T constraints.Ordered] func(T) T

func iWillReturnAFunc[T constraints.Ordered](name T) LogAndReturnDefaultFunc[T] {
	log.Println(name)
	// or do something with the *name"
    return LogAndReturnDefaultFunc[T] (func(input T) T {
        t := name
		log.Println(input)
		// Do something with input
        return t
    })
}

func Add[T constraints.Ordered](a T, b T) T {
	// Call `iWillReturnAFunc``, that will return a func
    returnedFunc := iWillReturnAFunc(a)
	// Run the returned func to get its o/p
	outputOfReturnedFunc := returnedFunc(b)
	//Do something with the Output of the func
	log.Println(outputOfReturnedFunc)
    return a + b + outputOfReturnedFunc
}

func main() {
	result := Add("abc", "DEF")
	result2 := Add(1.2, 3.4)
	log.Printf("%v\n", result)
	log.Printf("%v\n", result2)
}