santosomar/code-translation

Code Translation

Function-level translation between languages. The goal is observably equivalent behavior — same inputs → same outputs, same side effects, same error behavior. Not line-by-line transliteration; idiomatic code in the target.

For whole modules/packages, → module-level-code-translator (handles imports, file structure, cross-function concerns).

The three layers

1. Syntax — the easy part. for x in xs ↔ for (auto& x : xs). Mechanical.
2. Semantics — the dangerous part. 3 / 2 is 1 in Python 2, 1.5 in Python 3, 1 in C. Integer overflow, null semantics, string encoding.
3. Idiom — the quality part. [x*2 for x in xs if x > 0] → Java stream, not a for-loop with an ArrayList. Optional but expected.

Semantic minefields — per language pair

| Source → Target | What silently changes | | ---------------- | ---------------------------------------------------------------- | | Python → Java | int unbounded → int 32-bit overflow. / float vs int. Dicts ordered since 3.7 — HashMap isn't. None vs checked exceptions. | | Java → Python | int overflow at 2³¹ → Python never overflows. == on objects is identity, not equality. Checked exceptions disappear. | | C++ → Rust | UB becomes panic or won't compile. Raw pointers need lifetime decisions. Move semantics are default, not opt-in. Implicit conversions gone. | | JS → TypeScript | Mostly additive (types) — but == coercion stays, strictNullChecks changes nullability. | | Python → Go | Exceptions → explicit error returns. Duck typing → interfaces. No default args. **kwargs has no equivalent. | | C → Go | Manual memory → GC. Pointer arithmetic gone. goto cleanup → defer. No unions. |

Before translating, write down the three semantic mismatches that matter for this function. Check them in the output.

Idiom mapping — common patterns

| Pattern (Python) | Java | Go | Rust | | ----------------------------------- | ---------------------------------------- | ------------------------------------ | ------------------------------------- | | [f(x) for x in xs] | xs.stream().map(f).toList() | for-append loop | xs.iter().map(f).collect() | | {k: v for k, v in ...} | Collectors.toMap(...) | make + loop | HashMap::from_iter(...) | | try/except for control flow | Anti-pattern — check first | if err != nil | Result<T, E> / ? | | with open(...) as f: | try-with-resources | defer f.Close() | Drop (automatic) | | *args, **kwargs | Overloads or a params object | variadic (...T) — no kwargs | No direct — builder or options struct | | Multiple return values | Record/Pair (awkward) | Native — (T, error) | Tuple or struct |

Worked example

Python:

def top_k(items, k, key=lambda x: x):
    """Return the k largest items by key."""
    if k <= 0:
        return []
    if k >= len(items):
        return sorted(items, key=key, reverse=True)
    import heapq
    return heapq.nlargest(k, items, key=key)

Go translation:

import "sort"

// TopK returns the k largest items by the given key function.
// If k <= 0, returns an empty slice. If k >= len(items), returns all items sorted descending.
func TopK[T any](items []T, k int, key func(T) int) []T {
    if k <= 0 {
        return nil
    }
    // Go has no heapq.nlargest — full sort then slice.
    // (O(n log n) vs Python's O(n log k). Acceptable unless n is huge and k is small.)
    sorted := make([]T, len(items))
    copy(sorted, items)
    sort.Slice(sorted, func(i, j int) bool {
        return key(sorted[i]) > key(sorted[j])  // descending
    })
    if k >= len(sorted) {
        return sorted
    }
    return sorted[:k]
}

Semantic deltas noted:

• No default arg — caller must pass key explicitly (or make a TopKInt wrapper).
• Complexity: O(n log n) vs Python's O(n log k). For large n / small k, consider container/heap. Flagged, not fixed — premature optimization.
• nil vs [] — both are zero-length in Go, but nil is more idiomatic for "empty result."
• Copies input (Python's heapq.nlargest doesn't mutate either). Matches.

Verify the translation

After translating, → behavior-preservation-checker or → multi-version-behavior-comparator: run both versions on the same inputs, diff outputs. Pay attention to edge cases — empty input, k=0, k=len, duplicate keys.

Do not

• Do not transliterate control flow when the target has a better idiom. for i in range(len(xs)): f(xs[i]) → don't index in Go/Rust, use for _, x := range xs.
• Do not silently swallow error-handling differences. If the source throws and the target returns errors, every call site changes.
• Do not assume library parity. Python's heapq.nlargest has no exact Go equivalent — note the complexity tradeoff.
• Do not change mutability behavior. If the source doesn't mutate inputs, neither should the translation. Copy if you have to.
• Do not translate into deprecated/unsafe target idioms. Python str.format → Java String.format, not concatenation. No strcpy in C targets.

Output format

## Target
<language + version>

## Translation
<code block>

## Semantic deltas
- <what behaves differently, and why it's acceptable or flagged>

## Idiom choices
- <non-obvious mappings — why this Go/Rust/Java pattern and not the literal one>

## Verify with
<example inputs to diff against the source — especially the edge cases>