/ home / Programming / Python /

Function Overloading

Function overloading allows one to define multiple functions under the same name, taking different arguments. The task below shows the requisite code for overloading:

Python Qt/Cpp
  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:
  • Define a debug function with two arguments
  • [ whether it returns anything is unknown ]
  • T & TT [ Shorthand for Type ]
  • which implies a generic all purpose argument
  • [ whether this function alters the arguments is unknown ]
  • in which TT equals None [ Undefined ] by default.
  • After several complex conditional statements
  • [ return statements may be hidden in the definitions ]
  • if all else fails then the system exits with the message
  • 'Fatal: No Programming'.
  • Four prototypes of a void type debug function exist
  • [ They are probably defined elsewhere ]
  • whos parameter lists are combinations of
  • [ constant [ read-only ] references to ]
  • Foo and Bar structures.
  • These functions are probably for debugging Foo and Bar.
Benefits:
  • Everything is defined under one function, which some people may like because all the definitions are close together.
  • The syntax ' if T is Foo and TT is None ' is very straight forward and easy to understand.
  • You can be a lot more flexible with the default behaviour, given the dynamic nature of the language.
  • Requisite information [ gleamed from the function signature ] is provided with less lines of code
  • Decoupled, and easy to extend.
  • Logic for determining which definition to use, is handled by compiler.
Drawbacks:
  • Every definition has to exist in an extra indentation.
  • Have to sift through the definitions to read then write your relevant code.
  • The complexity of the conditional statements is relative to the amount of parameters in the function.
  • Its not obvious that this is intended for function overloading, even after glancing at the source code.
  • Bugs are very easy to create in the conditional statements. For example, a person may define some code, but mess up the conditional, and it may never fire when expected.
  • ' TT = None ' is kind of an odd red herring.
  • Difficult to create a dynamic solution using this particular idiom.

Final Thoughts