Four things Python can't do. Here's what U does instead.

import numpy as np

vals = np.array([1,2,3,4,5,6,7,8,9,10])
sq   = vals ** 2
total = sq.sum()

# Fast — but only because the work
# left Python entirely. Step outside
# what NumPy vectorizes and you are
# back to an interpreted loop, or
# writing C.

f main() -> I
	vals: [I] +V = [1,2,3,4,5,6,7,8,9,10]
	sq = vals.map(v => v * v)
	r => sq.sum()

// +V is the whole change.
// The lambda is ordinary U — it is
// compiled, not dispatched into a
// separate array runtime.

What the annotation buys you

from collections import OrderedDict

class LRU:
    def __init__(self, cap):
        self.cap = cap
        self.store = OrderedDict()

    def get(self, key):
        if key not in self.store:
            return -1
        self.store.move_to_end(key)
        return self.store[key]

    def put(self, key, val):
        if key in self.store:
            self.store.move_to_end(key)
        elif len(self.store) >= self.cap:
            self.store.popitem(last=False)
        self.store[key] = val

d Node
	key: S +M = ""
	val: I +M = 0
	hits: I +M = 0

d LRU
	cap: I +M = 2
	keys: [S] +M = []
	store: {S: Node} +M = {}

	f get(kk: S) -> I
		t.store.has(kk) == false ? r => 0 - 1
		nd = t.store[kk]
		nd.hits = nd.hits + 1
		t.touch(kk)
		r => nd.val

	f touch(kk: S) -> none
		fresh: [S] +M = []
		keep = kk
		t.keys.on(ex => ex != keep ? fresh.push(ex) ! none)
		fresh.push(keep)
		t.keys = fresh
		none

	f evict() -> none
		t.keys.len == 0 ? r => none
		victim = t.keys[1]
		rest: [S] +M = []
		gone = victim
		t.store.delete(gone)
		t.keys.on(ex => ex != gone ? rest.push(ex) ! none)
		t.keys = rest
		none

	f put(kk: S, vv: I) -> none
		t.store.has(kk) == false & t.keys.len >= t.cap ? t.evict()
		t.store = t.store.set(kk, Node({ key: kk, val: vv, hits: 0 }))
		t.touch(kk)
		none

What the U version tells you that the Python version doesn't

The Python is shorter, and for an interview whiteboard that's the right answer. What the U buys is that every field carries its contract: keys: [S] +M says this list is mutable and holds strings, store: {S: Node} +M pins both key and value type. Change +M to +M(MVCC) on the declaration and the same cache becomes safe for concurrent readers without touching a method body. That's the argument for annotations carrying semantics rather than documentation.

The number that was wrong, and the number now

We reported 24/24 Flask 3.1 files clean. Here is what "clean" was measuring, verbatim from the old batch checker:

var hasRawPy = u.split('\n').some(function(l){
  var lt = l.trim();
  return !lt.startsWith('//') && !l.startsWith('\t\t\t')
      && (/\bdef\b/.test(lt) || /\bself\./.test(lt));
});

It greps the output for the strings def and self.. No lint, no compile, no execution. "Clean" meant the text no longer looked like Python. The transpiler now refuses what it cannot translate, so the number means something:

Five out of twenty-four is a much worse headline than twenty-four out of twenty-four, and it is the first number here that can survive someone checking it.

What refusal looks like

A file that cannot be faithfully translated now says so in its own first line, with the construct, the source line, and what to do about it. There is no way to read the output and mistake it for a working translation.

// ═══════════════════════════════════════════════════════════════
// TRANSLATION INCOMPLETE — 1 construct could not be carried into U.
// The code below is NOT equivalent to the Python it came from.
// ═══════════════════════════════════════════════════════════════
// ✗ PY007  line 1  Decorator dropped — it rewrites the function at
//                  import time and that effect is not carried into U.
//     → Inline what the decorator does, or register it explicitly.

f handler(str: Tree)
	r => str.upper()

The refusal catalogue

Thirty codes, nineteen of them fatal. Every one names a Python construct whose meaning has no U equivalent, and every one carries a suggested rewrite. These are the counts across the Flask source:

What got fixed on the accept side

Refusing more is only half of it. These were producing U that could not parse, and now translate correctly:

The first row was the worst of them. uName() mapped a single-letter parameter through a stock table (s → str) while the body renamer doubled the letter (s → ss), so every function with a one-letter parameter emitted a signature and a body that disagreed. Both paths now share one renamer.

The structural defect is fixed: the transpiler previously had no concept of "I cannot translate this," so it always succeeded — which is exactly why the metric read 24/24. It now returns ok: false and a list of coded diagnostics, and the batch checker reports acceptance rather than the absence of the word def.

The realistic shape today: keep Python for orchestration, glue, and everything served by its library ecosystem. Write the numerically exact parts, the vectorized parts, and the shared-state parts in U, compile them to C, and call across. That's a claim about a boundary, not a migration.