added functions as parameters, Callable, and lambda

Author: thomasWeise

bibliography/bibliography.bib

@@ -91,6 +91,7 @@ @string { a_duchesnay_edouard
 @string { a_dutka_jacques = "Jacques Dutka" }
 @string { a_editors_of_encyclopaedia_britannica = "The Editors of Encyclopaedia Britannica" }
 @string { a_eglen_stephen_j = "Stephen J.\ Eglen" }
+@string { a_epperson_james_f = "James F.\ Epperson" }
 @string { a_euclid = "{{Euclid of Alexandria}~{(\ensuremath{E{\acute\upsilon}\kappa\lambda\varepsilon{\acute\iota}\delta\eta\varsigma})}}" }
 @string { a_euler_leonhard = "Leonhard Euler" }
 @string { a_fang_lu = "Lu Fang" }
@@ -190,13 +191,15 @@ @string { a_matthias_meg
 @string { a_maxwell_aaron = "Aaron Maxwell" }
 @string { a_mayorov_nikolay = "Nikolay Mayorov" }
 @string { a_mcintosh_shane = "Shane McIntosh" }
+@string { a_mendoza_mark = "Mark Mendoza" }
 @string { a_michel_vincent = "Vincent Michel" }
 @string { a_millman_jarrod_k = "K.\ Jarrod Millman" }
 @string { a_mirjalili_vahid = "Vahid Mirjalili" }
 @string { a_monga_rajat = "Rajat Monga" }
 @string { a_moore_eric_w = "Eric W.\ Moore" }
 @string { a_moore_sherry = "Sherry Moore" }
 @string { a_morris_sidney_a = "Sidney A.\ Morris" }
+@string { a_moss_maggie = "Maggie Moss" }
 @string { a_murray_derek_gordon = "Derek Gordon Murray" }
 @string { a_naik_ganesh = "Ganesh Naik" }
 @string { a_nakano_koji = "Koji Nakano" }
@@ -226,6 +229,7 @@ @string { a_picus_matti
 @string { a_polat_ilhan = "Ilhan Polat" }
 @string { a_pollard_tom_j = "Tom J.\ Pollard" }
 @string { a_pomerance_carl = "Carl Pomerance" }
+@string { a_prados_philippe = "Philippe PRADOS" }
 @string { a_press_william_h = "William H.\ Press" }
 @string { a_prettenhofer_peter = "Peter Prettenhofer" }
 @string { a_pylint_contributors = "{{Pylint Contributors}}" }
@@ -451,6 +455,7 @@ @string { p_university_of_toronto_cs
 @string { p_university_of_washington = "{University of Washington}" }
 @string { p_usas = "{United States of America Standards Institute~{(USAS)}}" }
 @string { p_usenix = "{{USENIX} Association}" }
+@string { p_wiley = "{Wiley}" }
 @string { p_wiley_and_sons_ltd = "{John Wiley and Sons Ltd.}" }
 @string { p_wolfram_research = "{Wolfram Research, Inc.}" }
 
@@ -518,6 +523,7 @@ @string { pa_university_of_toronto_cs
 @string { pa_university_of_washington = l_usa_seattle }
 @string { pa_usas = l_usa_new_york }
 @string { pa_usenix = l_usa_berkeley }
+@string { pa_wiley = l_usa_hoboken }
 @string { pa_wiley_and_sons_ltd = l_uk_chichester }
 @string { pa_wolfram_research = l_usa_champaign }
 
@@ -1105,6 +1111,15 @@ @article{E1985AEOCF
  addendum = {Translation of~\cite{E1737DFCD}.},
 }
 
+@book{E2013AITNMAA,
+ author = a_epperson_james_f,
+ title = {An Introduction to Numerical Methods and Analysis},
+ edition = {2},
+ date = {2013-10},
+ publisher = p_wiley_and_sons_ltd,
+ isbn = {9781118367599},
+}
+
 @book{EHF2008EEOGTGOJLH11FEEEELIEILHIATBG11EAPWMETBFR,
  title = {Euclid's Elements of Geometry~(\ensuremath{\Sigma\tau{o}\iota\chi\varepsilon{\tilde{\iota}}\alpha}). The Greek Text of J.L.~Heiberg~(1883-1885) from Euclidis Elementa, Edidit et Latine Interpretatus est I.L.~Heiberg in Aedibus } #  p_teubner_b_g # {i, 1883-1885. Edited, and provided with a modern English translation, by } # a_fitzpatrick_richard,
  author = a_euclid,
@@ -1560,6 +1575,17 @@ @techreport{PEP257
  urldate = {2024-07-27},
 }
 
+@techreport{PEP482,
+ author = a_langa_lukasz,
+ title = {Literature Overview for Type Hints},
+ number = {482},
+ xdata = {rep_pep},
+ date = {2015-01-08},
+ url = {https://peps.python.org/pep-0482},
+ urldate = {2024-10-09},
+}
+
+
 @techreport{PEP484,
  title = {Type Hints},
  author = a_van_rossum_guido # and # a_langa_lukasz,
@@ -1590,6 +1616,36 @@ @techreport{PEP515
  urldate = {2024-09-23},
 }
 
+@techreport{PEP585,
+ author = a_langa_lukasz,
+ title = {Type Hinting Generics In Standard Collections},
+ xdata = {rep_pep},
+ number = {585},
+ date = {2019-03-03},
+ url = {https://peps.python.org/pep-0585},
+ urldate = {2024-10-09},
+}
+
+@techreport{PEP604,
+ author = a_prados_philippe # and # a_moss_maggie,
+ title = {Allow Writing Union Types as \pythonil{X | Y}},
+ xdata = {rep_pep},
+ number = {604},
+ date = {2019-08-28},
+ url = {https://peps.python.org/pep-0604},
+ urldate = {2024-10-09},
+}
+
+@techreport{PEP612,
+ author = a_mendoza_mark,
+ title = {Parameter Specification Variables},
+ xdata = {rep_pep},
+ number = {612},
+ date = {2019-12-18/2020-07-13},
+ url = {https://peps.python.org/pep-0612},
+ urldate = {2024-10-09},
+}
+
 @techreport{PEP635,
  author = a_kohn_tobias # and # a_van_rossum_guido,
  title = {Structural Pattern Matching: Motivation and Rationale},
@@ -1700,6 +1756,13 @@ @proceedings{PROC2023GECCO
  date = {2023},
 }
 
+@inbook{PSF2024ACO,
+ title = {Annotating Callable Objects},
+ xdata = {PSF2024TPSL},
+ url = {https://docs.python.org/3/library/typing.html#annotating-callables},
+ urldate = {2024-10-09},
+}
+
 @inbook{PSF2024BIT,
  title = {Built-in Types},
  xdata = {PSF2024TPSL},
@@ -1745,6 +1808,14 @@ @inbook{PSF2024IPM
  urldate = {2024-08-17},
 }
 
+@inbook{PSF2024L,
+ title = {Lambda},
+ chapter = {6.14.},
+ xdata = {PSF2024TPLR},
+ url = {https://docs.python.org/3/reference/expressions.html#lambda},
+ urldate = {2024-10-09},
+}
+
 @inbook{PSF2024NTIFC,
  title = {Numeric Types -- \pythonilIdx{int}, \pythonilIdx{float}, \pythonilIdx{complex}},
  xdata = {PSF2024TPSL},

notation/software.sty

@@ -61,7 +61,7 @@ name={Mypy},%
 sort={Mypy},%
 description={%
 \pythonIdx{Mypy}%
-is a static type checking tool for \python~\cite{LLHSVRZSJYYMC2024MOSTFP}. %
+is a static type checking tool for \python~\cite{LLHSVRZSJYYMC2024MOSTFP} that makes use of \pglspl{typeHint}. %
 Learn more at \url{https://github.com/python/mypy} or in \cref{sec:variableTypesAndTypeHints,ut:mypy}.%
 }%
 }%

notation/terms.sty

@@ -45,12 +45,12 @@ See \cref{sec:howFloatingPointNumbersWork}.%
 %
 %
 \newglossaryentry{fstring}{%
-name={f-string},%
-plural={f-strings},%
+name={f\nobreakdashes-string},%
+plural={f\nobreakdashes-strings},%
 sort={f-string},
 description={%
 is a special string in \python, which delimited by \pythonil{f"..."}\pythonIdx{f\textquotedbl\idxdots\textquotedbl} which can contain expressions in curly braces like \pythonil{f"a\{6-1\}b"} that are then turned to text via \pgls{strinterpolation}, which turns the string to~\pythonil{"a5b"}. %
-f\nobreakdash-strings are discussed in \cref{sec:fstrings}.%
+f\nobreakdashes-strings are discussed in \cref{sec:fstrings}.%
 }%
 }%
 %
@@ -178,6 +178,22 @@ Under \ubuntu\ \linux, \ubuntuTerminal\ opens a terminal, which then runs a \bas
 }%
 %
 %
+\newglossaryentry{typeHint}{%
+name={type hint},%
+plural={type hints},%
+description={%
+are annotations that help programmers and static code analysis tools such as \mypy\ to better understand what type a variable or function parameter is supposed to be~\cite{PEP484,PEP482}. %
+\python\ is a dynamically typed programming language where you do not need to specify the type of, e.g., a variable. %
+This creates problems for code analysis, both automated as well as manual: %
+For example, it may not always be clear whether a variable or function parameter should be an integer or floating point number. %
+The annotations allow us to explicitly state which type is expected. %
+They are \emph{ignored} during the program execution. %
+They are a basically a piece of documentation. %
+See \cref{bp:typeHints,sec:varTypeHints}.%
+}%
+}%
+%
+%
 \newglossaryentry{unicode}{%
 name={Unicode},%
 description={%
@@ -198,3 +214,13 @@ The most popular distributed \gls{VCS} is \gls{git}.%
 }%
 }%
 %
+%
+\newglossaryentry{xAxis}{%
+name={\ensuremath{x}\nobreakdashes-axis},%
+plural={\ensuremath{x}\nobreakdashes-axes},%
+sort={x-axis},
+description={%
+The \ensuremath{x}\nobreakdashes-axis is the horizontal axis of a two-dimensional coordinate system, often referred to abscissa.%
+}%
+}%
+%

text/main/basics/collections/dictionaries/dictionaries.tex

@@ -13,7 +13,7 @@
 \begin{sloppypar}%
 \cref{lst:dicts:dicts_1} shows some examples of how we can use dictionaries.
 A dictionary can be created again using the \pythonil{\{...\}}\pythonIdx{\textbraceleft\idxdots\textbraceright!dict} syntax, however, this time, we place comma-separated \pythonil{key-value} pairs within the curly braces.
-The type hints for dictionaries\pythonIdx{dict!type hint} is \pythonil{dict[keyType][valueType]}, where \pythonil{keyType} is the type for the keys and \pythonil{valueType} is the type for the values.
+The \pglspl{typeHint} for dictionaries\pythonIdx{dict!type hint} is \pythonil{dict[keyType][valueType]}, where \pythonil{keyType} is the type for the keys and \pythonil{valueType} is the type for the values~\cite{PEP585}.
 The line \pythonil{num_str: dict[int, str] = \{2: "two", 1: "one", 3: "three", 4: "four"\}} therefore creates a new dictionary and stores it in the variable \pythonil{num_str}.
 The type-hint of the variable states that it can point only to dictionaries that have integers as keys and strings as values.
 The contents of the dictionary are the key-value pairs \pythonil{2: "two"}, \pythonil{1: "one"}, \pythonil{3: "three"}, and \pythonil{4: "four"}.
@@ -63,7 +63,7 @@
 We now create the empty dictionary \pythonil{str_num: dict[str, int] = \{\}}\pythonIdx{\textbraceleft\textbraceright}\pythonIdx{dict!empty}.\footnote{%
 Using the \pythonil{dict()}\pythonIdx{dict!empty} without arguments has the same effect, but several \pglspl{linter} discourage this and encourage using \pythonil{\{\}}\pythonIdx{\textbraceleft\textbraceright} instead.%
 }
-Notice that only due to the type hint \pythonil{dict[str, int]}, other programmers and static type-checking tools can know at this point that we intend to use strings as keys and integers as values in this new dictionary.
+Notice that only due to the \pgls{typeHint} \pythonil{dict[str, int]}, other programmers and static type-checking tools can know at this point that we intend to use strings as keys and integers as values in this new dictionary.
 The \pythonilIdx{update}\pythonIdx{dict!update} method allows us to append the values of an existing dictionary to a given dictionary.
 \pythonil{str_num.update(\{"one": 1, "three": 3, "two": 2, "four": 4\})} therefore stores four key-value pairs into our new dictionary.
 This time, the keys are indeed strings and the values are integers.

text/main/basics/collections/lists/lists.tex

@@ -19,7 +19,7 @@
 In \cref{lst:lists:lists_1}, we provide some first examples for using lists.
 A list can be defined by simply writing its contents, separated by~\pythonilIdx{,} inside square brackets~\pythonil{[...]}\pythonIdx{[\idxdots]}.
 \pythonil{["apple", "pear", "orange"]} creates a list with three elements, namely the strings \pythonil{"apple"}, \pythonil{"pear"}, and~\pythonil{"orange"}.
-If we want to store a list in a variable, then we can use the type hint~\pythonil{list[elementType]}\pythonIdx{list!type hint} where \pythonil{elementType} is to be replaced with the type of the list elements.
+If we want to store a list in a variable, then we can use the \pgls{typeHint}~\pythonil{list[elementType]}\pythonIdx{list!type hint} where \pythonil{elementType} is to be replaced with the type of the list elements~\cite{PEP585}.
 \pythonil{fruits: list[str] = ["apple", "pear", "orange"]} therefore creates the list \pythonil{fruits} with the contents listed above.
 It also tells any automated type checking tool and other programmers that we intent that only \pythonil{str} values should be stored inside the list.
 
@@ -159,7 +159,7 @@
 However, upon closer inspection, we discover some issues.
 In a first step, we would apply \mypy~(as~\cref{ut:mypy}) to check for problems with the types of variables.
 And indeed, \cref{exec:lists:lists_error:mypy} shows us \emph{three} errors!
-We defined \pythonil{my_list} as a list of strings by using the type hint \pythonil{list[str]}.
+We defined \pythonil{my_list} as a list of strings by using the \pgls{typeHint} \pythonil{list[str]}.
 However, we then set its value to be a list of three integer numbers (hence, three errors).
 As promised in the title of this section, we will also use another tool to analyze this program:~\ruff.
 
@@ -204,7 +204,7 @@
 %
 %
 In \cref{lst:lists:lists_fixed} we implement the three recommendations from the two tools.
-We change the type hint of the list to \pythonil{list[int]}, which solves the type confusion that \mypy\ discovered.
+We change the \pgls{typeHint} of the list to \pythonil{list[int]}, which solves the type confusion that \mypy\ discovered.
 We remove the useless copying of the list as \ruff\ recommended.
 Finally, we add a proper \pgls{docstring} at the top of the file, in which we even document the changes we applied.
 The output \cref{exec:lists:lists_fixed} of the new program remains the same.
@@ -228,7 +228,7 @@
 
 Well, this was only a two-line program.
 But ask yourself:
-Did you spot the incorrect type hint when you read the program?
+Did you spot the incorrect \pgls{typeHint} when you read the program?
 Did you see that we actually created a list and then copied it instead of using it directly?
 (The \pgls{docstring} I give you, no chance of seeing that as we did not mention it before.)
 Imagine that your job would be to work on a program with thousands of lines that was developed by a colleague.

text/main/basics/collections/sets/sets.tex

@@ -52,9 +52,9 @@
 \begin{sloppypar}%
 In \cref{lst:sets:sets_1}, we provide a first example for creating and working with sets.
 Sets can be created by using curly braces, i.e, \pythonil{\{...\}}\pythonIdx{\textbraceleft\idxdots\textbraceright!set}.
-They can be type-hinted using the notation \pythonil{set[elementType]}\pythonIdx{set!type hint} where \pythonil{elementType} is the type of elements to be stored in the set.
+They can be type-hinted using the notation \pythonil{set[elementType]}\pythonIdx{set!type hint} where \pythonil{elementType} is the type of elements to be stored in the set~\cite{PEP585}.
 The line \pythonil{upper: set[str] = \{"A", "G", "B", "T", "V"\}} creates the variable \pythonil{upper}, which points to a set of the five uppercase latin characters~\pythonil{"A"}, \pythonil{"G"}, \pythonil{"B"}, \pythonil{"T"}, and~\pythonil{"V"}.
-The type hint~\pythonil{set[str]} states that this is a set that shall contain only strings.%
+The \pgls{typeHint}~\pythonil{set[str]} states that this is a set that shall contain only strings.%
 \end{sloppypar}%
 %
 With the method~\pythonilIdx{add}\pythonIdx{set!add}, we can add new elements to a set.
@@ -71,7 +71,7 @@
 %
 We can also create a set by passing a sequence into the constructor~\pythonilIdx{set}.
 To demonstrate this, we first create the tuple~\pythonil{lower_tuple} to hold the lowercase characters \pythonil{("b", "i", "j", "c", "t", "i")}.
-The command \pythonil{lower: set[str] = set(lower_tuple)} creates the set \pythonil{lower}, type hints it as set of strings, and lets it contain all the elements of~\pythonil{lower_tuple}.
+The command \pythonil{lower: set[str] = set(lower_tuple)} creates the set \pythonil{lower}, \pglspl{typeHint} it as set of strings, and lets it contain all the elements of~\pythonil{lower_tuple}.
 \pythonil{lower_tuple} contains the letter \pythonil{"i"} twice, but it will appear only once in the set that we have created.
 Notice: Just calling \pythonil{set()} without argument (or with an empty collection inside) creates an empty set\pythonIdx{set!empty}.
 We can delete an element of a set using the \pythonilIdx{remove}\pythonIdx{set!remove} function:

text/main/basics/collections/tuples/tuples.tex

@@ -18,7 +18,7 @@
 First, they are immutable.
 You cannot add, delete, or change the elements of a tuple.
 Second, on a semantic level, lists are intended to hold objects of the same type.
-The type hint~\pythonil{list[int]} indicates that we want something to be list of integer numbers.
+The \pgls{typeHint}~\pythonil{list[int]} indicates that we want something to be list of integer numbers.
 While the \python\ interpreter permits us to ignore this and still store arbitrary objects in that list, this would violate the idea behind lists.
 Tuples, on the other hand, are designed to contain elements of different types.
 Since they cannot be changed, it will always be clear which element of which type is at which location.
@@ -31,14 +31,14 @@
 \begin{sloppypar}%
 \Cref{lst:tuples:tuples_1} shows us some of the things we can do with tuples.
 We create a tuple \pythonil{fruits} to hold three strings.
-The proper type hint for this is \pythonil{tuple[str, str, str]}\pythonIdx{tuple!type hint}.
+The proper \pgls{typeHint} for this is \pythonil{tuple[str, str, str]}\pythonIdx{tuple!type hint}~\cite{PEP585}.
 The line \pythonil{fruits: tuple[str, str, str] = ("apple", "pear", "orange")} thus creates a tuple~\pythonil{fruits} which contains three strings, namely \pythonil{"apple"}, \pythonil{"pear"}, and~\pythonil{"orange"}
-We also annotated the variable with a type hint informing any static code analysis tool that we indeed intend to store three strings in the tuple.
+We also annotated the variable with a \pgls{typeHint} informing any static code analysis tool that we indeed intend to store three strings in the tuple.
 Notice that the tuple is defined using parentheses, whereas a list with the same content would have been defined using square brackets, e.g., as \pythonil{fruits: list[str] = ["apple", "pear", "orange"]}.%
 \end{sloppypar}%
 %
 \begin{sloppypar}%
-If we are not sure about the actual number of elements that we will put in a tuple but know that they are all of the same type, we can use the ellipsis~\pythonilIdx{...} in the type hint.
+If we are not sure about the actual number of elements that we will put in a tuple but know that they are all of the same type, we can use the ellipsis~\pythonilIdx{...} in the \pgls{typeHint}.
 \pythonil{tuple[str, ...]} denotes a tuple that can receive an arbitrary amount of strings.\pythonIdx{tuple!type hint!...}
 The line \pythonil{veggies: tuple[str, ...] = ("onion", "potato", "leek", "garlic")} is therefore correct and defined a tuple~\pythonil{veggies} consisting of four strings.%
 \end{sloppypar}%
@@ -57,7 +57,7 @@
 %
 \begin{sloppypar}%
 In \cref{lst:tuples:tuples_2} we explore tuples containing elements of multiple types.
-The type hint \pythonil{tuple[str, int, float]} states that we want to define a tuple where the first element is a string, the second element is an integer number, and the third element is a floating point number.
+The \pgls{typeHint} \pythonil{tuple[str, int, float]} states that we want to define a tuple where the first element is a string, the second element is an integer number, and the third element is a floating point number.
 The line \pythonil{mixed: tuple[str, int, float] = ("apple", 12, 1e25)} stores such a tuple in the variable~\pythonil{mixed}.
 The first element of the tuple is the string~\pythonil{"apple"}.
 The second element is the integer~\pythonil{12} and the third element is the floating point number~\pythonil{1e25}, i.e.,~$10^{25}$.
@@ -66,11 +66,11 @@
 %
 \begin{sloppypar}%
 We now want to create a list of such tuples.
-This list should, of course, also be annotated with the proper type hint.
+This list should, of course, also be annotated with the proper \pgls{typeHint}.
 This is easy:
-The type hint for our kind of tuples is \pythonil{tuple[str, int, float]}.
-The type hint for a list is \pythonil{list[elementType]}, where \pythonil{elementType} is the type of the elements.
-If we want to create a list containing tuples of our kind, then the proper type hint would be \pythonil{list[tuple[str, int, float]]}.
+The \pgls{typeHint} for our kind of tuples is \pythonil{tuple[str, int, float]}.
+The \pgls{typeHint} for a list is \pythonil{list[elementType]}, where \pythonil{elementType} is the type of the elements.
+If we want to create a list containing tuples of our kind, then the proper \pgls{typeHint} would be \pythonil{list[tuple[str, int, float]]}.
 Having realized this, we can now create the list~\pythonil{tuples}.
 We use the square bracket syntax for this.
 As first element, we put the tuple stored in the variable~\pythonil{mixed}.