I also don't use it often. But when I do, it's very satisfying, haha. See the `retry` function from my other comment, for example. Another is `expect<IllegalStateException> { ... }` for use in tests. Or the small helper functions the Kotlin stdlib offers like `with`, `run`, `let` etc.

Yeah, basically. And an important point being that inlining allows you to do this without the performance tradeoff that higher-order functions otherwise would have (on the JVM at least).

To illustrate - I've written custom `retry` functions before that look like this: `retry(attempts = 3) { /* ... */ }`. Yes, you can do similar things in other languages, but the syntax just integrates super neatly into the language and it has less overhead than regular higher-order functions.

It's just an example for simplicity. You can do whatever want with it, that's the point. And also, the existing repeat, while provided out of the box, is in itself actually making use of exactly this feature, allowing it to be part of the standard library, and *not* actual the language itself.

It allows you to add custom control flow structures that don't exist natively in the language, the example here being the `repeat(x)`-loop.

if-Statements, for-loops, those things are control flow structures. Anything that controls how the program "flows" through its instructions, in what order and how often.

en.wikipedia.org/wiki/Control...

It's that, plus some syntactic sugar to make it feel almost like language-level control flow, plus inlining that prevents actual function objects from having to be created for every invocation. Not much more to it, but nonetheless a very nice DX

Went through it, look all good except one comment 👍

Yeah, that's in the PR. Unless I missed it somewhere, totally possible!

Wait didn't I fix that one?

For that website I'm working on we're planning to add a dictionary of domain-specific words and phrases that we always want translated in a specific way to the prompt. That's unfortunately not generalizable and would have to be done manually per language, but it would help with things like "Handle"

Here you go, quick review of the German translations. Hope that helps :)
github.com/lucid-softwo...

I'm assuming this one would be the source to compare against? github.com/lucid-softwo...

I could give it a shot for German, in case you starting to follow me back literally a couple of minutes ago counts as knowing me 😅

Not sure how well that translates to your setup, but it's working pretty well for us. We're also pretty decoupled from the LLM for all but the actual translation itself, since it just translates a plain list of strings to translate. Could switch to any other model or translation service easily

I'm currently building a translation pipeline for a content-heavy website, and running translations in smaller batches seems to work pretty well. One LLM call per blogpost/page etc., and we also checksum the individual source strings so that only new/updated texts are included with every run.