callable

Author: KotlinIsland

ROADMAP.md

@@ -41,7 +41,13 @@ upstream improvements. the symbol table phase handles nearly all near-term featu
 
 ## planned features
 
-- [ ] language server (fork ty)
+- [ ] fork ruff/ty
+  - essential features:
+    - `lsp` subcommand (with full suite of features from ruff and ty)
+    - `format` (from ruff)
+    - `check` (from ruff)
+    - `check` (from ty) - not sure about the name, maybe `lint` and `check` or maybe `typecheck`?
+    - one option would be to produce two binaries: buff and by
 - [ ] source maps
 - [ ] build wheels (`by build`?)
   - ensure that built wheel depends on the correct deps for polyfill (`tomli`/`typing_extensions` etc)
@@ -60,7 +66,7 @@ upstream improvements. the symbol table phase handles nearly all near-term featu
 - [x] PEP 695 generics polyfill: `class A[T]`, `def f[T]()`, `type X = ...` → 3.10-compatible equivalents including TypeVar name renaming
 - [x] `typing` import redirect: names unavailable in stdlib until later versions are redirected to `typing_extensions`
 - [x] expression compat rewrites: `datetime.UTC`, `sys.exception()`, `math.exp2()` → 3.10-compatible equivalents
-- [ ] callable syntax: `(int) -> int` -> `Callable[[int], int]` / `[T](int, t: T) -> T` → a `Protocol` definition
+- [x] callable syntax: `(int) -> int` -> `Callable[[int], int]` / `[T](int, t: T) -> T` → a `Protocol` definition
   `(int, /, a: str, *args: int, **kwargs: str) -> None`
 - [x] unpack syntax in type annotations: `def f(*args: *tuple[int, ...])` -> `def f(*args: Unpack[tuple[int, ...]])` #easy
 - [x] intersection types: `A & B` -> `ty_extensions.Intersection[A, B]` #easy
@@ -84,6 +90,22 @@ upstream improvements. the symbol table phase handles nearly all near-term featu
      print(y)
   ))
   ```
+  OR
+  ```bython
+  x(: print(it))
+  # trailing
+  x: print(it)
+  if x: print(it) # error, ambigious, need parens
+  a = (): print(1)
+  foo(:
+      a = 1
+      a + 1,
+      :
+      b = 2
+      b + 1
+  )
+  ```
+- [ ] annotations on `lambda`: `lambda (a: int, b: str) -> bool: a + b` -> `lambda a, b: a + b` #easy
 - [ ] extension functions: (needs design) `def Foo.bar():`
 - [ ] property syntax: (needs design)
   ```
@@ -154,6 +176,16 @@ upstream improvements. the symbol table phase handles nearly all near-term featu
   - maybe also call expressions
 - [ ] make ternary expressions bearable: `if bool() 1 else 2`
 - [ ] `match`/`try` as an expression #easy
+- [ ] reified type parameters #harder
+  ```python
+  def f[T](x: object) -> bool:
+      return isinstance(x, T)
+  ```
+- [ ] generic function calls 
+  ```python
+  def f[T](t1: T, t2: T) -> T: ...
+  f[object](1, "a")
+  ```
 
 ### anonymous named tuple:
 ```

crates/ruff_python_ast/src/comparable.rs

@@ -1008,6 +1008,12 @@ pub struct ExprIpyEscapeCommand<'a> {
     value: &'a str,
 }
 
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct ExprCallableType<'a> {
+    args: Vec<ComparableExpr<'a>>,
+    returns: Box<ComparableExpr<'a>>,
+}
+
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub enum ComparableExpr<'a> {
     BoolOp(ExprBoolOp<'a>),
@@ -1045,6 +1051,7 @@ pub enum ComparableExpr<'a> {
     Tuple(ExprTuple<'a>),
     Slice(ExprSlice<'a>),
     IpyEscapeCommand(ExprIpyEscapeCommand<'a>),
+    CallableType(ExprCallableType<'a>),
 }
 
 impl<'a> From<&'a Box<ast::Expr>> for Box<ComparableExpr<'a>> {
@@ -1324,6 +1331,15 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
                 range: _,
                 node_index: _,
             }) => Self::IpyEscapeCommand(ExprIpyEscapeCommand { kind: *kind, value }),
+            ast::Expr::CallableType(ast::ExprCallableType {
+                args,
+                returns,
+                range: _,
+                node_index: _,
+            }) => Self::CallableType(ExprCallableType {
+                args: args.iter().map(ComparableExpr::from).collect(),
+                returns: Box::new(returns.as_ref().into()),
+            }),
         }
     }
 }