case with two alternative options per command

[MaxGyver83]

I would like to reproduce this POSIX shell code with two alternative options per match/command:

case "$1" in
-h|--help) usage; exit ;;
-V|--version) echo "$VERSION"; exit ;;
esac

The verbose way would be something like:

(case arg
  case1a command1
  case1b command1
  case2a command2
  case2b command2)

I have tried to create a macro that turns case1a case1b command1 into case1a command1 case1b command1.

My attempt:

(defmacro twocases [case1 case2 command]
  case1 command case2 command)

It does not work:

(case 3
  (twocases 1 2 (print "1 or 2"))
  (twocases 3 4 (print "3 or 4")))

This prints 1 or 2.

Can macros return multiple symbols at all? Or only one form? Could somebody tell me why this doesn't work?

[ianthehenry]

Yeah, Janet's native macros can only expand to a single form, so there's not a direct way to do what you're trying to do.

case is a special-case of cond, and you could use cond directly:

(def subject 3)
(cond
  (or (= subject 1) (= subject 2)) (print "one or two")
  (or (= subject 3) (= subject 4)) (print "three or four"))

But that's clearly not as nice as case. It would be possible to write a custom case macro that understood your twocases form, but it's kinda sad that it wouldn't compose with built-in things. There are... ways... to define macros that would allow your general twocases macro to work. But... that's not really accessible.

I've written a library called pat that has a match macro that can express this succinctly which you might consider using:

(import pat)

(pat/match 3 
  (or (= 1) (= 2)) (print "one or two")
  (or (= 3) (= 4)) (print "three or four"))

# or even more succinctly:
(pat/match 3 
  (or ,1 ,2) (print "one or two")
  (or ,3 ,4) (print "three or four"))

match is more general than case though and this might produce less efficient code.

Also if you are literally trying to replicate that argument-parsing code, you might consider cmd which would let you write:

(cmd/def
  --other-flag :string
  [-v --version] (effect (fn []
    (print "1.0")
    (os/exit 0))))

(print other-flag)

And will automatically generate --help/-h/-? for you.

[MaxGyver83]

Thank you for your detailed answer!

Yeah, Janet's native macros can only expand to a single form

Good to know. I couldn't find this information anywhere. (Maybe it's obvious for people used to Lisp.)

case is a special-case of cond, and you could use cond directly:

(def subject 3)
(cond
  (or (= subject 1) (= subject 2)) (print "one or two")
  (or (= subject 3) (= subject 4)) (print "three or four"))

But that's clearly not as nice as case.

Indeed. It's even worse for strings where you need deep=.

It would be possible to write a custom case macro that understood your twocases form, but it's kinda sad that it wouldn't compose with built-in things. There are... ways... to define macros that would allow your general twocases macro to work. But... that's not really accessible.

I stumbled over this, probably after reading your book. I'm not yet ready for an alternative macro system :-)

I've written a library called pat that has a match macro that can express this succinctly which you might consider using:
...

Also if you are literally trying to replicate that argument-parsing code, you might consider cmd which would let you write:
...

And will automatically generate --help/-h/-? for you.

pat is a great improvement. Thanks for sharing. cmd might work for my script as well. I'm not sure if it can handle all the possible arguments (the first argument is positional but -h/--help/-V/--version might be only/first arguments).
Actually, my goal was to provide simply a script that just works. No dependencies (except Janet itself) and no installation process. But maybe it makes sense to turn it into a full project and provide a binary for users that don't want to install a script plus its "rat tail" (not sure if you can say this in english 😆).

[ianthehenry]

If you have a command-line invocation that cmd can't parse, I'd be interested to hear about it. (It does support optional positional arguments, and can parse mixed positional and named arguments.)

Actually, my goal was to provide simply a script that just works. No dependencies (except Janet itself) and no installation process.

This is very reasonable. Depending on your audience a Janet dependency might be a big lift though!

a binary for users that don't want to install a script plus its "rat tail" (not sure if you can say this in english 😆)

I don't think there's an equivalent phrase in English but it's evocative enough that the meaning is very clear.