(🎁) Flag to make default return type `None` instead of `Any`

[KotlinIsland]

🚀 Feature

Most other languages(Kotlin, Rust, Swift etc) have a void(or equivalent) return type by default. Can an option be added to have an implicit None return type.

def foo():  # implicit None
  print("hi")

🆕 Update

Basedmypy 1.3 supports this functionality with the --default-return flag.

[gvanrossum]

Already exists: ‘ --check-untyped-defs’.

[KotlinIsland]

@gvanrossum I don't think you understand my feature request, in Kotlin

fun foo() {
    return
}

is a valid function, that returns an implicit Unit(essentially Void) and is fully typed.

Swift and Rust(and others I assume) also have this feature and I think it's a good one.

The --check-untyped-defs flag isn't what I'm asking for.

Thanks for the quick response.

[KotlinIsland]

Go also supports this.

[KotlinIsland]

Currently returns Any

def foo():
  return

[gvanrossum]

Whoops.

[JukkaL]

I think that this could be a useful feature, but perhaps only when --check-untyped-defs or --disallow-untyped-defs is enabled, as otherwise def foo(): would be ambiguous -- it's unclear if we should type check the body.

There is a problem when using --check-untyped-defs, as we should only give def foo(): an implicit None return type if there is no return statement with an explicit value in the body. This would be a bit dangerous however, as any return statement with a value would turn the return type into Any. So maybe this should only be allowed with --disallow-untyped-defs?

Unit tests, in particular, could benefit from this, since there tend to be a lot of functions like def test_foo(...) -> None.

Additionally, maybe an explicit None return type should be an error in this mode, as otherwise it could look confusing (or at least inconsistent). We could give this error a dedicated error code so that it would be possible to disable the message, however.

[KotlinIsland]

Maybe name the flag --default-none-return and if enabled then def foo(): would then be considered a typed def and should be checked regardless of whether --check-untyped-defs is selected.

I would think an explicit none return type in this mode should be a warning.

[eternal-sorrow]

I think that this could be a useful feature, but perhaps only when --check-untyped-defs or --disallow-untyped-defs

Or it would rather be an alternative to these 2 options.

This would be a bit dangerous however, as any return statement with a value would turn the return type into Any.

This case should be considered an error.

[gvanrossum]

I feel this feature request is misguided. It creates an incompatible variant language. Just write ‘-> None’ already!

[eternal-sorrow]

Just write ‘-> None’ already!

I don't know. Maybe I'm just too spoiled by the fact that return None, return and implicit return do exactly the same thing, but it feels just wrong to add -> None to a function that doesn't actually have a return None statement. For me it feels natural that functions that don't have a return type annotation should be considered as retuning None, because that's what happens if a function doesn't have a return statement.