To me, these are mostly convincing examples that people need to name
parts of a complex type like this :-)
I don't actually find any of the syntaxes better than any other. They
are all a bit bad, but I view that as the fault of the complex nested
types, not the syntax (hence my preference for
In the example I was aiming for something easy to understand that produced a
type illustrating potential problems of PEP 677, which is at its worst when
there are callables in both argument and return position. I don't have a great
real-world example of this worst-case, most of what I've seen
Hello!
The python-dev list is for developing the next version of Python. For help
using Python, please send your question to
python-l...@python.org
Thanks, and good luck!
--
~Ethan~
___
Python-Dev mailing list -- python-dev@python.org
To
Good evening everyone I used python 3.7.3 IDLE i found the bug to solve the
problem when list contain repetitive value is come i.e. if i want to delete 2
from list using remove function it's 2 value put containouls 2 and such value
is remove using any type of loop all element are not delete
Ahah, that makes sense. But then I think I buy into your reasoning that this
isn't really a replacement for callable syntax (although functions as types
opens up other interesting possibilities). For this and other reasons I'd hate
to see callable syntax rejected in favor of it, so definite +1
I agree with what Batuhan said. Adding on, I'm very concerned about the
potential maintenance burden for Python implementations.
Just for typing in CPython, some combination of the following knowledge is
required to contribute code:
1. Metaclasses
2. Descriptors and CPython dunders
3. C
On Tue, 21 Dec 2021 at 18:35, Steven Troxler wrote:
>
> I've been thinking about readability hard because I share many of your
> concerns about readability.
Before I comment on syntax, I'd like to question the example:
> An example
> =
>
> The function
>
>
> To get at
I've been thinking about readability hard because I share many of your concerns
about readability.
I'm starting to think parenthesizing the outside might work much better in
practice:
```
(int, str -> bool)
```
instead of
```
(int, str) -> bool
```
This looks a bit less familiar, but it
-
