I find this approach too cryptic compared to reading regular Python
notation, my brain has to mode switch to make sense of it. Would a little
extra ?: be too much add to make clear it's a lambda function, e.g.
?: ? > 0 instead of ? > 0
Also either approach *could *add multi-argument lambdas:
?1, ?2: ?1 > ?2 or just ?1 > ?2
I wonder though if there's a nice approach to have a no argument lambda? 🤔
Damian (he/him)
On Wed, Sep 29, 2021 at 8:55 AM Dominik Vilsmeier <dominik.vilsme...@gmx.de>
wrote:
> Lambda functions that have a single parameter are a common thing, e.g. for
> "key" functions: `sorted(items, key=lambda x: x['key'])`. For these cases
> however, the rather long word "lambda" together with the repetition of the
> parameter name, results in more overhead than actual content (the
> `x['key']`) and thus makes it more difficult to read. This is also a
> difficulty for `map` and `filter` for example where there's lots of visual
> overhead when using a lambda function and hence it's difficult to read:
> `filter(lambda x: x > 0, items)` or `map(lambda x: f'{x:.3f}', items)`.
>
> Hence the proposal is to add a new syntax via the new token `?`. For the
> examples above:
>
> * `sorted(items, key=?['key'])`
> * `filter(? > 0, items)`
> * `map(f'{?:.3f}', items)`
>
> The rules are simple: whenever the token `?` is encountered as part of an
> expression (at a position where a name/identifier would be legal), the
> expression is replaced by a lambda function with a single parameter which
> has that expression as a return value, where any instances of `?` are
> replaced by the name of that single parameter. For example:
>
> * `?['key']` translates to `lambda x: x['key']`
> * `? > 0` translates to `lambda x: x > 0`
> * `f'{?:.3f}'` translates to `lambda x: f'{x:.3f}'`
> * `?*?` translates to `lambda x: x*x`
>
> With the difference that the replacement function would use an unnamed
> parameter, i.e. not shadowing any names from outer scopes. So `? * x` would
> use `x` from enclosing scopes, not as the lambda parameter.
>
> Regarding operator precedence, the rules would be similar as for lambda
> functions, i.e. it will include as much in the expression as it would for a
> lambda function.
>
> To find more example use cases, I used `grep -rnE 'lambda
> [_a-zA-Z][_a-zA-Z0-9]*:' Lib/` on the CPython standard library to find
> single parameter lambda functions and there are various results coming up
> (although not all are applicable, e.g. because they return a constant
> value). I'll include a few examples below, but the actual list is much
> longer:
>
> ```
> modes[char] = max(items, key=lambda x: x[1])
> modes[char] = max(items, key=?[1]) # proposed new syntax
>
> obj = unwrap(obj, stop=(lambda f: hasattr(f, "__signature__")))
> obj = unwrap(obj, stop=hasattr(?, "__signature__"))
>
> s = re.sub(r"-[a-z]\b", lambda m: m.group().upper(), s)
> s = re.sub(r"-[a-z]\b", ?.group().upper(), s)
>
> members.sort(key=lambda t: (t[1], t[0]))
> members.sort(key=(?[1], ?[0]))
> ```
>
> Of course, there is no requirement to use `?` as the token, it could be
> any other character that's currently not used by Python, i.e. `$` or `!`
> would be possible too.
> _______________________________________________
> Python-ideas mailing list -- python-ideas@python.org
> To unsubscribe send an email to python-ideas-le...@python.org
> https://mail.python.org/mailman3/lists/python-ideas.python.org/
> Message archived at
> https://mail.python.org/archives/list/python-ideas@python.org/message/HADJG5L6ML7JRYKPRCSNJGWBY4NPG5NH/
> Code of Conduct: http://python.org/psf/codeofconduct/
>
_______________________________________________
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at
https://mail.python.org/archives/list/python-ideas@python.org/message/SD4IUPNCTQMS25KJSVDO7WX45MYGYUYZ/
Code of Conduct: http://python.org/psf/codeofconduct/
