Allow passing arguments to dependencies

[casey]

I've started working on passing arguments to dependencies, see #289, a longstanding feature request.

Open questions to resolve:

Syntax

• 1. Lisp style:

bar name options:
  ./build {{name}} {{options}}

foo: (bar "arg" "baz")

• 2. Fortran style:

bar name:
  ./build {{name}}

foo: bar("arg", "baz")

Lisp can be pretty incomprehensible, for example:

foo: (bar 'a' + 'b' 'c' + 'd')

As opposed to:

foo: bar('a' + 'b', 'c' + 'd')

However, I think in some sense lisp style is more natural, since recipe invocation on the command line doesn't require parenthesis or commas. At the moment I'm leaning towards lisp style.

Repeat dependency invocations

Just, like Make, will only run a recipe once per invocation, even if it appears multiple times in a dependency tree. For example, given the following, just bob will run bar only once, even though foo and baz both depend on it:

bar:

foo: bar

baz: bar

bob: foo baz

However, the situation is complicated by arguments. Consider:

build target:
  ./build {{target}}

release: (build "foo") (build "bar")
  ./release

Clear, the user intends to run build twice, once for "foo" and once for "bar".

I think a reasonable approach would be to run recipes once per recipe and combination of arguments. So given the following justfile, just release would run build "foo", build "bar" and build "baz":

build target:
  ./build {{target}}

build-foo: (build "foo") (build "bar")

build-baz: (build "baz") (build "bar")

release: build-foo build-baz

I can't immediately think of any counter-examples where this behavior wouldn't be desirable, so barring any counter examples, this is what I'll implement.

To Do

• error on undefined variables in arguments
• allow recipes with parameters in dependencies
• error if wrong number of arguments are passed to dependency
• test assignments can be used in arguments
• test parameters can be used in arguments
• test functions can be used in arguments
• test backticks can be used in arguments
• dependency memoization is correct (recipe with same args run once, different args run multiple times)
• update readme

[clarfonthey]

I also think the lisp style is the way to go.

[runeimp]

I'm good with either but I'd say the "lowest common denominator" might be the Fortran style. Most languages I've dealt with handle functions in the same manner that you have Fortran listed. Were as the LISP style is similar to calling functions in a subshell. So if your coming from anything other than LISP (and Scheme?) development or shell scripting the Fortran style will be more natural.

[casey]

@clarfon and @runeimp, thanks for the feedback! I decided to go with the lisp-style, just because it felt more natural, and to make it visually distinct from function invocations.

As for duplicate recipe invocations, Just will run every combination of recipe and arguments at most once.

For example in:

foo: (bar "A") (bar "A")
bar x:

just foo will run bar once with the argument "A".