{"version":"https:\/\/jsonfeed.org\/version\/1","title":"mathspp.com feed","home_page_url":"https:\/\/mathspp.com\/blog\/tags\/typing","feed_url":"https:\/\/mathspp.com\/blog\/tags\/typing.json","description":"Stay up-to-date with the articles on mathematics and programming that get published to mathspp.com.","author":{"name":"Rodrigo Gir\u00e3o Serr\u00e3o"},"items":[{"title":"TIL #084 \u2013 type statement and type aliases","date_published":"2023-10-03T10:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/til\/type-statement-and-type-aliases","url":"https:\/\/mathspp.com\/blog\/til\/type-statement-and-type-aliases","content_html":"

Today I learned about the Python 3.12 type statement you can use to create type aliases.<\/p>\n\n

type<\/code> statement and type aliases<\/a><\/h2>\n

Python 3.12 introduced the soft keyword type<\/code>, which is used in the type<\/code> statement to create type aliases.\nThe type<\/code> statement offers a more convenient and powerful<\/a> way of creating type aliases and it supersedes typing.TypeAlias<\/code>.<\/p>\n

In its simplest form, the type<\/code> statement is composed of the type<\/code> keyword, the name of the type alias you are creating, and the type you are aliasing.\nThe example below shows how to create a type alias called Point<\/code> that is the same as a pair with two floats:<\/p>\n

type Point = tuple[float, float]<\/code><\/pre>\n
Before the introduction of the type<\/code> statement, you could create a type alias via a regular assignment:<\/p>\n
Point = tuple[float, float]<\/code><\/pre>\n
You could also annotate Point<\/code> with typing.TypeAlias<\/code> to make it clear that you were creating a type alias:<\/p>\n
from typing import TypeAlias\n\nPoint: TypeAlias = tuple[float, float]<\/code><\/pre>\n
So, why do we care about the type<\/code> statement?<\/p>\n
Forward references<\/a><\/h3>\n
One of the advantages of the type<\/code> statement is that it supports forward referencing without having to quote the names of the types you are refering to.\nThis is possible because the type value is lazily evaluated.<\/p>\n
For example, suppose we want to create a recursive type for a linked list, where a linked list is a tuple with two elements: an integer and a linked list (the remainder of the linked list).\nIn 3.12, you could write it as such:<\/p>\n
type LinkedList = tuple[int, LinkedList]<\/code><\/pre>\n
The self-reference works just fine, and so does the forward reference of the example below:<\/p>\n
type A = tuple[B, C, D]\ntype B = int\ntype C = str\ntype D = list[str]<\/code><\/pre>\n
In Python 3.11 and earlier, you'd have to quote the forward references or the self-reference of the first example, like so:<\/p>\n
from typing import TypeAlias\n\nLinkedList: TypeAlias = tuple[int, \"LinkedList\"]\n\nA: TypeAlias = tuple[\"A\", \"B\", \"C\"]\nB: TypeAlias = int\nC: TypeAlias = str\nD: TypeAlias = list[str]<\/code><\/pre>\n
Generic type aliases<\/a><\/h3>\n
Type aliases can also be made generic.\nFor example, the linked list could be a linked list of any kind of value we want, not just integers.<\/p>\n
We could type the linked list like so:<\/p>\n
type LinkedList[T] = T | tuple[T, LinkedList[T]]<\/code><\/pre>\n
This means that a linked list is either a value of its type T<\/code> or it is a pair with a value and a linked list.<\/p>\n
For example, the variable ll<\/code> below defines a linked list of integers:<\/p>\n
ll: LinkedList[int] = (42, (73, (10, (16, 0))))<\/code><\/pre>\n
This is just the tip of the iceberg.\nGenerics were also improved in Python 3.12, so there's even more you can do.\nYou can take a look at the references<\/a> below to learn more about this.<\/p>","summary":"Today I learned about the Python 3.12 type statement you can use to create type aliases.","date_modified":"2025-07-23T16:49:02+02:00","tags":["programming","python","typing"],"image":"\/user\/pages\/02.blog\/04.til\/084.type-statement-and-type-aliases\/thumbnail.webp"},{"title":"TIL #083 \u2013 sentinel value for default arguments","date_published":"2023-09-15T21:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/til\/sentinel-value-for-default-arguments","url":"https:\/\/mathspp.com\/blog\/til\/sentinel-value-for-default-arguments","content_html":"
Today I learned how to create a sentinel value to use as a default argument in a way that respects Python typing.<\/p>\n\n
Sentinel value for default arguments<\/a><\/h2>\n
Context<\/a><\/h3>\n
Today at work I had a problem.\nI was working on a progress bar that Textual<\/a> has:<\/p>\n
\"A<\/p>\n
The ProgressBar<\/code> class has a method update<\/code> that you can use to update the status of the progress bar.\nThe method update<\/code> looked roughly<\/em> like this:<\/p>\n
class ProgressBar(...):\n    ...\n\n    def update(\n        self,\n        total: float | None = None,\n        progress: float | None = None,\n        advance: float | None = None,\n    ) -> None:\n        \"\"\"Update the status of the progress bar.\"\"\"\n        if total is not None:\n            self.total = total\n        if progress is not None:\n            self.progress = progress\n        if advance is not None:\n            self.progress += advance<\/code><\/pre>\n
By calling update<\/code>, you can change the total “size” of the progress bar (total<\/code>), you can change how far along you are with the progress (progress<\/code>), and you can increment the current progress by a given amount (advance<\/code>).<\/p>\n
For example, if you create a progress bar pb<\/code> and then call pb.update(total=100, progress=30, advance=7)<\/code>, your progress bar ends up at 37% completion and it would look something like this:<\/p>\n
\"A<\/p>\n
What's the problem, then?<\/p>\n
Using another default value instead of None<\/code>\n<\/a><\/h3>\n
The default value for total<\/code> is None<\/code>, but the truth is that I also want to be able to set total<\/code> to None<\/code>, because that turns the progress bar into its indeterminate\/pulsing state.\nSo, how can I do this?<\/p>\n
The answer is obvious: just use another default value!<\/p>\n
That's right, but I can't use any random default value, because then the typing will look odd!\nFor example, I could use the string \"default\"<\/code>, and modify the method to look like this:<\/p>\n
class ProgressBar(...):\n    ...\n\n    def update(\n        self,\n        total: float | str | None = \"default\",\n        progress: float | None = None,\n        advance: float | None = None,\n    ) -> None:\n        \"\"\"Update the status of the progress bar.\"\"\"\n        if not isinstance(total, str):\n            self.total = total\n        if progress is not None:\n            self.progress = progress\n        if advance is not None:\n            self.progress += advance<\/code><\/pre>\n
The problem with this, I argue, is that it looks really odd to have total<\/code> accept values of the type str<\/code>, when it really doesn't, it's just so that the typing matches the default value given...<\/p>\n
In other words, if I just had<\/p>\n
...\ntotal: float | None = \"default\",\n...<\/code><\/pre>\n
then the typing would be wrong.\nAnd I want to have the code typed correctly, if possible.<\/p>\n
So, how do we solve this?<\/p>\n
Using object<\/code> as the default value<\/a><\/h3>\n
My next thought went to using object<\/code> as the default value.\nSo, something like this:<\/p>\n
_sentinel = object()\n\nclass ProgressBar(...):\n    ...\n\n    def update(\n        self,\n        total: float | None | object = _sentinel,\n        progress: float | object = _sentinel,\n        advance: float | object = _sentinel,\n    ) -> None:\n        \"\"\"Update the status of the progress bar.\"\"\"\n        if total is not _sentinel:\n            self.total...<\/code><\/pre>","summary":"Today I learned how to create a sentinel value to use as a default argument in a way that respects Python typing.","date_modified":"2025-07-23T16:49:02+02:00","tags":["programming","python","typing"],"image":"\/user\/pages\/02.blog\/04.til\/083.sentinel-value-for-default-arguments\/thumbnail.webp"},{"title":"TIL #054 \u2013 type hint Any","date_published":"2022-11-04T00:00:00+01:00","id":"https:\/\/mathspp.com\/blog\/til\/type-hint-any","url":"https:\/\/mathspp.com\/blog\/til\/type-hint-any","content_html":"
Today I learned about the type hint Any<\/code> and its bidirectional compatibility with all other types.<\/p>\n\n
Type hint Any<\/code><\/a><\/h2>\n
The special type Any<\/code> provided in the module typing<\/code> is a type that matches all<\/em> Python objects.\nThe documentation says that Any<\/code> is compatible with all other types and all other types are compatible with Any<\/code>.<\/p>\n
I have a limited understanding of type hints in Python, but I don't think this sentence is redundant:<\/p>\n
\n
“A static type checker will treat every type as being compatible with Any<\/code> and Any<\/code> as being compatible with every type.”<\/p>\n<\/blockquote>\n
This compatibility<\/em> seems to be related to subclasses and the methods and attributes that objects provide.<\/p>\n
For example, suppose we have this class hierarchy:<\/p>\n
class Animal:\n    pass\n\nclass Human(Animal):\n    pass<\/code><\/pre>\n
All instances of Human<\/code> are also instances of Animal<\/code> (because Human<\/code> is a subclass of Animal<\/code>) but there may be instances of Animal<\/code> that are not instances of Human<\/code>.\nFor example, dolphins are definitely animals and also definitely not humans.<\/p>\n
So, the type Human<\/code> is compatible with the type Animal<\/code>.\nWhy?\nBecause all instances of Human<\/code> can also be seen as instances of Animal<\/code>.\nIn fact, the function below would pass static type checking:<\/p>\n
def foo(human: Human) -> Animal:\n    return human<\/code><\/pre>\n
However, the reverse does not<\/strong> pass static type checking:<\/p>\n
def bar(animal: Animal) -> Human:\n    return animal<\/code><\/pre>\n
The static type checker complains with “Animal<\/code> is incompatible with Human<\/code>”.\nSo, if Any<\/code> is compatible with all types and if all types are compatible with Any<\/code>, this means the functions f<\/code> and g<\/code> below should pass static type checking:<\/p>\n
from typing import Any\n\ndef f(x: int) -> Any:\n    return x\n\ndef g(x: Any) -> int:\n    return x<\/code><\/pre>\n
And they do.\nIf you run a static type checker against the functions f<\/code> and g<\/code>, they both pass static type checking.<\/p>\n
What bothers me is that the function g<\/code> seems to be typed improperly.\nAfter all, I can write this code:<\/p>\n
from typing import Any\n\ndef g(x: Any) -> int:\n    return x\n\nprint(g(\"Hello, world!\"))<\/code><\/pre>\n
Running this code will print a string (and the function g<\/code> has a type hint saying it returns an integer) but the code passes static type checking!\nAfter all, we have that:<\/p>\n