Interfaces, Generics & Type Sets

package geo

import "fmt"

type Stringer interface {
    String() string
}

type Point struct{ X, Y int }

func (p Point) String() string {
    return fmt.Sprintf("(%d,%d)", p.X, p.Y)
}

var _ Stringer = Point{}

interface Stringer {
  toString(): string;
}

class Point implements Stringer {
  constructor(public x: number, public y: number) {}
  toString() {
    return `(${this.x},${this.y})`;
  }
}

from typing import Protocol

class Stringer(Protocol):
    def __str__(self) -> str: ...

class Point:
    def __init__(self, x: int, y: int) -> None:
        self.x, self.y = x, y

    def __str__(self) -> str:
        return f"({self.x},{self.y})"

package gen

type Number interface {
    ~int | ~int64 | ~float64
}

func Sum[T Number](xs []T) T {
    var s T
    for _, v := range xs {
        s += v
    }
    return s
}

func Keys[M ~map[K]V, K comparable, V any](m M) []K {
    out := make([]K, 0, len(m))
    for k := range m {
        out = append(out, k)
    }
    return out
}

function sum(xs: number[]): number {
  return xs.reduce((a, b) => a + b, 0);
}

function keys<K extends string, V>(m: Record<K, V>): K[] {
  return Object.keys(m) as K[];
}

from typing import Iterable, TypeVar

T = TypeVar("T", int, float)

def sum_nums(xs: Iterable[T]) -> T:
    total: T = 0  # type: ignore[assignment]
    for value in xs:
        total = total + value  # type: ignore[operator]
    return total