Traits, Generics, impl Trait & dyn Trait

trait Summarize {
    fn summary(&self) -> String;
}

struct Article {
    title: String,
}

impl Summarize for Article {
    fn summary(&self) -> String {
        self.title.clone()
    }
}

fn notify(item: &impl Summarize) {
    println!("{}", item.summary());
}

interface Summarize {
  summary(): string;
}
class Article implements Summarize {
  constructor(public title: string) {}
  summary() {
    return this.title;
  }
}
function notify(item: Summarize) {
  console.log(item.summary());
}

from typing import Protocol

class Summarize(Protocol):
    def summary(self) -> str: ...

class Article:
    def __init__(self, title: str) -> None:
        self.title = title

    def summary(self) -> str:
        return self.title

def notify(item: Summarize) -> None:
    print(item.summary())

fn static_sum() -> impl Summarize {
    Article { title: "static".into() }
}

fn dyn_sum() -> Box<dyn Summarize> {
    Box::new(Article { title: "dyn".into() })
}

function make(): Summarize {
  return new Article("dyn");
}
const many: Summarize[] = [new Article("a"), new Article("b")];

def make() -> Summarize:
    return Article("dyn")

many: list[Summarize] = [Article("a"), Article("b")]

fn takes_string(s: impl Into<String>) {
    let owned: String = s.into();
    println!("{owned}");
}

function takesString(s: string) {
  console.log(s);
}

def takes_string(s: str) -> None:
    print(s)