Module 2: Functional programming II

Question 1

What are useful applications of higher-order functions?

Answer 1

• Function composition
• Decorators
• Currying
• Partial
• Closures

Question 2

What are Decorators?

Answer 2

Decorators take an existing function and add some functionality (or “decoration”) over it

Question 3

What is this code exemplifying?
def make_polite(func):
def inner():
print(“Hello, world! “,)
func()
return inner

@make_polite
def another_function():
print(“I am some other ordinary
function.”)

Answer 3

Decorator
The code is an example of a DECORATOR because it wraps another function (another_function) to modify its behavior without changing its code. The make_polite function adds a greeting before the original function’s output. Using @make_polite applies this modification, demonstrating a decorator’s purpose: to extend or alter a function’s behavior dynamically.

When you apply @make_polite to another_function, another_function gets wrapped by inner. Therefore, calling another_function() now actually calls inner(), which in turn does two things:

Prints “Hello, world!”
Calls the original another_function() content, printing “I am some other ordinary function.”

Question 4

Does a decorator modify the internal code of a function?

Answer 4

No, decorators add functionality but DON”T change the internal code of a functions thanks to function composition.
new function = decorator (original_function)

Original function is not changed and we keep the same interface.

Question 5

Why are decorators useful?

Answer 5

Useful to maintain and augment existing code that is already working!

Question 6

What are the phases when using decorators? Explain.

Answer 6

1. Wrap: at definition time, the decorator takes the original function and returns
   a new wrapped function
2. Evaluate: at evaluation time, the wrapping function usually calls the original
   function. The wrapping function can pre-process the argument values or
   post-process the return value (or both)

Question 7

What are some common scenarios in which decorators are useful?

Answer 7

• Logging
• Security
• Handling incomplete data

Question 8

How could you rewrite this multi-argument function?
f(a,b,c) = x

Answer 8

h = g(a)
i = h(b)
j = i(c) = x

or more compactly:
g(a)(b)(c)

Question 9

What is currying?

Answer 9

The process of turning multi-argument functions into a composition of single argument functions

Question 10

What is the natural way to implement currying?

Answer 10

Using decorators to add curry to the function

Question 11

What does currying allow us to do?

Answer 11

• Look at the intermediate steps of a function
• Create specialized functions

Question 12

What does currying rely on?

Answer 12

Function composition

Question 13

Why is currying interesting from a functional programming perspective?

Answer 13

• by separating one complex multi-argument function into single argument functions,
  we have simpler components: functions only have one input and one output
• functions are compatible with theoretical frameworks that only allow single argument
  functions (e.g. lambda calculus)

Question 14

What does Partial do?

Answer 14

With partial, we can call multi-argument functions with less arguments than they require, and obtain a specialized function with fixed arguments.

Question 15

What does Partial return?

Answer 15

Partial may return a (possibly multi-argument) function, or value

Question 16

What is the difference between currying and partial

Answer 16

Currying: Focus to create and return a single argument.
Partial: Can return a multi-argument function.

Question 17

Explain this code:
from functools import partial
def operation(x, y, z):
return x * (y + z)
doublesum = partial(operation, 2)
doublesum(3,1)

Answer 17

doublesum is now a more specialized function that always multiplies by 2.
Return 8

Question 18

What are Closures?

Answer 18

Closure is a function that remembers values

Question 19

What does this code show?
def outer_func():
pi = 3.14
def inner_func():
print(f”pi is : {pi}”)
return inner_func
f=outer_func()
f()

Answer 19

The outer_func function prints “pi is 3.14”

The pi variable is a nonlocal variable for the inner_func function.
This is closure!!

This code demonstrates the concept of closures in Python. A closure occurs when a nested function (here, inner_func) references a value in its enclosing scope (here, pi from outer_func), and Python allows the nested function to access that value even after the outer function has finished execution.

Question 20

Why are closures useful?

Answer 20

To avoid the use of global.

Question 21

What is Decorating?

Answer 21

• Wrapping a function to add some “decoration” (extra functionality) to it.
• Is is a form of composition.

Question 22

What is Currying?

Answer 22

• Procedure to convert a multi-argument function into a chain of single-argument functions
• The intermediate functions may be accessed for creation of specialized functions
• It relats to lambda calculus

Question 23

What are Partials?

Answer 23

• Runs a function with less arguments than declared in its signature
• Main application is the creation of specialized functions (i.e. functions tied to some values)
• Often mixed with currying

Question 24

What is a Closure?

Answer 24

A closure is a function that remembers and can access variables from the scope where it was created, even after that scope has finished executing.

Question 25

What design patterns can be used to create specialized functions?

Answer 25

• Currying
• Partial
• Closure