lambda function are now compiled so they are regular functions

Author: craigbarratt

custom_components/pyscript/eval.py

@@ -1042,13 +1042,21 @@ async def ast_functiondef(self, arg):
             sym_table[name] = func_var
 
     async def ast_lambda(self, arg):
-        """Evaluate lambda definition."""
-        funcdef = ast.FunctionDef(
-            args=arg.args, body=[ast.Return(value=arg.body)], name="lambda", decorator_list=None,
+        """Evaluate lambda definition by compiling a regular function."""
+        name = "__lambda_defn_temp__"
+        await self.aeval(
+            ast.FunctionDef(
+                args=arg.args,
+                body=[ast.Return(value=arg.body, lineno=arg.body.lineno, col_offset=arg.body.col_offset)],
+                name=name,
+                decorator_list=[ast.Name(id="pyscript_compile", ctx=ast.Load())],
+                lineno=arg.col_offset,
+                col_offset=arg.col_offset,
+            )
         )
-        func = EvalFunc(funcdef, self.code_list, self.code_str, self.global_ctx)
-        await func.eval_defaults(self)
-        return EvalFuncVar(func)
+        func = self.sym_table[name]
+        del self.sym_table[name]
+        return func
 
     async def ast_asyncfunctiondef(self, arg):
         """Evaluate async function definition."""

docs/reference.rst

@@ -788,12 +788,14 @@ Other Function Decorators
 
 By default in pyscript all functions are async, so they cannot be used in ``task.executor``,
 as callbacks or methods in python packages that expect regular functions, or used with built-in
-functions like ``map`` or special class methods that are called by python internals (eg,
-``__getattr__`` or ``__del__``).
+functions like ``filter``, ``map`` or special class methods that are called by python internals
+(eg, ``__getattr__`` or ``__del__``).
 
 The ``@pyscript_compile`` decorator causes the function to be treated as native Python and
 compiled, which results in a regular python function being defined, and it will run at full
-compiled speed.
+compiled speed. A ``lambda`` function is automatically compiled so it behaves like a regular
+python ``lambda`` function (which means the lambda function body cannot contain pyscript
+features).
 
 For example:
 

tests/test_unit_eval.py

@@ -123,6 +123,7 @@
     ["d = {'x': 123}; d['x'] += 10; d", {"x": 133}],
     ["d = [20, 30]; d[1] += 10; d", [20, 40]],
     ["func = lambda m=2: 2 * m; [func(), func(3), func(m=4)]", [4, 6, 8]],
+    ["thres = 1; list(filter(lambda x: x < thres, range(-5, 5)))", [-5, -4, -3, -2, -1, 0]],
     ["y = 5; y = y + (x := 2 * y); [x, y]", [10, 15]],
     ["Foo = type('Foo', (), {'x': 100}); Foo.x = 10; Foo.x", 10],
     ["Foo = type('Foo', (), {'x': 100}); Foo.x += 10; Foo.x", 110],