Writing and linting Python at scale

Post by llwu » Wed, Nov 22, 2023, 10:00 PM UTC

driggs wrote: post #8

It looks like the interesting feature of their tool Fixit 2 is that its lint rules know how to auto-apply themselves. I'm fine with an auto code formatter, an auto import organizer, but not sure how much I trust a linter to auto-apply "fixes".

Post by corethree » Wed, Nov 22, 2023, 10:08 PM UTC

Timon3 wrote: post #34

corethree wrote: post #21

Earlier quoted context omitted.

Python not only has types but it's type system is superior to typeScript. Get this python has sum types and exhaustive pattern matching exactly like rust or haskell. The only problem with python are the libraries are sometimes written with tricks that make static typing ineffective. Other than that it is really really good at scale. Better API then typescript imo which is really it's main competitor. edit: (rate limi…

> Python not only has types but it's type system is superior to typeScript. I strongly disagree. It might be better at some things, but it's much worse at others. Many functions can't be accurately typed (try, for example, to make a well-typed function that concatenates two arbitrary fixed-size tuples), and as far as I know generic type transformations can't be implemented (random example "this type takes a Dict[str,…

   def concat_tuples(tuple1: Tuple[int, str, float], tuple2: Tuple[str, str, str]) -> Tuple[int, str, float, str, str, str]:
       return tuple1 + tuple2

   T = TypeVar('T')
   def transform(x: Dict[str, T]) -> Dict[str, Callable[[], T]]:
       return {key: lambda : value for key, value in x.items()}

   from numbers import Number
   def transform2(x: Dict[str, Number]) -> Dict[str, Callable[[Number], Number]]:
       return {key: lambda y: value + y for key, value in x.items()}

   def transform3(x: Dict[str, Number]) -> Dict[str, Callable[[], Number]]:
       return {key: lambda: value + value for key, value in x.items()}

Post by corethree » Wed, Nov 22, 2023, 10:14 PM UTC

dragonwriter wrote: post #87

Timon3 wrote: post #34

Earlier quoted context omitted.

> Python not only has types but it's type system is superior to typeScript. I strongly disagree. It might be better at some things, but it's much worse at others. Many functions can't be accurately typed (try, for example, to make a well-typed function that concatenates two arbitrary fixed-size tuples), and as far as I know generic type transformations can't be implemented (random example "this type takes a Dict[str,…

Python can almost do this with Variadic Generics from Python 3.11; its missing an exception to the single-unpacking rule (which exists to prevent ambiguity) to allow unambiguous cases. Then you would have: from typing import TypeVarTuple Ts = TypeVarTuple("Ts”) Us = TypeVarTuple("Us”) def tconcat( t1: tuple[*Ts], t2: tuple[*Us] ) -> tuple[*Ts, *Us]: ...

   Tuple[int, str, float] #correct

   List[Any]

Post by corethree » Wed, Nov 22, 2023, 10:19 PM UTC

Timon3 wrote: post #49

dazzlefruit wrote: post #44

Earlier quoted context omitted.

For the tuple example: from typing import TypeVar T, U, V, W = TypeVar('T'), TypeVar('U'), TypeVar('V'), TypeVar('W') def concatenate(a: tuple[T, U], b: tuple[V, W]) -> tuple[T, U, V, W]: return a + b For the generic type transformation example, I'm not sure what you mean: from typing import Any, Callable Transformer = Callable[[dict[str, Any]], dict[Callable, Any]] This seems to match your question but it's really w…

Your tuple example only works if both tuples have two elements. I specifically mentioned arbitrary fixed-size tuples (as in, tuples with an arbitrary non-variable length). Your generic type transformation example also doesn't come close to what Typescript does. The resulting dict will not have known keys based on the keys of the input dict. In Typescript I can write a function that takes an object with known keys, an…

    List[Any]

Post by Timon3 » Wed, Nov 22, 2023, 10:50 PM UTC

corethree wrote: post #97

Timon3 wrote: post #89

Earlier quoted context omitted.

That's the conclusion I also arrived at. The type system is slowly getting there, but many operations like this one are still not possible. It's a shame, because it makes features like decorators significantly harder to use with static typing.

I haven't seen a type system that allows variadic types for Tuples. This would be equivalent to creating a struct with variadic amount of properties. The definition for tuples here is similar to a struct. They are one in the same except structs have names for each property while tuples don't. That is literally the main concept of a tuple, just a struct with no names for properties. The type system for python is alrea…