Type inference woes

CONSIDER this Rust code that a reasonable human being might try to write:

fn add<T>(a: T, b: T) -> T {
return a + b;
}
If you try to compile that, you’ll get an error like this:

:1:25: 1:30 error: binary operation `+` cannot be applied to type `T`
What you actually have to write is something like this:

use std::ops::Add;
fn add<T: Add>(a: T, b: T) -> T::Output {
return a + b;
}
Now it typechecks correctly.

This seems a little ridiculous. The compiler already knew that T had to be a type that supports addition — it just told me that. So why am I spelling it out?

>>44

1.Require no library/header/method import and processing time associated thereof.

Modules do really require any more processing time than a primitive.

2.Are able to be optimized further than library construct, within the compiler.

Can also be done with library functions in the same way.

Secure the existence of libraries...

Prelude comes with GHC dude.

4.Language primitives reduce syntax clutter and boilerplate

No they do not.

you don't need to explicitly import anything

Already the case with Prelude.