Map function

[arran4]

As generics don't seem to be supported by text/template yet I produced the following: (Or does anyone know what other library I should be looking at?)

Would something like this be accepted into the project?

package main

import (
    "errors"
    "fmt"
    "os"
    "reflect"
    "text/template"
)

var (
    ErrInputFuncMustTake0or1Arguments     = errors.New("expected second parameter function to take 0 or 1 parameters")
    ErrExpectedFirstParameterToBeSlice    = errors.New("expected first parameter to be an slice")
    ErrExpected2ndArgumentToBeFunction    = errors.New("expected second parameter to be a function")
    ErrExpectedSecondReturnToBeError      = errors.New("expected second return type to be assignable to error")
    ErrExpectedSecondArgumentToBeFunction = errors.New("expected second return of function f to take 1 or 2 parameters instead")
    ErrExpected2ReturnTypes               = errors.New("expected return with 1 or 2 arguments of types (any, error?)")
)

func MapTemplateFunc(array any, f any) (any, error) {
    av := reflect.ValueOf(array)
    if av.Kind() != reflect.Slice {
        return array, fmt.Errorf("%w not %s", ErrExpectedFirstParameterToBeSlice, av.Kind())
    }
    fv := reflect.ValueOf(f)
    if fv.Kind() != reflect.Func {
        return array, ErrExpected2ndArgumentToBeFunction
    }
    var fvfpt reflect.Type
    switch fv.Type().NumIn() {
    case 0:
    case 1:
        fvfpt = fv.Type().In(0)
    default:
        return array, ErrInputFuncMustTake0or1Arguments
    }
    var fvfrt reflect.Type
    switch fv.Type().NumOut() {
    case 1:
        fvfrt = fv.Type().Out(0)
    case 2:
        fvsrt := fv.Type().Out(1)
        if !fvsrt.AssignableTo(reflect.TypeOf(error(nil))) {
            return array, fmt.Errorf("%w instead got: %s", ErrExpectedSecondReturnToBeError, fvsrt)
        }
    default:
        return array, fmt.Errorf("%w got: %d", ErrExpectedSecondArgumentToBeFunction, fv.Type().NumOut())
    }
    l := av.Len()
    ra := make([]reflect.Value, l)
    var newType reflect.Type = fvfrt
    toan := reflect.TypeOf(any(nil))
    for i := 0; i < l; i++ {
        var r []reflect.Value
        switch fv.Type().NumIn() {
        case 1:
            if fvfpt != nil {
                ev := av.Index(i)
                if !ev.Type().AssignableTo(fvfpt) {
                    return nil, fmt.Errorf("item %d not assignable to: %s", i, fvfpt)
                }
                r = fv.Call([]reflect.Value{ev})
                break
            }
            fallthrough
        case 0:
            r = fv.Call([]reflect.Value{})
        default:
            return array, ErrInputFuncMustTake0or1Arguments
        }
        if r == nil {
            continue
        }
        if len(r) != 1 && len(r) != 2 {
            return array, fmt.Errorf("f execution number %d returned: %d results %w", i, len(r), ErrExpected2ReturnTypes)
        }
        if len(r) == 2 && !r[1].IsNil() {
            return nil, fmt.Errorf("f execution number %d returned: %w", i, r[1].Interface().(error))
        }
        rt := reflect.TypeOf(r[0])
        if newType == nil {
            newType = rt
        } else if rt != newType && !rt.AssignableTo(newType) {
            rt = toan
        }
        ra[i] = r[0]
    }
    if newType == nil {
        return ra, nil
    }
    nra := reflect.MakeSlice(reflect.SliceOf(newType), l, l)
    for i, e := range ra {
        nra.Index(i).Set(e)
    }
    return nra.Interface(), nil
}

func main() {
    // Create a template.
    funcs := map[string]any{
        "map": MapTemplateFunc,
        "inc": func(i int) int {
            return i + 1
        },
        "odd": func(i int) bool {
            return i%2 == 1
        },
    }
    tmpl := template.Must(template.New("").Funcs(funcs).Parse(`
        {{ map $.Data $.Funcs.inc }}
        {{ map $.Data $.Funcs.odd }}
    `))

    // Create some data to be used in the template.
    data := struct {
        Data  []int
        Funcs map[string]any
    }{
        Data:  []int{1, 2, 3, 4},
        Funcs: funcs,
    }

    // Execute the template with the data.
    err := tmpl.Execute(os.Stdout, data)
    if err != nil {
        fmt.Println(err)
    }
}

It would be unreasonable for functions like this to match some of the clauses here: We followed these principles to decide which functions to add and how to implement them:

• Use template functions to build layout. The following types of operations are within the domain of template functions:
  • Formatting
  • Layout
  • Simple type conversions
  • Utilities that assist in handling common formatting and layout needs (e.g. arithmetic)
• Template functions should not return errors unless there is no way to print a sensible value. For example, converting a string to an integer should not produce an error if conversion fails. Instead, it should display a default value.
• Simple math is necessary for grid layouts, pagers, and so on. Complex math (anything other than arithmetic) should be done outside of templates.