Bash/Clj-like "case"

[nstgc]

What is the most "ergonomic" way to implement case as it appears in Bash and Clojure. I know Janet has case, however if you have multiple possible matches for the same result, you either has to use multiple entries, or do something else. As an example:

(case "hello"
  ("hi" "Hello" "hello") (println "World")
  :true "...")

case hello in
    hi|Hello|hello)
        echo World
        ;;
    *)
        ...
esac

The Bash is just there for completion's sake. I find it rather unsightly, among other shortcomings. I could use os/shell to run that, but that seems like the worst of all worlds.

In Janet I would write

(case "hello"
  "hi"    (print "World")
  "Hello" (print "World")
  "hello" (print "World")
  "...")

or

(defn foo [bar]
  (case foo
    "hi"    (print "World")
    "Hello" (foo "hi")
    "hello" (foo "hi")
    "..."

but that feels like boiler plate to me. An alternative, and what I'm currently doing, is

(defn in? [el coll]
  (some (partial = el) coll))

(defn foo [bar]
  (cond bar
    (in? foo ["hi" "Hello" "hello"] (print "World")
    "..."))

but that also isn't great. I feel like I'm just using the code equivalent of duck tape, which isn't surprising since I'm nowhere close to being a real programmer.

To those of you who actually know a thing or two about Janet (or just programming in general), how would you solve this?

[tionis]

I've been outsourcing the behaviour I want to duplicate into a function like so:

(defn add [x y] (+ x y))
(defn exec [op & args]
  (case op
    "add" (add ;args)
    "a"   (add ;args)
    (error "not supported")))

You could of course write your own version of the case macro that works on arrays like so:

(defn exec [op & args]
  (multi-case op
    ["add" "a"] (+ ;args)
    ["substract" "s"] (- ;args)
    (error "not supported")))

I don't know if anyone has done that yet.
Might be convenient though, maybe I'll write one to add to my utility library or spork 🤔.

[tionis]

That's also a valid name choice. I think I'll upstream a macro for this to spork/misc when I find the time and have a tested solution.
I guess, this should question can be closed, right?

[nstgc]

I am curious if there are other answer. I do feel like I should try to write that, though. Even if it takes you minutes to my hours, I haven't contributed anything to Janet and I feel like I should. So don't feel rushed. :)

[tionis]

Oh yes, of course, please do try everything out. I myself am also only a student with a few lines of code in this repo.
If you do build something neat for this, please share it. It's a small, welcoming community great to learn and share progress.

[tionis]

As you seem to be a new user for janet I'm also interested in your thoughts and problem while starting to use it,
I (and quite a few others) would like to improve the experience for newcomers.

[nstgc]

Actually, I've been using Janet since last August. 😅 I'm just not much of a programmer.

janet/src/boot/boot.janet

Line 222 in 3a4d56a

(tuple 'if (tuple = sym (in pairs i))

Looking at that, it seems like changing the equality test to one of belonging would be enough for my purposes, though I'm currently cooking up a macro that (1) also takes predicates functions and (2) has a certain "me-ness" to it so as to make it more of a learning experience.

edit: Whatever I make likely won't be idiomatic Janet as I tend to learn more into functional programming that the source code seems to suggest is proper.

[CosmicToast]

The main difficulty is you may want to match on a tuple too.
Thankfully, (= [1] '(1)), which means we can check against tuple/type instead of requiring quote semantics.
Does this work for you?

(defn- switch*
  [& xs]
  (match xs
    [k v & rest]
    (if (and (tuple? k) (= :parens (tuple/type k)))
       [;(interleave k (seq [:repeat (length k)] v))
        ;(switch* ;rest)]
       [k v ;(switch* ;rest)])

    [v] [v]
    (error "unreachable")))
(defmacro switch
  [x & xs]
  (let [cases (switch* ;xs)]
    ~(case ,x
       ,;cases)))

It's an initial attempt and is largely untested, but hey, if it works eh?
The only testing I've done is:

(each e ["hi" "hallo" "ok" "nope"]
  (switch e
          ("hi" "Hello") (print "A")
          ("hello" "hallo") (print "B")
          "ok" (print "then")
          (print "...")))

which seems to work.

[CosmicToast]

Note that the "unreachable" isn't really unreachable but I'm sick and it's an MVP

[nstgc]

Thanks! That's the sort of elegant macro I would have tried (and ultimately failed) to write. It's especially unlikely since I have no idea why [v] [v] is needed.

Hope you feel better soon!

[CosmicToast]

I'll explain [v] [v] real quick, since it's relevant for other situations too.
Match will ultimately match against "any length" as long as it can assign a value to all of the components.
So when you match against [k v & rest] it will be matched against a tuple of at least 2 values.
Let's say you give it [1 2 3 4], you will end up with k = 1, v = 2, rest = [3 4].
If you give it [1 2], you will end up with k = 1, v = 2, rest = [].
But what if you give it [1]? Well, that won't match!
So you need to handle the [v] case specially.

"Ok, but why [v] for the output?
Look at how I'm using it: I later ,;cases (if it's the only entry), which means it must be an enumerable, I can't just return v.
Similarly, in the other case of switch*: ;(switch* rest).
In short, I must return the final ("else") clause wrapped in a tuple, so it can be unwrapped by ; (unsplice).

As for testing, my main concern is in the following cases:
a) what if you want to match against the output of a function? You may need to write ((myfun)), but it would be nice to make sure that works.
b) does case even do destructuring? if so, does it interfere in any way? what if you give it a paren tuple as a symbol? (that last one shouldn't be a concern but you never know)
But I suspect someone else can do that fieldwork if it's to be included in boot.janet, and if not then it doesn't matter.

re: feeling better, I have a chronic illness (several, even)
it's not too bad, but it's not going away anytime soon ^^;;
though it would be nice to go in remission again :)

[nstgc]

Ah, thanks! And yeah, chronic illness sucks.