A Failed Experiment with Python Type Annotations

Post by neuland » Wed, Jun 12, 2019, 2:24 AM UTC

rcfox wrote: post #30

lozenge wrote: post #28

Earlier quoted context omitted.

It looks like the constructor is being typechecked, but probably not attribute access. `val.child.junk` will pass because `val.child` is `Any` and you can do any-thing to an Any.

That seems to work too.. a = Foo(Foo(Foo(None))) b = Bar(Bar(Bar(None))) c = Hep(Hep(Hep(None))) a.child.junk = 1 # error: Item "Foo" of "Optional[Foo]" has no attribute "junk" # error: Item "None" of "Optional[Foo]" has no attribute "junk" b.child.junk = 'a' # error: Item "Bar" of "Optional[Bar]" has no attribute "junk" # error: Item "None" of "Optional[Bar]" has no attribute "junk" c.child.junk = 1.1 # error: Item…

    class Node:
        child: 'Node'

    class NodeBase(type):
        def __new__(cls, name, bases, attrs):
            return super().__new__(cls, name, bases, attrs)


    class Node(metaclass=NodeBase):
        child: 'Node'  # works

Post by zapzupnz » Wed, Jun 12, 2019, 3:04 AM UTC

pacala wrote: post #26

ggregoire wrote: post #5

Why would you keep Python if you want static typing? I mean, there are several modern, performant (more than Python actually) statically typed languages. Rust, Go, Kotlin, Scala, Swift… All of them are mature and have a good library ecosystem. So, except if you need some math/AI/ML packages available only for Python, why bother? Choose the right tool for the job, no?

Scala: Python + dataclasses [+ mypy] offers a programming experience close to pragmatic Scala. The tradeoff becomes: * worse performance * lack of immutable vectors, alleviated via style conventions * rarely, awkward lambdas vs. * wide pool of people familiar with the language * lack of JVM lockin: Scala native is not there yet, the library ecosystem is all JVM. * [good] batteries included * much better reflection *…

Post by adrianratnapala » Wed, Jun 12, 2019, 3:15 AM UTC

jimmaswell wrote: post #43

What's possibly so cumbersome about defining return types? It does seem a little embarrassing that the annotations don't even support circular references.

Post by pacala » Wed, Jun 12, 2019, 3:41 AM UTC

zapzupnz wrote: post #44

pacala wrote: post #26

Earlier quoted context omitted.

Scala: Python + dataclasses [+ mypy] offers a programming experience close to pragmatic Scala. The tradeoff becomes: * worse performance * lack of immutable vectors, alleviated via style conventions * rarely, awkward lambdas vs. * wide pool of people familiar with the language * lack of JVM lockin: Scala native is not there yet, the library ecosystem is all JVM. * [good] batteries included * much better reflection *…

> Swift: Apple lock-in. Swift runs on Linux and has done since it was made open source in 2015, a year after its initial announcement. Windows support is being worked on but, for the time being, it runs fine in WSL. No lock in.

Post by dragonwriter » Wed, Jun 12, 2019, 3:44 AM UTC

klodolph wrote: post #33

dragonwriter wrote: post #12

Earlier quoted context omitted.

> But you should still annotate your public apis. The good thing about inference (especially with a REPL) is you can write it without the annotation, and then use the inferred type (in Haskell, I usually find that when I resist the temptation to explicitly annotate types, the actual types are more general than I would have specified.)

In Haskell, I usually find the quality of error messages to be much worse without top-level annotations.