It is a special type of curried function that can only combine functions with a single argument and a single return value. It enables "unary programming."

It takes two functions, f and g, and creates a new function that applies them from left-to-right (f then g). It enables a style called "function chaining."

It is a debugging tool that logs the input and output of a function without changing its behaviour. It enables a style called "transparent programming."

It takes multiple functions and runs them in parallel, merging their results. It enables a style called "asynchronous programming."

It takes two functions, f and g, and creates a new function that applies them from right-to-left (g then f). It enables tacit or point-free style programming.

Creating the Observable using a function like of() or range().

None of the options is correct.

Piping operators like map() or filter() to the Observable.

Calling the .subscribe() method on the Observable.

The JavaScript event loop automatically starts the stream.

A special function found only in Haskell and Lambda Calculus that cannot be implemented in languages like JavaScript.

A function, like compose, that must take at least two other functions as arguments.

A lambda expression or function that has no free variables.

A higher-order function that must be curried and always returns another function.

A function that combines two data streams into one, such as merge or zip.

Renaming a function's bound variables without changing its meaning (e.g. λx.x to λy.y)

A simplification rule where a function that does nothing but apply another expression to its argument can be replaced by that expression directly (e.g. λx.fx to f)

None of the options is correct.

Applying a function to its argument by substitution (e.g. (λx.x)y to y)

A rule that proves any lambda expression can be encoded as a number.

LazySequence is "push-based," and Observable is "pull-based."

None of the options is correct

LazySequence is "pull-based," and Observable is "push-based."

Both LazySequence and Observable are "push-based."

Both LazySequence and Observable are "pull-based."

3

None of the options is correct

1

A function f => f(2)(3)

2

It automatically handles functions with a variable number of arguments without extra code.

It ensures that all functions passed as arguments are pure.

None of the options is correct.

It improves performance by evaluating all arguments at once.

It allows for the creation of new, reusable functions by applying only a subset of the total arguments (partial application).

None of the options is correct.

Observable, Observable, Observable

[0, "A"], [1, "A"], [2, "A"], [0, "B"], [1, "B"], [2, "B"], [0, "C"], [1, "C"], [2, "C"]

["A", 0], ["A", 1], ["A", 2], ["B", 0], ["B", 1], ["B", 2], ["C", 0], ["C", 1], ["C", 2]

["A", 0], ["B", 0], ["C", 0], ["A", 1], ["B", 1], ["C", 1], ["A", 2], ["B", 2], ["C", 2]

It was used to directly create and remove SVG elements from the DOM, simplifying the updateView function.

It allowed the game to handle multiple user inputs simultaneously, which was not possible with map and filter alone.

It eliminated the dependency on an external, mutable state object by managing state transformations purely within the stream, making the logic self-contained.

It improved rendering performance by batching DOM updates instead of applying them one by one.

It provided the main game loop by replacing the interval(10) observable, which was causing performance issues.

Spread throughout the stream pipeline, with each operator performing a small DOM update.

Inside the scan operator, where the state and the view are updated together.

Inside the map operators, where input events are transformed into DOM update commands.

In a separate fromEvent stream that listens for a "render" event.

It is isolated entirely within the function passed to the final .subscribe() call.