Holding Konglish to Its Lane

"English inside Korean should read the Korean way. The same rule must not touch English that's standing on its own."

The Bilingual Problem

Korean prose is full of embedded English — technical terms, brand names, acronyms sitting inside Korean sentences. When you're speaking Korean, you want that embedded English read the Korean way: an acronym pronounced as Koreans pronounce it, numbers read in Korean. But here's the trap: the exact same rule, applied to a sentence that's genuinely English, mangles it. "Read this the Korean way" is right inside Korean and wrong everywhere else. A naive global rule can't tell the two apart.

Scope to Context, Match on Boundaries

Konglish containment solves this with two moves. First, scope: the Korean-context rules — the Korean-context dictionary and Korean-style number reading — apply only within Korean text, not to standalone English spans. Second, word-boundary ASCII keys: an embedded term is matched as a whole token, not as a substring. So the acronym is caught exactly, and the letters of an unrelated English word are never accidentally swept into a Korean reading. Scope decides when the rule fires; boundaries decide what it touches.

Why Both Halves Are Needed

Scope without boundaries would still misfire inside Korean — matching a substring and warping a word that merely contains the same letters. Boundaries without scope would still reach into pure-English text where the Korean reading doesn't belong. Only together do they keep Konglish in its lane: the right reading for embedded English, and ordinary English left completely alone. It's a small, precise piece of engineering that's the difference between a bilingual voice that sounds natural and one that sounds confused.

Code

Scope to Korean context; match whole tokens only·python

# Konglish: English embedded in Korean should read the Korean way --
# but the SAME rule must NOT warp standalone English elsewhere.
def apply_konglish(text: str) -> str:
    out = []
    for span in segment_by_language(text):       # Korean spans vs English spans
        if span.lang == "ko":
            # In Korean context: Korean-context dictionary + Korean number
            # reading, matching ASCII terms on WORD BOUNDARIES, not substrings.
            out.append(apply_ko_context(span.text))   # embedded 'API' -> KO reading
        else:
            out.append(span.text)                # standalone English: untouched
    return "".join(out)

# Boundary keys: the token 'API' matches, but the 'api' inside 'therapist'
# never does. SCOPE picks when the rule fires; BOUNDARIES pick what it touches.

Exercise

Find a transformation that's correct in one context but harmful applied globally — auto-linking words, currency formatting, capitalizing acronyms, a find-and-replace across a document. Construct one input where a naive global apply corrupts something it shouldn't. Then split the fix into scope (where does the rule belong?) and boundaries (what exactly may it match?).

Hint

Every over-applied rule fails the same two ways: it fired in the wrong place (needs scope) or it matched too much in the right place (needs boundaries). Name which half your example needs — usually it needs both.