Slide with text: “Rust teams at Google are as productive as ones using Go, and more than twice as productive as teams using C++.”
In small print it says the data is collected over 2022 and 2023.
Slide with text: “Rust teams at Google are as productive as ones using Go, and more than twice as productive as teams using C++.”
In small print it says the data is collected over 2022 and 2023.
Without static type annotations you can only make best effort guesses that are sometimes right. Better than nothing but not remotely the same as actual static types. The LSP you linked works best when you use static type annotations.
Also I would really recommend Pylance over that if you can - it’s much better but is also closed source unfortunately.
Why would it just be best effort? To find references for a specific thing, it still would parse an AST, find the current scope, see it’s imported from some module, find other imports of the module, etc.
if random() > 0.5: x = 2 else: x = "hello"Where is the definition of x? What is the type of x? If you can’t identify it, neither can the LSP.
This kind of thing actually happens when implementing interfaces, inheritance, etc. Thus, LSPs in dynamic languages are best effort both theoretically and in practice.
Types are not necessary at all.
Saying “x is defined somewhere in the entire program” isn’t satisfactory to many users. Also, you didn’t tell me what type x has. Can I do
x + 5?It absolutely does. Without static types an IDE/LSP can’t reliably find all the references / definition and therefore can’t refactor reliably either.
Consider something like this:
class Foo: bar: int class Baz: bar: str def a(f: Foo) -> int: return f.bar + 1 def b(f: Baz) -> str: return f.bar + "1"Now imagine you want to rename
Foo.baror find all references to it. Impossible without the type annotations.deleted by creator
Ah, I see. You’re talking about object properties. I don’t see any issue with finding references to variables, but for properties, yeah.
Tbf this example can be deducted as
string | intjust fine.The real problem is when you start using runtime reflection, like
getattr(obj, "x")def get_price(x): return x.prizeOk imagine you are a LSP. What type is
x? Isprizea typo? What auto-complete options would you return forx.?I didn’t say types. I said find references / go to definition / rename.
How are you going to find references to
prize, go to its definition or rename it without knowing what typexis? It’s impossible without static types.It breaks down when you do runtime reflection, like
getattr(obj, "x").