match with shorter list pattern

[z-rui]

How to interpret the following?

(match [1 2]
  [x] 1
  [x y] 2)

With Janet 1.38.0, it evaluates to 1, instead of 2.

It looks like a list pattern only needs to match the prefix of the target value. The documentation is a bit vague:

an array or bracket tuple will match only if all of its elements match the corresponding elements in x.

Is this a bug or a feature? I think prefix matching can be better expressed as [x & _]. (Side note: currently this will make a slice for the rest elements and bind it to _, probably not needed.)

[sogaiu]

If I'm understanding what's being described here, I believe it's a known characteristic.

---

On a side note, I think it's discussed in chapter 6 of @ianthehenry's Janet Guide.

I don't know how to link to the specific bit, but I think searching for:

implementation of pattern matching

may get one to a relevant section.

[z-rui]

Also multi-bindings do not do arity check:

(def [x] [1 2 3])  # x binds to 1
(def [x y z] [1])  # x binds to 1; y, z binds to nil

This feels like Lua's multi-assignment behavior. But unlike Lua, it is inconsistent with argument passing:

(defn f [x] x)
(apply f [1 2 3])  # arity check error
(def [x] [1 2 3]) # no error

function f(x) return x end
f(1, 2, 3)  -- returns 1
x = 1, 2, 3 -- x = 1

Personally, I like the arity check, as it prevents potential programming errors. It may be nice to have multi-bindings follow the same rule as argument passing:

# proposed usage
(def [x y z] [1 2 3]) # x=1, y=2, z=3
(def [x] [1 2 3]) # arity error
(def [x y z] [1]) # arity error
(def [x &] [1 2 3]) #x=1
(def [x &opt y z] [1]) # x=1, y=z=nil

Although the last two cases may not be very useful. If the implementation can share the logic, it may be nice to have them too.

[sogaiu]

I think @ianthehenry has explored this space and IIUC his pat library incorporates some of his thoughts about and experience with match.

If people haven't taken a look already, may be it's worth checking out?

[bakpakin]

This will not change for backwards compatibility purposes - however, one is free to implement their own version of pattern matching. Alternatively, one could add new syntax for arity strict matching.