# ✓ Reducing Python Into Functional Core¶

We will look at the Python programming language, and identify how we can eliminate imperative parts of the language while still retaining its expressiveness.

## Selected parts of Python¶

### Variables¶

```
x = "Hello world"
x
```

```
'Hello world'
```

Variables are mutable in the sense that their values can change during the execution of the program.

```
x += ", everyone."
x
```

```
'Hello world, everyone.'
```

### Loop¶

```
i = 0
x = ""
while i < 3:
x += "*"
print(x)
i += 1
```

```
*
**
***
```

### Function declaration¶

A function can have arbitrary number of parameters.

```
def power(x, y):
result = 1
for i in range(y):
result *= x
return result
```

```
power(2, 8)
```

```
256
```

Python also support anonymous functions, called lambda functions.

```
(lambda x, y: x + y)(10, 20)
```

```
30
```

### Statements¶

A block is a sequence of statements which will be executed sequentially. This style of programming
is known as *procedural programming*.

```
x = 2
y = 10
z = power(x, y)
print("z =", z)
```

```
z = 1024
```

## Reducing Python¶

### No variables¶

We can do without variable assignments.

```
x = 1
y = 2
print(x + y)
```

```
3
```

```
def f(x, y):
print(x + y)
f(1,2)
```

```
3
```

### No loops¶

Since Python supports recursion, we can do without loops.

```
i = 0
x = ""
while i < 3:
x += "*"
print(x)
i += 1
```

```
*
**
***
```

```
def f(i, x):
if i < 3:
print(x)
f(i+1, x + "*")
f(0, "*")
```

```
*
**
***
```

### Unary functions¶

Did you know that we only need functions of a single variable? The trick to simulate functions with multiple parameters is called *currying* and *higher order functions*. Both concepts will be explored in greater detail.

```
def power(x, y):
result = 1
for i in range(y):
result *= x
return result
```

```
power(2, 10)
```

```
1024
```

```
def f(x):
def g(y):
if y == 0:
return 1
else:
return x * g(y-1)
return g
```

```
f(2)(10)
```

```
1024
```

### No statements¶

We can simulate procedural blocks without statements.

```
x = 1
y = 2
print(x + y)
```

```
3
```

```
(lambda x: (lambda y: print(x+y)))(1)(2)
```

```
3
```

## Summary¶

The minimal core programming constructs are:

Variable names as parameter names

Function declaration with a single variable

Function invocation

Data and

**functions**as return values and arguments

We are ready to formalize the core as a formal language known as *lambda calculus*.