Variadic List pattern

[gefjon]

I have grown tired of writing patterns like (Cons a (Cons b (Cons c (Nil)))), and would like to instead be able to write (List a b c), like how the Trivia list pattern works.

Bonus points for having a way to express a "rest" argument, like the Trivia list* pattern, but I'm not sure how the syntax for that should look.

[stylewarning]

Just ideations: WDYT about define-pattern which works basically equivalently to Lisp's define-type (a thin macro veil over the type system)?

[gefjon]

I don't personally feel any need to expose a define-pattern to the user (though @rvs314 might feel differently; I know he's been doing more work with custom data structures than I have), but I can't really see any other way to define patterns for coalton-library types like Vector, which I think would be nice to have.

I think in order to have a user-visible define-pattern, I'd want to have it be a Coalton-native macro facility that doesn't require lots of cl: prefixes, though I suppose I could be convinced to offer something like define-pattern-macro analogous to our use of cl:defmacro. I just wouldn't want to waste the name define-pattern on a facility that I want to replace eventually anyway. I like the idea of using the -macro suffix for the version that behaves like cl:defmacro i.e. you define an expander function in Common Lisp.

Anyway, I think in the short term, it would be easy to special-case a List pattern in the compiler, without having to make any tough decisions about how much we expose CL macros to users, how define-pattern should work, compilation semantics (do define-pattern forms have to go in separate files? Do we implicitly hoist them? etc.), etc.

[rvs314]

I think custom patterns would be cool, but I agree with @gefjon that it seems more productive to make macros in general more user-friendly, then approach this problem. I haven't run into many cases where I'm matching on constant-size lists (it seems like tuples would be better for that case), but I could definitely see something like List* being useful.

[ornamentist]

I was wondering also about pattern matching on tuple too: #280 (comment)