Python ↔ Java

# Python 3.8+ warns on `is` against an int/str literal, since it's almost always a mistake.
# We're deliberately doing it on purpose here to demonstrate identity semantics, so silence that warning.
import warnings
warnings.filterwarnings("ignore", category=SyntaxWarning)

a = 256
b = 256
print("256 is 256:", a is b, "|", a == b)

e = -5
f = -5
print("-5 is -5: ", e is f, "  <- both in the cached range, always True, script or notebook")

String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");

System.out.println("s1 == s2 (both literals, pooled):      " + (s1 == s2));
System.out.println("s1 == s3 (s3 is `new String(...)`):    " + (s1 == s3));
System.out.println("s1.equals(s3):                         " + s1.equals(s3));
System.out.println("s1 == s3.intern():                     " + (s1 == s3.intern()));

d = {"a": 1, "b": 2}
try:
    for k in d:
        d["c"] = 3   # adds a NEW key -> changes size
except RuntimeError as e:
    print("RuntimeError:", e)

print()
d2 = {"a": 1, "b": 2}
for k in d2:
    d2[k] = d2[k] * 10   # only changes an EXISTING key's value -> size unchanged, totally fine
print("mutated values in place:", d2)

print()
s = {1, 2, 3}
try:
    for x in s:
        s.add(4)
except RuntimeError as e:
    print("RuntimeError (set):", e)

import java.util.*;

System.out.println("case A: [1,2,3], remove value 2 (second-to-last) mid for-each");
List<Integer> a = new ArrayList<>(List.of(1, 2, 3));
try {
    for (Integer v : a) { if (v == 2) a.remove(v); }
    System.out.println("  NO exception thrown. list silently ends up = " + a + "  <-- the trap");
} catch (ConcurrentModificationException e) {
    System.out.println("  CME: " + e);
}

System.out.println("case B: [1,2,3,4], remove value 2 (NOT second-to-last)");
List<Integer> b = new ArrayList<>(List.of(1, 2, 3, 4));
try {
    for (Integer v : b) { if (v == 2) b.remove(v); }
    System.out.println("  no exception. list now = " + b);
} catch (ConcurrentModificationException e) {
    System.out.println("  CME: " + e);
}

def countdown(n):
    print(f"  (starting countdown from {n})")
    while n > 0:
        yield n
        n -= 1
    print("  (countdown done)")

gen = countdown(3)
print("generator created, body has NOT run yet:", gen)
print("first next():", next(gen))
print("second next():", next(gen))
print("third next():", next(gen))
try:
    next(gen)
except StopIteration:
    print("StopIteration once exhausted")

import java.util.*;
import java.util.stream.*;

List<Integer> src = List.of(1, 2, 3, 4, 5);

var stream = src.stream()
        .peek(x -> System.out.println("  peek saw " + x))
        .filter(x -> x > 2);

System.out.println("stream pipeline built -- nothing printed above, because nothing has RUN yet");

Optional<Integer> first = stream.findFirst();   // terminal op, short-circuits after the first match
System.out.println("first element > 2: " + first + "  <- only elements 1..3 were ever peeked at, not all 5");

class Bad:
    def __init__(self, v):
        self.v = v
    def __eq__(self, other):
        return isinstance(other, Bad) and self.v == other.v
    # no __hash__ override

b = Bad(1)
try:
    hash(b)
except TypeError as e:
    print("hash() on an eq-only class:", e)
print("Bad.__hash__ is:", Bad.__hash__)

try:
    {b}
except TypeError as e:
    print("can't even put it in a set:", e)

import java.util.*;

class Bad {
    int v;
    Bad(int v) { this.v = v; }
    @Override public boolean equals(Object o) { return o instanceof Bad b && b.v == v; }
    // no hashCode() override -> falls back to identity hash, contract broken
}

Set<Bad> set = new HashSet<>();
Bad b1 = new Bad(5);
set.add(b1);

System.out.println("contains(new Bad(5)) [equal by value]: " + set.contains(new Bad(5)));
System.out.println("contains(b1) [same reference]:         " + set.contains(b1));

class Resource:
    def __enter__(self):
        print("  acquiring")
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"  releasing (exception type seen: {exc_type})")
        return False   # don't suppress

with Resource() as r:
    print("  using")

try:
    with Resource() as r:
        raise ValueError("boom")
except ValueError:
    print("exception still propagated after __exit__ ran")

class NoisyResource implements AutoCloseable {
    String name;
    NoisyResource(String name) { this.name = name; System.out.println("  open " + name); }
    public void close() { System.out.println("  close " + name); }
}

try (var a = new NoisyResource("A"); var b = new NoisyResource("B")) {
    System.out.println("  using both");
}
// note the close order below: B, then A -- reverse of declaration order

from dataclasses import dataclass, field

@dataclass
class Bucket:
    items: list = field(default_factory=list)

b1 = Bucket()
b2 = Bucket()
b1.items.append(1)
print("independent lists, not shared:", b1.items, b2.items)

record Point(int x, int y) {}

Point p1 = new Point(1, 2);
Point p2 = new Point(1, 2);

System.out.println("p1.equals(p2) [value equality]: " + p1.equals(p2));
System.out.println("p1 == p2 [reference identity]:  " + (p1 == p2));
System.out.println("toString():                     " + p1);
System.out.println("accessor (not getX()):           " + p1.x() + "," + p1.y());

def describe(x):
    match x:
        case 0:
            return "zero"
        case int() | float() if x < 0:
            return "negative number"
        case [a, b]:
            return f"pair: {a}, {b}"
        case [a, *rest]:
            return f"list starting with {a}, {len(rest)} more"
        case {"type": "point", "x": px, "y": py}:
            return f"point dict at {px},{py}"
        case str():
            return "a string"
        case _:
            return "something else"

for val in [0, -5, [1, 2], [1, 2, 3, 4], {"type": "point", "x": 1, "y": 2}, "hi", 3.5]:
    print(f"{val!r:34} -> {describe(val)}")

class Shapes {
    sealed interface Shape permits Circle, Square, Rectangle {}
    record Circle(double radius) implements Shape {}
    record Square(double side) implements Shape {}
    record Rectangle(double w, double h) implements Shape {}

    static double area(Shape s) {
        return switch (s) {
            case Circle c -> Math.PI * c.radius() * c.radius();
            case Square sq -> sq.side() * sq.side();
            case Rectangle r -> r.w() * r.h();
            // no default -- the compiler knows Circle/Square/Rectangle are the ONLY permitted shapes
        };
    }
}

for (Shapes.Shape shape : List.of(new Shapes.Circle(2), new Shapes.Square(3), new Shapes.Rectangle(2, 5))) {
    System.out.printf("%s area = %.2f%n", shape.getClass().getSimpleName(), Shapes.area(shape));
}