Input/Output/Match-Case/...

[patrick-kidger]

First of all, thank you for the awesome package.

I've found myself defining some helpers on top of this package for my use-cases, and I'm guessing that some of them might be common enough that others would find them useful too. Would the maintainers of this package be interested in having any of the following upstreamed?

#let Input(doc) = Line([*input* #doc])
#let Output(doc) = Line([*output* #doc]) + Line[$quad$]
#let Sample(var, val) = Line([#var $~$ #val])
#let ForIn(x, xs, code) = For($#x #[*in*] #xs$, code)
#let Case(pattern, code) = (pattern: pattern, code: code)
#let Match(x, ..cases) = {
    if cases.named().len() > 0 {
        panic("`Match` takes only positional arguments.")
    }
    iflike(kw1: "match", kw2: "", kw3: "end", x, {
        for case in cases.pos() {
            if type(case) != dictionary or case.keys() != ("pattern", "code") {
                panic("`Match` should be called with `Case` arguments.")
            }
            iflike(kw1: "case", kw2: "then", kw3: "", case.pattern, case.code)
        }
    })
}
#let Loop(code) = iflike(kw1: "loop", kw3: "end", [], code)

Example document you can copy-paste to see what they look like

Copy-paste the following into https://typst.app/play:

#import "@preview/algorithmic:1.0.6": *

#let Input(doc) = Line([*input* #doc])
#let Output(doc) = Line([*output* #doc]) + Line[$quad$]
#let Sample(var, val) = Line([#var $~$ #val])
#let ForIn(x, xs, code) = For($#x #[*in*] #xs$, code)
#let Case(pattern, code) = (pattern: pattern, code: code)
#let Match(x, ..cases) = {
    if cases.named().len() > 0 {
        panic("`Match` takes only positional arguments.")
    }
    iflike(kw1: "match", kw2: "", kw3: "end", x, {
        for case in cases.pos() {
            if type(case) != dictionary or case.keys() != ("pattern", "code") {
                panic("`Match` should be called with `Case` arguments.")
            }
            iflike(kw1: "case", kw2: "then", kw3: "", case.pattern, case.code)
        }
    })
}
#let Loop(code) = iflike(kw1: "loop", kw3: "end", [], code)

#algorithm(line-numbers: false, {
  Input[Some input $x$]
  Output[Some output $y$]
  Sample[$y$][$x$]
  Line[$-----$]
  ForIn($i$, $(1, ..., 5)$, {
    Line[...]
  })
  Line[$-----$]
  Match($z$,
    Case($(a,)$, $a$),
    Case($(a, b)$, $a + b$)
  )
  Line[$-----$]
  Loop({
    Line[...]
  })
})

The only piece I'm not 100% happy with is the unbalanced indentation around match-case-end, happy to take suggestions on this.

[quachpas]

Thank you! I don't think these should be added to the library, otherwise it might conflict with user keywords. Probably the best thing to do would be to have some documentation about implementing these? Or a more expensive solution is to have more namespace I suppose. In the second case we do run into problems of conflicting standards.

Imo it's better to just add these to the README and you're welcome to send a patch upstream!

Your implementation of match might be generic enough to let users generate their own block logic, that can be a second patch if you'd like to do that. Eg let users change the keywords or depth etc.

Thanks for the feedback!!

[patrick-kidger]

Ok, no worries!
My main concern was that I'm using the iflike function, which I think might not be public API. Would you be okay adding that to the public API to support these use-cases?

[quachpas]

Thx! Yes it's ok as long as an example+ test is added.

Ok, no worries!
My main concern was that I'm using the iflike function, which I think might not be public API. Would you be okay adding that to the public API to support these use-cases?