Python is a simple language to understand, but to me functions are a special case. And according to the Zen of Python (PEP20 https://www.python.org/dev/peps/pep-0020/): `Special cases aren't special enough to break the rules.`. For beginners, Python functions can cause some pain that boils down to three points that shows some lack of standardization. 1. Function declaration needs keyword `def`: If you are a long time Python (1991) developer, you surely got used to the keyword `def` to declare a function, same goes if you are a Ruby (1995) programmer. In Fortran (1957) you start them with the word `function` and in Perl (1987) you use the word `sub`. In C-family languages C (1972), C++ (1985), C# (2000), also in Java (1995) you don't need any word to declare it: return_type function_name(args) In languages from the last decade you have Rust (2010) with the keyword `fn`, Kotlin with `fun`. Dart (2011) follows C-family style and Julia (2012) offers two ways of defining a named function: using the word `function` or the compact version with no keyword `f(x,y) = x + y`. Following PEP20 https://www.python.org/dev/peps/pep-0020/ aphorism of `Simple is better than complex.` I would say no word like C-family is simpler. But there is also `Explicit is better than implicit.`. I would choose `fun` or even `fn` since they at least resemble the word function. Eg:

...

...

def x(args):

... pass would turn into:

...

...

fun x(args):

... pass Resemblance of function leads me to my next point. 2. Class name Again, functions are an exception.

...

...

x = 1

...

...

type(x)

*# not integer*

...

...

x = {"a": 1}

...

...

type(x)

*# not dictionary*

...

...

def x(args):

... pass ...

...

...

type(x)

*# not fun =(* 3. Type hinting This is when the syntax gets trickier. With PEP 585 https://www.python.org/dev/peps/pep-0585/ you don't have to do:

...

...

from typing import Dict, List, Set

to have:

...

...

def x(foo: dict[string, int], bar: list[float]) -> None:

... pass But if you have a function as a parameter, your only option is to use Callable. It breaks the rule again having a totally different syntax:

...

...

from typing import Callable

...

...

def x(method: Callable[[int, dict], None]) -> None:

... pass So you have `def`, `function`, `Callable` and also this [[args], return] syntax, also different from the rest of type hinting syntax. I would add a `fun` type without the need of an import. Also Callable syntax could also be simplified with the -> operator into something like:

...

...

def x(method: fun[int, dict] -> None) -> None:

... pass === Preliminary Proposal === With the same goal of removing the pain and making life of Python teachers easier (PEP 585 https://www.python.org/dev/peps/pep-0585/), I would change this:

...

...

from typing import Callable

...

...

def x(method: Callable[[int, dict], None]) -> None:

... pass ...

...

...

type(x)

Into something like this:

...

...

fun x(method: fun[int, dict] -> None) -> None:

... pass ...

...

...

type(x)

In order to make this possible the following changes would be needed: 1. adding `fun` keyword to method definition (maintaining `def` for backwards compatibility); 2. adding `fun` built-in type in addition to Callable; 3. supporting `->` as return syntax for type hinting. Isn't it much more `fun` to learn the language this way? Kind regards, Thiago Carvalho D'Ávila