brackets for function arguments

[mcarifio]

First, ty for janet-lang. It's neat to explore although I don't exactly yet know where I might use it.

Like clojure and unlike various lisps and scheme, janet uses brackets for function argument delimiters, e.g. (defn echo [token] (print token)). I found this jarring in clojure and find it jarring here. Yes, it's just syntax and yes, I should just get over it. But I've never really understood the design choice so I'll ask here now: why?

[CFiggers]

Fun fact, you actually can use parens for the arguments array if you want to 🤪

Janet 1.33.0-f91e5994 linux/aarch64/clang - '(doc)' for help
repl:1:> (defn echo (token) (print token))
<function echo>
repl:2:> (echo "Hello, world")
Hello, world
nil

[sogaiu]

Oops, I guess @CFiggers was faster (^^;

---

I don't have an answer to your question, but if you really must, I think you can use parentheses:

$ janet
Janet 1.34.0-e2a8951f linux/x64/gcc - '(doc)' for help
repl:1:> (defn a (x) (+ x 1))
<function a>
repl:2:> (a 2)
3

It looks like there are some folks who've discussed why square brackets are used in the way mentioned above for Clojure:

• https://ericnormand.me/mini-guide/parens-vs-brackets-in-clojure
• https://stackoverflow.com/questions/2540237/are-the-square-brackets-in-clojures-defn-defmacro-and-binding-really-a-vector

[ianthehenry]

I don't know an official reason but I think the square bracket version is easier for me to parse because of the following heuristic that works most of the time:

Whenever you see round parens, the first element is significant in some way (it's treated or interpreted or behaves differently from the remaining elements). Whenever you see square brackets, all elements in the brackets are on equal footing.

In (defn foo (x y z) ...), there's nothing special about x, so it reads oddly to me. (defn foo [x y z] ...) feels more natural. Also (let [x 1 y 2] ...) vs (let (x 1 y 2) ...). That x really sticks out! But it's not actually special in this context.

The scheme-style (def (foo x y z) ...) also parses correctly for me. But I prefer the square bracket approach for another reason though -- it mirrors destructuring syntax.

Like (def [x y] point). The arguments to a function are really a "list" of some kind, so you destructure it in the same way, binding to each element in turn. And you can use other syntaxes that work in patterns, like (def [first & rest] foo) or (defn example [first & rest] ...).

(This argument falls apart a little because the function argument list supports a couple pieces of syntax that don't work in regular list destructuring, like &opt. Also you can't write (defn foo args ...), you have to write (defn foo [& args] ...). It's not literally a pattern. But there are symmetries...)

(Also this is also a little undercut by the fact that Janet allows you to write (def (x y) point) but that's just weird to me.)