Python → U — Comprehensive Comparison

# no annotation — type inferred
name = "Alice"
count = 0
ratio = 3.14

# optional type hints (not enforced)
name: str = "Alice"
items: list[int] = []

// type inferred at declaration
name = "Alice"
count = 0
ratio = 3.14

// explicit annotation (compiler enforces)
name: S = "Alice"
items: [I] = []

# everything mutable by default
x = 5
x = 10  # fine

# immutable requires effort
from typing import Final
X: Final = 5
X = 10  # mypy error, not runtime

// immutable by default (-M)
x: I = 5
x = 10  // compile error: -M

// opt into mutability
x: I +M = 5
x = 10  // fine: +M declared

def add(a: int, b: int) -> int:
    return a + b

def greet(name: str) -> str:
    return f"Hello, {name}"

f add(a: I, b: I) -> I
    r => a + b

f greet(name: S) -> S
    r => "Hello, " + name

def connect(host: str, port: int = 5432) -> Connection:
    ...

f connect(host: S, port: I = 5432) -> Connection
    ...

def minmax(data: list[float]) -> tuple[float, float]:
    return min(data), max(data)

lo, hi = minmax([1, 5, 3])

f minmax(data: [N]) -> {lo: N, hi: N}
    r => { lo: data.min(), hi: data.max() }

result = minmax([1.0, 5.0, 3.0])
result.lo  // 1.0

# no direct equivalent
# closest: dataclasses, __init_subclass__,
# or metaclasses at class-creation time

// c f runs at compile time
c f validate_schema(schema: S) -> L
    r => schema.len() > 0

class Point:
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y

    def dist_sq(self) -> float:
        return self.x**2 + self.y**2

d Point
    x: N +M
    y: N +M

    f dist_sq() -> N
        r => x*x + y*y

class Shape:
    def area(self) -> float:
        return 0.0

class Circle(Shape):
    def __init__(self, r: float):
        self.r = r
    def area(self) -> float:
        return 3.14159 * self.r ** 2

d Shape
    f area() -> N
        r => 0.0

d Circle : Shape
    r: N +M
    f area() -> N
        r => 3.14159 * r * r

from dataclasses import dataclass, field

@dataclass
class Config:
    host: str = "localhost"
    port: int = 5432
    tags: list = field(default_factory=list)

d Config
    host: S  +M = "localhost"
    port: I  +M = 5432
    tags: [S] = []  // array is +R+M(MVCC) by default

class Vector:
    def __init__(self, x, y): ...
    def __add__(self, other):
        return Vector(self.x+other.x, self.y+other.y)
    def __str__(self):
        return f"({self.x}, {self.y})"
    def __len__(self): return 2
    def __eq__(self, other): ...

d Vector
    x: N +M
    y: N +M
    f __add__(other: Vector) -> Vector
        r => Vector(x+other.x, y+other.y)
    f __string__() -> S
        r => "(" + x + ", " + y + ")"
    f __len__() -> I => 2

items = [1, 2, 3]
items.append(4)
items.extend([5, 6])
items.pop()        # removes last
items.pop(0)      # removes first
items.insert(1, 99)
items.remove(3)   # remove by value
len(items)

items: [I] = [1, 2, 3]  // [I] is +R+M(MVCC) by default
items.append(4)
items.extend([5, 6])
items.pop()        // removes last
items.pop(1)      // removes by index
items.insert(2, 99)
items.delete(3)   // remove by value
items.len          // property, no parens

items[1:3]      # indices 1,2
items[:3]       # first 3
items[2:]       # from index 2
items[::2]      # every other
items[::-1]     # reversed

items[1..3]     // inclusive [1,2,3]
items[1...3]    // exclusive [1,2]
items.first(3)  // first 3
items.skip(2)   // from index 2
items.step(2)   // every other
items.reverse()  // reversed copy

3 in items          # True
items.index(3)     # first position
items.count(3)     # occurrences
any(x > 2 for x in items)
all(x > 0 for x in items)

3 in items           // true
items.index(3)      // first position
items.count(3)      // occurrences
items.any(x => x > 2)
items.all(x => x > 0)

items.sort()                    # in-place
items.sort(key=lambda x: -x)  # custom
sorted(items)                   # new list
items.reverse()                 # in-place
list(map(lambda x: x*2, items))
list(filter(lambda x: x>2, items))

items.sort()                    // in-place
items.sort(x => -x)             // custom key
items.sorted()                  // new array
items.reverse()                 // in-place
items.x(x => x*2)              // map
items.x(x => x>2 ? x ! none)   // filter

d = {"a": 1, "b": 2}
d["c"] = 3
d.get("x", 0)   # 0 if missing
"a" in d
del d["a"]
len(d)
d.keys(); d.values(); d.items()

d: {S: I} = {"a": 1, "b": 2}  // {K:V} is +R+M(MVCC) by default
d["c"] = 3
d.get("x", 0)   // 0 if missing
"a" in d
d.delete("a")
d.len
d.keys(); d.values(); d.items()

from collections import defaultdict

groups = defaultdict(list)
groups["eng"].append(user)

# nested — must use lambda:
freq = defaultdict(lambda: defaultdict(int))
freq[doc][word] += 1

groups: {S: [User] !}  // +R+M(MVCC) implicit
groups["eng"].append(user)

// nested — ! composes, no lambda trap:
freq: {S: {S: I !} !}
freq[doc][word] += 1

merged = {**d1, **d2}   # 3.5+
merged = d1 | d2        # 3.9+
d1.update(d2)

merged = d1 | d2        // union
d1 << d2               // patch (MVCC-aware)

s = {1, 2, 3}
s.add(4)
s.discard(2)
3 in s
s | t   # union
s & t   # intersection
s - t   # difference
len(s)

s: {I} = {1, 2, 3}  // {T} set is +R+M(MVCC) by default
s.insert(4)      // returns L (had effect?)
s.delete(2)      // returns L
3 in s
s | t    // union
s & t    // intersection
s - t    // difference
s.len

s = "hello world"
s.upper()           # "HELLO WORLD"
s.lower()           # "hello world"
s.strip()           # trim both ends
s.lstrip()          # trim left
s.rstrip()          # trim right
s.split(" ")        # ["hello","world"]
s.replace("hello","hi")
s.startswith("hel")
s.endswith("rld")
s.find("wor")       # index or -1
" ".join(["a","b"])  # "a b"
len(s)

s: S = "hello world"
s.upper()           // "HELLO WORLD"
s.lower()           // "hello world"
s.strip()           // trim both ends
s.lstrip()          // trim left
s.rstrip()          // trim right
s.split(" ")        // ["hello","world"]
s.replace("hello","hi")
s.startswith("hel")
s.endswith("rld")
s.find("wor")       // index or none
["a","b"].join(" ") // "a b"
s.len

name, age = "Alice", 30
f"Hello {name}, age {age}"
"Hello {}, age {}".format(name, age)

name: S = "Alice"; age: I = 30
"Hello {name}, age {age}"  // interpolation

# no typed template literals
# raw f-strings go to sql/html unsafely:
query = f"SELECT * FROM users WHERE id={uid}"
# ^ SQL injection risk — no compile check

// typed — returns SQL, not S
query = sql`SELECT * FROM users WHERE id={uid}`
page  = html`<h1>{title}</h1>`

// passing S where SQL expected → compile error
// {uid} is parameterised, never concatenated

# if/elif/else
if x > 0:
    sign = "positive"
elif x < 0:
    sign = "negative"
else:
    sign = "zero"

# ternary
label = "yes" if flag else "no"

// chained ?! (no if/elif/else keywords)
sign = x > 0 ? "positive"
     ! x < 0 ? "negative"
     !          "zero"

// ternary
label = flag ? "yes" ! "no"

name = user.name if user else "anon"

# walrus operator
if (n := get_name()) is not None:
    print(n)

name = user ?? "anon"     // null coalesce

n = get_name()
n != none & process(n)    // guard: short-circuit

for x in items:
    print(x)

for i, x in enumerate(items):
    print(i, x)

for i in range(1, 6):     # 1..5
    ...

while condition:
    ...

items.x(x => process(x))

items.x((i, x) => process(i, x))  // with index

[1..5].x(i => ...)     // inclusive range

// while: use recursion or generator
// no while keyword — use .x() or +W

for a, b in zip(xs, ys):
    ...

for i, x in enumerate(items, start=1):
    ...

xs.zip(ys).x((a, b) => ...)

items.x((i, x) => ...)  // 1-based by default

# list comprehension
squares = [x**2 for x in items]

# with filter
evens = [x for x in items if x % 2 == 0]

# dict comprehension
d = {k: v*2 for k, v in pairs}

# set comprehension
s = {x % 10 for x in items}

// map via .x()
squares = items.x(x => x*x)

// filter+map (none values dropped)
evens = items.x(x => x % 2 == 0 ? x ! none)

// dict from pairs
d = pairs.x((k,v) => {k: v*2}).merge()

// set
s = items.x(x => x % 10).toSet()

# lambda (expression only)
double = lambda x: x * 2

# multi-param
add = lambda a, b: a + b

# closure over outer variable
def make_adder(n):
    return lambda x: x + n

plus5 = make_adder(5)
plus5(10)  # 15

// => arrow (expression or block)
double: I+F = x => x * 2

// multi-param
add: I+F = (a, b) => a + b

// closure (captures by reference)
f make_adder(n: I) -> (I)->I
    r => x => x + n

plus5 = make_adder(5)
plus5(10)  // 15

class NetworkError(Exception): ...

def fetch(url: str) -> str:
    try:
        return http.get(url)
    except NetworkError as err:
        log(err)
        raise
    finally:
        cleanup()

d NetworkError : Error
    msg: S

f fetch(url: S) -> S ! NetworkError
    result = http.get(url) ! err =>
        log(err)
        e NetworkError(err.msg)
    r => result

def count_up(n: int):
    i = 0
    while i < n:
        yield i
        i += 1

for x in count_up(5):
    print(x)

f count_up(n: I) -> I +W
    [0..n].x(i =>
        w i)

count_up(5).x(x => process(x))

import asyncio

async def fetch(url: str) -> str:
    return await http.get(url)

async def main():
    result = await fetch("https://...")

# must be called with asyncio.run()
asyncio.run(main())

a f fetch(url: S) -> S
    r => a http.get(url)

// call with a prefix or block inline
result = a fetch("https://...")
// or: result: S+A = a fetch(...)  ← pending type

import asyncio

# gather runs coroutines in parallel
results = await asyncio.gather(
    fetch(url1), fetch(url2), fetch(url3)
)

// +A values are pending — run in parallel
pending: [S +A] = [
    a fetch(url1),
    a fetch(url2),
    a fetch(url3)
]
results: [S] = pending.all()

import asyncio
cache = {}
lock = asyncio.Lock()

async def update(key, val):
    async with lock:
        cache[key] = val  # manual lock

cache: {S: S} = {:}  // +M(MVCC) is already the default

a f update(key: S, val: S) -> none
    cache[key] = val  // MVCC handles concurrency

import json
from pathlib import Path
from typing import Optional

# relative import
from .utils import helper

o Json
o Fs { Path }
o Network { HTTP, WebSocket }

// capability grant at import time
o Database { Query } // grants DB capability

# None can appear anywhere
def get_user(id: int) -> Optional[User]:
    ...

user = get_user(42)
user.name  # AttributeError if None — runtime!

# must check manually
if user is not None:
    print(user.name)

// +N marks nullable — -N is default
f get_user(id: I) -> User +N
    ...

user = get_user(42)
user.name  // compile error: user is +N

// must narrow first
user != none & process(user.name)
// or: user?.name  (optional chain)
// or: user ?? default_user

# structural (duck typing)
def process(x):  # any type
    x.quack()   # fails at runtime if no .quack

# type hints (not enforced)
def add(a: int, b: int) -> int: ...

# Protocol for structural typing
from typing import Protocol
class Drawable(Protocol):
    def draw(self): ...

// nominal + structural, fully enforced
f process(x: Drawable) -> none
    x.draw()  // compile error if Drawable not met

// interface declaration
d Drawable
    f draw() -> none

// no any, no object, no escape hatch

# everything on heap, GC manages
x = 5          # heap int object
items = []     # heap list
# no control over allocation
# GC pauses unpredictable
import sys
sys.getrefcount(x)  # manual inspection only

// -R (default): stack, no alloc cost
x: I = 5

// +R: heap, ARC (no GC pauses)
config: Config +R = Config()

// +R -M: shared immutable (free to alias)
data: Data +R -M = load()

// explicit copy when needed
local = heap_val.c()

class Foo:
    def public_method(self): ...
    def _private(self): ...    # convention only
    def __mangled(self): ...   # name-mangled

# nothing is truly enforced at runtime
obj._private()  # works fine — just a warning

d Foo
    f public_method() -> none ...
    f _private() -> none ...   // enforced

// outside callers get compile error:
foo._private()  // ERROR: _private is module-private

// __method__ = magic/protocol methods only

# {} is empty DICT, not set
d = {}         # dict — OK
s = set()      # set — need set() constructor
s = {}         # WRONG — this is a dict!

# checking which one you have:
type({})       # <class 'dict'>
type(set())   # <class 'set'>

# non-empty: same literal syntax
d = {"a": 1}   # dict ← colon signals map
s = {1, 2}    # set

// {} = empty SET (consistent with {1, 2})
s = {}         // set — unambiguous

// {:} = empty MAP (: always signals map)
d = {:}      // map — unambiguous

// checking: the type is in the declaration
s: {I}         // set of I
d: {S: I}     // map S→I

// non-empty: same rule
d = {"a": 1}   // map ← colon signals map
s = {1, 2}    // set

# join: sep.join(iterable)
" ".join(["a", "b", "c"])   # "a b c"

# split: str.split(sep)
"a b c".split(" ")         # ["a","b","c"]
"a b c".split()            # split on whitespace

// JS-style (array method)
["a", "b", "c"].join(" ")  // "a b c"

// Python-style (string method) — also valid
" ".join(["a", "b", "c"]) // "a b c"

// split — string method, same as Python
"a b c".split(" ")         // ["a","b","c"]
"a b c".split()            // split on whitespace

# ( continues across lines
result = (
    first_value
    + second_value
    + third_value
)

query = (
    "SELECT * FROM users "
    "WHERE active = true "
    "ORDER BY name"
)

// ( continues across lines — same rule
result = (
    first_value
    + second_value
    + third_value
)

query = sql`
    SELECT * FROM users
    WHERE active = true
    ORDER BY name
`(args)