Python

I am including the full text of the post

Despite not being a pure functional language, a lot of praise that python receives are for features that stem from functional paradigms. Many are second nature to python programmers, but over the years I have seen people miss out on some important features. I gathered a few, along with examples, to give a brief demonstration of the convenience they can bring.

Replace if/else with or

With values that might be None, you can use or instead of if/else to provide a default. I had used this for years with Javascript, without knowing it was also possible in Python.

def get_greeting_prefix(user_title: str | None):
	if user_title:
		return user_title
	return ""

Above snippet can shortened to this:

def get_greeting_prefix(user_title: str | None):
	return user_title or ""

Pattern Matching and Unpacking

The overdue arrival of match to python means that so many switch style statements are expressed instead with convoluted if/else blocks. Using match is not even from the functional paradigm, but combining it with unpacking opens up new possibilities for writing more concise code.

Let's start by looking at a primitive example of unpacking. Some libraries have popularised use of [a, b] = some_fun(), but unpacking in python is much powerful than that.

[first, *mid, last] = [1, 2, 3, 4, 5]
# first -> 1, mid -> [2, 3, 4], last -> 5

Matching Lists

Just look at the boost in readability when we are able to name and extract relevant values effortlessly:

def sum(numbers: [int]):
	if len(numbers) == 0:
		return 0
	else:
		return numbers[0] + sum(numbers[1:])

def sum(numbers: [int]):
	match numbers:
		case []:
			return 0
		case [first, *rest]:
			return first + sum(rest)

Matching Dictionaries

Smooth, right? We can go even further with dictionaries. This example is not necessarily better than its if/else counterpart, but I will use it for the purpose of demonstrating the functionality.

sample_country = {"economic_zone": "EEA", "country_code": "AT"}

def determine_tourist_visa_requirement(country: dict[str, str]):
	match country:
		case {"economic_zone": "EEA"}:
			return "no_visa"
		case {"country_code": code} if code in tourist_visa_free_countries:
			return "non_tourist_visa_only"
		case default:
			return "visa_required"		

Matching Dataclasses

Let’s write a function that does a primitive calculation of an estimated number of days for shipment

@dataclass
class Address:
	street: str
	zip_code: str
	country_code: str

def calculate_shipping_estimate(address: Address) -> int:
	match address:
		case Address(zip_code=zc) if close_to_warehouse(zc):
			return 1
		case Address(country_code=cc) if cc in express_shipping_countries:
			return 2
		case default:
			return provider_estimate(city.coordinates)

Comprehensions

List comprehensions get their deserved spotlight, but I’ve seen cases where dictionary comprehension would’ve cut multiple lines. You can look at examples on this page on python.org