You have a forward declaration; functions (to be bound as methods) are created before the class is, so the name Vector doesn’t yet exist. Only when all of the class body has been executed, can Python create the class object and bind the name Vector to it. Simply use a string with the name instead: … Read more
PHP 7.1 or newer (released 2nd December 2016) You can explicitly declare a variable to be null with this syntax function foo(?Type $t) { } this will result in $this->foo(new Type()); // ok $this->foo(null); // ok $this->foo(); // error So, if you want an optional argument you can follow the convention Type $t = null … Read more
Use float only, as int is implied in that type: def my_func(number: float): PEP 484 Type Hints specifically states that: Rather than requiring that users write import numbers and then use numbers.Float etc., this PEP proposes a straightforward shortcut that is almost as effective: when an argument is annotated as having type float, an argument … Read more
According to PEP 526, this is not allowed: In addition, one cannot annotate variables used in a for or with statement; they can be annotated ahead of time, in a similar manner to tuple unpacking Annotate it before the loop: i: int for i in range(5): pass PyCharm 2018.1 and up now recognizes the type … Read more
Update: This is not a catchable fatal error anymore in php 7. Instead an “exception” is thrown. An “exception” (in scare quotes) that is not derived from Exception but Error; it’s still a Throwable and can be handled with a normal try-catch block. see https://wiki.php.net/rfc/throwable-interface E.g. <?php class ClassA { public function method_a (ClassB $b) … Read more
PHP 7.1 Now supports nullable return types. The first RFC I linked to is the one they went for: function nullOrString(int $foo) : ?string { return $foo%2 ? “odd” : null; } old answer: Since my comment was actually an answer to the question: PHP 7 won’t support nullable return-types just yet, but there’s an … Read more
Until Python 3.9 added support for type hinting using standard collections, you had to use typing.Tuple and typing.List if you wanted to document what type the contents of the containers needed to be: def f(points: Tuple[float, float]): return map(do_stuff, points) Up until Python 3.8, tuple and list did not support being used as generic types. … Read more
You are always returning one object; using return one, two simply returns a tuple. So yes, -> Tuple[bool, str] is entirely correct. Only the Tuple type lets you specify a fixed number of elements, each with a distinct type. You really should be returning a tuple, always, if your function produces a fixed number of … Read more
The former is correct, if arg accepts an instance of CustomClass: def FuncA(arg: CustomClass): # ^ instance of CustomClass In case you want the class CustomClass itself (or a subtype), then you should write: from typing import Type # you have to import Type def FuncA(arg: Type[CustomClass]): # ^ CustomClass (class object) itself Like it … Read more
According to Suggested syntax for Python 2.7 and straddling code in PEP 484 which defined type hinting, there is an alternative syntax for compatibility with Python 2.7. It is however not mandatory so I don’t know how well supported it is, but quoting the PEP: Some tools may want to support type annotations in code … Read more