Port a code snippet to another language idiomatically

Translating code between languages is easy to do badly: a literal transliteration that compiles but isn't idiomatic, or that quietly changes behavior because the two languages disagree on integer division, null handling, or string immutability. This prompt asks for an idiomatic port—using the target language's standard library, naming conventions, and error-handling style—while preserving exact behavior including edge cases. The most useful output is the list of behavioral differences to verify: the model flags exactly where the languages diverge (e.g. Python's arbitrary-precision ints vs. Java's overflow, or JavaScript's truthiness vs. Go's explicit nil checks) so you know what to test. Specify both languages and the target version/runtime, since idioms shift across versions. This is great for migrating utilities, sharing logic across a polyglot codebase, or learning a new language by example. Always compile and test the result—an idiomatic-looking port can still hide a subtle semantic gap that only a test will catch.

What you can expect back

```go
// Average returns the mean of nums, or 0 for an empty slice.
func Average(nums []float64) float64 {
    if len(nums) == 0 {
        return 0
    }
    var sum float64
    for _, n := range nums {
        sum += n
    }
    return sum / float64(len(nums))
}
```

Behavioral differences to verify:
- Division: Python's `/` is always float division; in Go I used `float64` to match. If your inputs are ints, the Go version would need an explicit conversion or it would do integer division.
- Empty input: both return 0, but Python returns int `0` while Go returns `float64(0)`—type matters for callers.
- Overflow: Go's float64 can lose precision on very large sums where Python ints are exact; test with large datasets if precision is critical.

Illustrative example — your results will vary by tool and inputs.

Get sharper results

• 01Always state [TARGET_VERSION]—async/await, pattern matching, and stdlib APIs vary across versions.
• 02Compile and run the port; idiomatic-looking code can still hide a semantic gap.
• 03Pay special attention to flagged integer-division and null-handling differences—those cause the subtlest bugs.
• 04For larger migrations, port one function at a time and keep the difference notes as a test checklist.

Adapt it for your case