Proposal: Add "functions" to templates

[technosophos]

I've been trying to come up with a way to call templates like functions (with arguments).

So far, the best I've been able to do is:

{{ include "some.template" (dict "NAME" "value") }}

Would it be helpful to simulate a Bash-like function call like this?

# Execute a template as if it were a function that takes arguments.
{{ func "some.template" $param $param2 }}

This could be used as a way to call templates that look like this:

{{ define "some.template" }}
  # Arguments are passed in using an Args array.
  {{ $arg1 := index .Args 0 }}
  {{ $arg2 := index .Args 1 }}
  # Do something
{{ end }}

This is something I am looking for and I was planning to read gotpl in detail for finding this functionality.

Current state of templates is getting repetitive and I believe this will solve it

[alanmeadows]

We are using something like your example:

{{ define "some.template" }}
  # Arguments are passed in using an Args array.
  {{ $arg1 := index .Args 0 }}
  {{ $arg2 := index .Args 1 }}
  # Do something
{{ end }}

See https://github.com/att-comdev/openstack-helm/blob/master/helm-toolkit/templates/_endpoints.tpl#L129

My issue with this is it lacks support for optional arguments, which is important if we think of charts as an evolving piece of software. Everything is positional which makes refactoring hard, and it makes optional arguments impossible because there is no good way to gracefully test for the existence of elements that I am aware of. This is also tangential to the issue where accessing nested elements where the parent doesn't exist implodes just about everything.

The lack of named arguments, which kind of goes hand in hand with removing positional and offering optional arguments, would greatly increase readability. tuple is simply not enough long-term.

In other words

# define it
{{- define "helm-toolkit.my_function" -}}
{{- $arg1 := index . 0 -}}
{{- $arg2 := index . 1 -}}
{{- $optional_arg3 := index . 3 | default "None" -}}

# use it and blow up
{{ tuple "foo" "bar" | include "helm-toolkit.my_function" }}

In the example above, if arg3 is not passed, at least as an empty string (which is not ideal for readability) the index call will implode.

The ability to silently test for the presence of vars, lengths of arrays, and be able to access non-existent nested maps without exploding will really facilitate using what already exists as function building blocks.

[technosophos]

@alanmeadows Thanks for the feedback. I'll have to see to what extent I can accommodate optional params without risking the behavior of a failed index lookup. I wonder if there is a way to cleverly wrap a define block in a way that I could intercept some parameters.

[databus23]

How about passing the arguments as a map to the template instead of an array.

e.g. map[string]string{"1":"value1", "2":"value2"}

Shouldn't this then work?

{{- $arg1 := .1 -}}
{{- $arg2 := .2 -}}
{{- $optional_arg3 := .3 | default "None" -}}

[technosophos]

@databus23 That could work well. I like that idea.

[sgnl19]

We're using a dict to inject parameters for readability reasons:

{{- define "some.template" -}}
{{- $arg1 := index . "arg1" -}}
{{- $arg2 := index . "arg2" -}}
...
{{- end -}}

{{ some.template (dict "arg1" "first arg" "arg2" "second arg")

[fejta-bot]

Issues go stale after 90d of inactivity.
Mark the issue as fresh with /remove-lifecycle stale.
Stale issues rot after an additional 30d of inactivity and eventually close.

If this issue is safe to close now please do so with /close.

Send feedback to sig-testing, kubernetes/test-infra and/or fejta.
/lifecycle stale

[fejta-bot]

Stale issues rot after 30d of inactivity.
Mark the issue as fresh with /remove-lifecycle rotten.
Rotten issues close after an additional 30d of inactivity.

If this issue is safe to close now please do so with /close.

Send feedback to sig-testing, kubernetes/test-infra and/or fejta.
/lifecycle rotten
/remove-lifecycle stale

[sparty02]

/remove-lifecycle rotten