How to transform all uppercase words into smallcaps?

[ckunte]

In my poor understanding of Typst's scripting, I tried using the below without success:

// set all caps to smallcaps
#show regex("[A-Z\s]+"): scaps => { 
  set text(weight: "regular")
  align(left, smallcaps(scaps))
}

Please can anyone show me how to auto transform all uppercase words into smallcaps (without having to increase the verbosity of body with #smallcaps(content))?

[ckunte]

Ten minutes of trial and error, and I have a working solution for the above:

// turn all uppercase words (with 2 or more characters) into smallcaps
#show regex("([A-Z]{2,})+"): sc => {
  smallcaps(lower(sc))
}

The above one assumes the content has UPPERCASE words, which will remain unmodified. This above in the template preamble retains the content as is, but transforms all UPPERCASE words into lowercase first, and then into smallcaps in the compiled document.

Still if there is a smart(er) way of doing this, then please do share. Thank you.

[epsilonError]

OpenType Features

If your font implements the OpenType features, you could use the combination of "smcp" and "c2sc" in the features parameter for text.

E.g., you could use

// turn all uppercase words (with 2 or more characters) into smallcaps
#show regex("([A-Z]{2,})+"): sc => {
  text(features: ("smcp", "c2sc",))[#sc]
}

Enabling "smcp" is what smallcaps does behinds the scenes. And "c2sc" is an OpenType feature that substitutes capital letters with small caps. If you only want uppercase letters in small caps, you could use ("c2sc",) instead of ("smcp", "c2sc",).

Regex

You might also be able to simplify your Regex string from "([A-Z]{2,})+" to "[A-Z]{2,}". I'm not particularly proficient with regex, but at least for me the simpler form seems to work just as well. (I tend to use https://regex101.com/, which allows trying out the Rust "flavor" of regex that Typst uses, to double-check my regex assumptions.)

With regex change and only small caps-ing uppercase,

// turn all uppercase letters (with 2 or more uppercase characters in a row) into smallcaps
#show regex("[A-Z]{2,}"): sc => {
  text(features: ("c2sc",))[#sc]
}

The edge-case I notice is that any single letter all-cap words (e.g. I or A) won't be made into small caps with this regex.
But maybe that is what you want. If you want to include I and A, "\b[A-Z]+\b" would be a better choice, but I would rather set those manually if the regex is searching the whole document. (The \b checks for a word boundary, that way the A and O in the word "AvocadO" aren't made small caps since they have lowercase letters between them and "AvocadO" is a single word.)

Verbosity Specifically

For cases where you can't avoid using the styling markup in the text (say regex can't find a word without also styling a bunch of words you don't want styled), you can make your own shorter named function to use instead.

An example of this would be:

#let sc(content) = smallcaps(content)

An #smallcaps([example]) line of #smallcaps([text]).

Another #sc([example]) line of #sc([text]).

The trouble here is remembering what sc means if you come back to this document after a long time. Or have to explain it to someone else in future. But it does help reduce the verbosity problem.

My Recommendation

I'd probably use the code:

// turn only uppercase letters to small caps
#let SC(content) = text(features: ("c2sc",))[#content]

// turn all uppercase words (any 2 or more grouping of A-Z ASCII characters) into smallcaps
#show regex("[A-Z]{2,}"): match => {
  SC(match)
}

THIS LINE WOULD BE ALL SMALL CAPS.

#SC([I]) HAVE TO ADD SMALL CAPS MANUALLY TO #SC([A]) LINE LIKE THIS. TO CONVERT #SC([I]) AND #SC([A]).

#SC([Which I could also do this way.]) // Only the 2 uppercase characters in this line would be small caps (W and I).

These kinds of words might be trouble with the regex: A.V., T.V., A, I, O'Brien, O'BRIEN, MAdeUPwoRD, so be sure to take a close look over your document and handle any special cases you have.

This gives a little less verbosity and will only ever change uppercase letters to small caps (which may be a help or a hindrance, depending on your needs). And I would use the highlight function while drafting (i.e., use #let SC(content) = text(features: ("c2sc",))[#highlight(content)]), just so I could skim the changes and figure what what needs fixing.

[ckunte]

Thank you @epsilonError for this comprehensive answer, and also for sharing the underpinning features to enable this 🙏, really helpful. (+1 for adding answers like this one to Typst documentation.)