Traits: Why the need for brackets, why not allow the trait to be the 'type' of an argument?

[ixig]

The biggest difference between Java and Python is how verbose Java is compared to Python -- as such I find fn make_it_quack[T: Quackable](implements_quack: T): to be extremely unwieldy and unnecessarily verbose. Why can't the compiler accept fn make_it_quack(implements_quack: Quackable): instead? It can see that Quackable is defined as a trait, so there's no confusion over whether it's a trait or a struct.

And fn factory[T: MassProducible]() -> T: can be fn factory() -> MassProducible:.

Similarly for the case of calling static functions on traits, i.e. fn fun_with_traits[T: HasStaticMethod](): T.do_stuff() -- why not just fn fun_with_traits(): HasStaticMethod.do_stuff() ?

[Brian-M-J]

Mojo uses this syntax because, since 3.12, Python does. Mojo aims to be a strict superset of Python, so it has to add these features.

As for why Python decided to use this syntax, I'm not very knowledgeable about type theory and how it interacts with programming language syntax, so I don't know. You'll have to ask people who do know. It seems that this verbose syntax is inescapable since even modern languages like Rust use it, though it provides some syntax sugar. For example:

pub fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

...desugars to:

pub fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}