On 9/18/20 3:12 PM, Guido van Rossum wrote:
> On 9/18/20 2:44 PM, Ethan Furman wrote:
>> I'm looking for arguments relating to:
>>
>> - should _convert_ make the default __repr__ be
>> module_name.member_name?
>
> I actually like the status quo for regular enums, when repr() shows
> the type, name and value, and str() shows "classname.flagname", so I'd
> stick to that for converted flags. Even though this violates the rule
> of thumb that repr() should look like a valid expression -- perhaps a
> stronger rule of thumb is that repr() should show more than str().
Well, if the repr is re.IGNORECASE and the str is 2, then we've met that
bar. ;-)
>> - should _convert_ make the default __str__ be the same, or be the
>> numeric value?
>
> Showing just (the str of) the value seems unkind, since e.g. showing
> '4' makes me think it's just an int. (Then again I can see that for
> *converted* flags that's not unreasonable.)
>
> But yeah, backwards compatibility. However, I don't think we got any
> complaints about the `re` flags, did we?
The only complaints I'm aware of were before the re constants became an
Enum, but my social media activity consists almost entirely of
Stackoverflow.
:-)
So at this point, I think the choices are:
Standard Enum
__repr__ __str__
<RegexFlag.IGNORECASE: 2> RegexFlag.IGNORECASE
and
Modified Converted Constant
__repr__ __str__
re.IGNORECASE 2
I will admit I fancy the MCC variant more, but we should make a choice
and then be consistent.
Hm, there's also what re actually does (tried in 3.8, 3.9 and 3.10):
```
>>> import re
>>> print(str(re.I))
RegexFlag.IGNORECASE
>>> print(repr(re.I))
re.IGNORECASE
>>>
```
I honestly think we've already lost consistency.
Possibly regular enums (Enum, IntEnum, IntFlag) should just all return "
class.name", e.g. 'Color.RED', for both str() and repr(), and "converted" enums should return "
module.name", e.g. 're.IGNORE' for both? It restores the rule of thumb, and it's not unusual. Maybe it's a new trend -- PEP 585's list[int] returns "list[int]" for both str() and repr(). :-)
At the same time it's as old as Python -- for most builtins other than strings, repr() and str() are the same, and modeled after repr(). Historically, I only introduced the difference between str() and repr() because of strings -- I wanted the REPL to clearly show the difference between the number 42 and the string '42', but at the same time I wanted both to print as just '42'. Of course numpy took a different fork in that road...
Another brainstorm (or brainfart): maybe repr() should show the module/class and the name, and str() should only show the name. We'd then get
```
>>> # Mock-up!
>>> print(str(re.i))
IGNORE
>>> print(repr(re.i))
re.IGNORE
>>>
```
and similar for Color.RED:
```
>>> # Another mock-up!
>>> print(str(Color.RED))
RED
>>> print(repr(Color.RED))
Color.RED
>>>
```
--