## Question 1 @ 2021-10-12 18:07

Which kinds of functions do we have in our current version of the Flang
language?

- First-order functions.
- First-class functions.
- Higher-order functions.
- Higher-class functions.
- None of the above, since our support for functions is premature.

## Question 2 @ 2021-10-12 18:09

Say that we use de-Bruijn indexes similar to what we’ve seen in class.
What would be the result of evaluating the following?

{with 5 {fun {+ [1] [0]}}}

- The expression is nonsensical, eg, it lacks a function argument
name.
- The result would be 6.
- The result would be a function, which will cause a runtime error
when called.
- The result is a function that returns its input plus 1.
- The result is a function that returns its input plus 5.

## Question 3 @ 2021-10-12 18:11

What is the main problem with our current Flang language
implementation?

- Our bindings are not handled correctly yet.
- Function calls are slow, so we need to change the
interpreter-based implementation into a compiler using de-Bruijn
indexes.
- Function calls are slow, corresponding to the function sizes.
- We’re missing a way to build object values.

## Question 4 @ 2021-10-12 18:13

We can drop the `with`

from Flang because we can replace any use:

{with {x V} B}

with

{call {fun {x} B} V}

Is this symmetric? — Could we similarly drop the `call`

+`fun`

and
manage with just `with`

?

- Of course not, we can express more ideas since we broke
`with`

into two independent features.
- Of course we can, we just need to do a similar substitution as
above, but in reverse.
- The question is nonsensical, because we cannot always replace
`with`

using `call`

+ `fun`

.
- Of course not, since any kind of such substitution loses the
original code and therefore the intended meaning that the programmer
had.