Default values for function arguments?

[jjmaestro]

I have

const function foo1(arg1: Int): String =
  "arg1: \(arg1)"

_foo1 = foo1(42)

which works as expected:

$ pkl eval function_defaults.pkl

_foo1 = "arg1: 42"

But then, when I tried adding another argument with a default value, I got the following:

(...)
const function foo2(arg1: Int, arg2: Int = 5): String =
  "arg1: \(arg1)" + ", arg2: \(arg2??"")"

_foo2 = foo2(42)

% pkl eval function_defaults.pkl

–– Pkl Error ––
Mismatched input: `)`. Expected one of: `{`, `=`, `:`

7 | "arg1: \(arg1)" + ", arg2: \(arg2??"")"
                 ^
at function_defaults (file:///tmp/function_defaults.pkl, line 7)

The most surprising bit was when I tried going around that issue by using a nullable argument like so:

(...)
const function foo2(arg1: Int, arg2: Int?): String =
  "arg1: \(arg1)" + ", arg2: \(arg2 ?? 4242)"

_foo2 = foo2(42)

And I get the following error:

$ pkl eval function_defaults.pkl

–– Pkl Error ––
Expected 2 function arguments but got 1.

6 | const function foo2(arg1: Int, arg2: Int?): String =
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
at function_defaults#foo2 (file:///tmp/function_defaults.pkl, line 6)

9 | _foo2 = foo2(42)
            ^^^^^^^^
at function_defaults#_foo2 (file:///tmp/function_defaults.pkl, line 9)

106 | text = renderer.renderDocument(value)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
at pkl.base#Module.output.text (https://github.com/apple/pkl/blob/0.25.3/stdlib/base.pkl#L106)

Of course, it works when I pass null:

(...)
_foo2 = foo2(42, null)

$ pkl eval function_defaults.pkl

_foo1 = "arg1: 42"
_foo2 = "arg1: 42, arg2: 4242"

I was expecting the same behavior we have in properties, explained in the language reference:

Type Annotations - Default values

Type-annotated properties have implicit "empty" default values depending on their type:
(...)
(8): Properties of type X? default to Null(x) where x is the default for X.

Advanced Topics - Amending Null Values

In most cases, the Null() method is not used directly. Instead, it is used under the hood to create implicit defaults for properties with nullable type:
(...)
The general rule is: A property with nullable type X? defaults to Null(x) if type X has default value x, and to null if X has no default value.

For the time being, I've worked around this by crafting an Object and passing that instead, amending it if needed:

(...)
local class FooArgs {
  arg1: Int
  arg2: Int?
}

const function foo2(args: FooArgs): String =
  "arg1: \(args.arg1)" + ", arg2: \(args?.arg2 ?? 4242)"

_foo2 = foo2(new FooArgs { arg1 = 42 })

I guess function arguments are different :-? Is this supported? And if not, what's the "pickly way" to do this until it's supported, if ever? 😄

Thanks!

[holzensp]

You're so close to how I would write this.

Taking a step back; first a mini-rant about functions. People grab for them too often. Very many applications of functions are much more cleanly expressed using laziness / late-binding. The fact that one value derives from other, given values is a reason to reach for functions in many languages, but not lazy, value-centric ones. Here's how I'd write your initial example (I understand this is heavily reduced from a real-world case, so I may be shooting at the wrong target); you wrote

const function foo1(arg1: Int): String =
  "arg1: \(arg1)"

_foo1 = foo1(42)

where I'd write

hidden arg1: Int
fixed foo1 = "arg1: \(arg1)"

In your last suggestion, you reach for a class, to aggregate the function parameters and give them default values. I would take one further step, and eliminate the function itself:

local class FooArgs {
  arg1: Int
  arg2: Int?
  fixed foo2: String = "arg1: \(args.arg1)" + ", arg2: \(args?.arg2 ?? 4242)"
}

_foo2 = new FooArgs { arg1 = 42 }.foo2

There is a general pattern for using classes to define functions. You can even do this in multiple directions;

class Temperature {
  celcius: Number = kelvin - 273.15
  fahrenheit: Number = celcius * 9 / 5 + 32
  kelvin: Number = (Fahrenheit - 32) * 5 / 9 + 273.15
}

boilingPointOfWaterInKelvin = new Temperature { celcius = 100 }.kelvin
absoluteZeroInFahrenheit = new Temperature { kelvin = 0 }.fahrenheit

(Notice the difference in the use of fixed compared to FooArgs.)

We are still considering how to make functions more expressive, but the power of laziness, and using objects as functions is actually enough for so many scenarios, so it's not a priority.

I think I only ever user functions when an instance of my (module) class needs extra information that I can't provide at definition time.

[jjmaestro]

Wow 🤯 Thanks!! I think I get it! And yeah, in my case, as you mention it's heavily reduced from a real-world case, but even then I think it's probably doable and even "pickly" to do it using classes 😃 I'll mark this as the answer, I think it's the best one.

Although, I'd also like to see some syntactic sugar added to function that could let me pass default values, it could also lower the barrier of entry to the language (and yeah, I know that might also be a bad thing too 😅).

Finally, I think it would be great to add this pattern to the documentation when talking about functions, I think it would greatly help to understand the philosophy of the language better and it can help noobs like me on their quest to grok Pkl 😄