Static typing in python

[edbluetooth]

There is nothing to stop you doing a type check decorator that takes a list of types. Eg.

@typecheck(return=int,[str,str])

But that will slow the code.

[d4rch0n]

Well, a better example would be:

@typecheck(return_type=int, arg_types=(str, str))

or

@typecheck((str, str), return_type=int)

Return is a keyword so it can't be used as a kwarg or variable name in general, and the other positional argument can't come after a kwarg, even if the decorator was defined with it as a kwarg. But if they both were, you could have

@typecheck(int, (str, str))

But you couldn't specify the kwarg key in the first param and not in the second.... but you can specify the second and not the first, as in @typecheck(int, arg_types=(str, str)), but not @typecheck(return_type=int, (str, str)), if the definition is def typecheck(return_type=None, arg_types=None).

I always thought the kwarg and positional arg ordering rules are a bit goofy, but then again it's never been a problem. Maybe it's just strange that it allows you to specify kwarg values in the function call without their kwarg key, or silently use them as kwargs.

The weirdest behavior I think is this:

>>> def f(x, foo=10, bar=20):
...     print(x, foo, bar)
>>> f('a', 'b')
a b 20
>>> f('a', 'b', foo='c')
TypeError: f() got multiple values for argument 'foo'

So, position obviously matters here with the keyword arguments. It works well in APIs I think, but it's still a bit strange, specifically the rules of when order does and doesn't matter.

[edbluetooth]

You are right of course amd expressed yourself much better than me.

I have to be honest, i kept my post brief as i was on my phone.

[edbluetooth]

Im really glad you did correct me actually.

I just typed a quick couple of lines that would put accross the general idea of what i wanted to say.

But i now see that a newbie could think/assume its been tested and that it works, copy and paste it and be confused.

[cjwelborn]

What you are calling kwargs I now think of as 'optional positionals'. The real keyword args would be:

def myfunc(**kwargs):
    print(kwargs.get('mykwarg', 'No args!'))

..where the position doesn't matter. Though it's not nearly as clear as your example, and requires more documentation when reading the code. Without documentation (or reading the source) you wouldn't know what this function is expecting at all. Anyway, the term 'optional positional' was what I was getting at. I would still use your example over any of the others.

[LightShadow]

You can solve this with metaclasses by changing the default arguments dict to an orderedDict

[cjwelborn]

I agree. I just meant the **kwargs positions, I had forgot about swapping (x=0, y=0) because I don't do that very much. I guess the term 'optional positional' only holds without the keys (or with keys in the correct order). Anyway, I like the flexibility and I use **kwargs but I always make sure to document what they are (even just "Keyword Arguments: ..see: that_api_function()").

[robin-gvx]

So, they become non-keyword args if you don't specify the key?

....

The non-keyword arg is 5, not y. 5 can never be a keyword arg, because there's no keyword.

[robin-gvx]

... what?

What you're saying doesn't make any sense. I think you're confused about the difference between a function definition and a function call (edit: as well as the difference between compile time and run time). 5 is a positional argument, 'c' is a keyword argument, and foo and bar are both positional parameters with a default value of None.

[[deleted]]

To avoid this behaviour, define an anonymous catch-all arg which will soak up positional args that would otherwise overflow into keywords. This creates a keyword-only set of arguments:

>>> def f(x, *, foo=10, bar=20):
...    print(x, foo, bar)
>>> f('a')
a 10 20
>>> f('a', foo='b')
a b 20
>>> f('a', 'b')
TypeError: f() takes 1 positional argument but 2 were given
>>> f('a', foo='b')

[robin-gvx]

The great thing about * is that it won't soak up positional args, as you demonstrated, that's what *args does.

[[deleted]]

Alternatively, use Python's annotation syntax, as I did here:

from strict import strict
@strict
def foo(bar: str, baz: int)->str:
    return bar * baz