'switch'

1. # Special thanks from jinsuun__ on #python irc
2. from dataclasses import dataclass
4. @dataclass
5. class C:
6. m_c: int
7. isLetter : bool = False
8. isNonCharacter : bool = False
9. isNull : bool = False
10. isNumber : bool = False
11. isPrintable : bool = True
12. isSpace : bool = False
13. isUpper : bool = False
14. n = 88
15. c = C(n)
17. match c:
18. case C(0):
19. c.isNull = True
20. case C( m_c = x ) if x in range( 1, 32 ) or x == 127:
21. c.isNonCharacter = True
22. c.isPrintable = False
23. case C(" "):
24. c.isSpace = True
25. case C(x) if x in range( ord("A"), ord("Z") + 1 ):
26. c.isUpper = True
27. c.isLetter = True
28. case C(x) if x in range( ord("a"), ord("z") + 1 ):
29. c.isUpper = False
30. c.isLetter = True
31. case C(x) if x in range( ord("0"), ord("9") + 1 ):
32. c.isNumber = True
33. case _:
34. pass

1. qint8 c(88);
2. bool isLetter (false);
3. bool isNonCharacter(false);
4. bool isNull (false);
5. bool isNumber (false);
6. bool isPrintable (true );
7. bool isSpace (false);
8. bool isUpper (false);
10. switch (c) {
11. default: break;
12. case 0 :
13. isNull = true;
14. [[fallthrough]];
15. case 1 ... 31:
16. case 127 : // Delete
17. isNonCharacter = true;
18. isPrintable = false;
19. break;
21. case ' ':
22. isSpace = true;
23. break;
25. case 'A' ... 'Z':
26. isUpper = true;
27. [[fallthrough]];
28. case 'a' ... 'z':
29. isLetter = true;
30. break;
32. case '0' ... '9':
33. isNumber = true;
34. break;
35. }

Read as:

• 'match 'c [ a character dataclass ] where if:
• under case [ dataclass ] C(0)
• isNull equals true
• under case [ dataclass ] c is an instance of [ dataclass ] C which has an attribute m_c
• it will evaluate as true when we assign m_c to x and if x is in the range of 1 to 32 or is equal to 127,
• isNonCharacter equals true
• isPrintable equals false
• Under case [ dataclass ] C( space )
• isSpace equals true
• under case [ dataclass ] C( x [ which is a copy of the first attribute of C, m_c ] ) if x is in the range of A to Z,'
• isUpper equals true
• isLetter equals true
• under case [ dataclass ] C( x [ which is a copy of the first attribute of C, m_c ] ) if x is in the range of a to z,'
• isUpper equals false
• isLetter equals true
• under case [ dataclass ] C( x [ which is a copy of the first attribute of C, m_c ] ) if x is in the range of 0 to 9,'
• isNumber equals true
• under case underscore [ Which is a wildcard pattern, taking any argument ]
• pass [ and do nothing ]

• 'switch' c [ 'c' implying character value ]
• by default, 'break' [ out of the 'switch' ].
• Under case 0:
• isNull equals true.
• Fallthrough [ to the next case's code ]
• Under case from 1 to 31:
• Under case 127:
• isNonCharacter equals true.
• isPrintable equals false
• 'break' [ out of the 'switch' ]
• under case space character
• isSpace equals true.
• 'break' [ out of the 'switch' ]
• Under case from A to Z:
• isUpper equals true.
• Fallthrough [ to the next case's code ]
• Under case from a to z:
• isLetter equals true.
• 'break' [ out of the 'switch' ]
• Under case from 0 to 9:
• isNumber equals true.
• 'break' [ out of the 'switch' ]

Benefits:

• Cases support conditional triggers.

• A 'switch' here is transformed into a jump or lookup table for potential massive performance gains.
• In order to achieve this, the compiler guarantees that all case values are unique numeric values.
• Because of the unique value nature, the order of the case statements is more or less immaterial unless one plans to make fallthrough code
• Code can fallthrough allowing for subtle optimization.
• Offers excellent readability if working in tandem with enumerators

Drawbacks:

• Extremely unintuitive syntax.
• No fallthrough.
• Performatively poor, due to the fact that no jump is executed.
• Cases are not guaranteed unique.
• Two cases may evaluate as true, however only the first will execute

• Value has to be translateable to an interger form
• [[fallthrough]] is optional, and absent this, it may be easy to not realize that no 'break'is occurring.
• '0' has a different value than 0. Although this remains true in python as well in similar contexts.