Two powerful `List` functions provided by F# are `List.fold` and `List.foldBack`. These are similar to `List.reduce` and `List.reduceBack`, but more general. Both take a binary function `f`, an initial value `i`, and a list `[x1;x2;x3;...;xn]`. Then `List.fold `returns

(f ... (f (f (f i x1) x2) x3) ... xn)

while `List.foldBack `returns

(f x1 (f x2 (f x3 ... (f xn i) ... )))

In spite of this complicated behavior, they can be implemented very simply:

> let rec fold f a = function | [] -> a | x::xs -> fold f (f a x) xs;; val fold : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a > let rec foldBack f xs a = match xs with | [] -> a | y::ys -> f y (foldBack f ys a);; val foldBack : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b

(Note that they don’t take their arguments in the same order.)

Each of these functions can be used to implement `flatten`, which “flattens” a list of lists:

let flatten1 xs = List.fold (@) [] xs let flatten2 xs = List.foldBack (@) xs []

For example,

> flatten1 [[1;2];[];[3];[4;5;6]];; val it : int list = [1; 2; 3; 4; 5; 6]

Compare the efficiency of `flatten1 xs` and `flatten2 xs`, both in terms of *asymptotic time compexity* and *experimentally*. To make the analysis simpler, assume that `xs` is a list of the form `[[1];[2];[3];...;[n]]`.

E -> n | -E | E + E | E - E | E * E | E / E | (E)

In the above, `n` is an integer literal, `-E` is the negation of `E`, the next four terms are the sum, difference, product, and quotient of expressions, and `(E)` is used to control the order of evaluation of expressions, as in the expression `3*(5-1)`.

Rather than working directly with the concrete syntax above, we will imagine that we have a parser that parses input into an *abstract syntax tree*, as is standard in real compilers. Hence your interpreter will take an input of the following discriminated union type:

type Exp = Num of int | Neg of Exp | Sum of Exp * Exp | Diff of Exp * Exp | Prod of Exp * Exp | Quot of Exp * Exp

Note how this definition mirrors the grammar given above. For instance, the constructor `Num` makes an integer into an `Exp`, and the constructor `Sum` makes a pair of `Exp`‘s into an `Exp`representing their sum. Interpreting abstract syntax trees is much easier than trying to interpret concrete syntax directly. Note that there is no need for a constructor corresponding to parentheses, as the example given above would simply be represented by

Prod(Num 3, Diff(Num 5, Num 1))

which represents the parse tree which looks like

Your job is to write an F# function `evaluate`that takes an abstract syntax tree and returns the result of evaluating it. Most of the time, evaluating a tree will produce an integer, but we must address the possibility of dividing by zero. This could be handled by raising an exception, but instead we choose to make use of the built-in F# type

type 'a option = None | Some of 'a

Thus `evaluate` will have type `Exp -> int option`, allowing it to return `Some m` in the case of a successful evaluation, and `None`in the case of an evaluation that fails due to dividing by zero. For example,

> evaluate (Prod(Num 3, Diff(Num 5, Num 1)));; val it : int option = Some 12 > evaluate (Diff(Num 3, Quot(Num 5, Prod(Num 7, Num 0))));; val it : int option = None

Naturally, `evaluate e` should use recursion to evaluate each of `e`‘s sub-expressions; it should also use `match` to distinguish between the cases of successful or failed sub-evaluations. To get you started, here is the beginning of the definition of `evaluate`:

let rec evaluate = function | Num n -> Some n | Neg e -> match evaluate e with | ...

The price is based on these factors:

Academic level

Number of pages

Urgency

Basic features

- Free title page and bibliography
- Unlimited revisions
- Plagiarism-free guarantee
- Money-back guarantee
- 24/7 support

On-demand options

- Writer’s samples
- Part-by-part delivery
- Overnight delivery
- Copies of used sources
- Expert Proofreading

Paper format

- 275 words per page
- 12 pt Arial/Times New Roman
- Double line spacing
- Any citation style (APA, MLA, Chicago/Turabian, Harvard)

Delivering a high-quality product at a reasonable price is not enough anymore.

That’s why we have developed 5 beneficial guarantees that will make your experience with our service enjoyable, easy, and safe.

You have to be 100% sure of the quality of your product to give a money-back guarantee. This describes us perfectly. Make sure that this guarantee is totally transparent.

Read moreEach paper is composed from scratch, according to your instructions. It is then checked by our plagiarism-detection software. There is no gap where plagiarism could squeeze in.

Read moreThanks to our free revisions, there is no way for you to be unsatisfied. We will work on your paper until you are completely happy with the result.

Read moreYour email is safe, as we store it according to international data protection rules. Your bank details are secure, as we use only reliable payment systems.

Read moreBy sending us your money, you buy the service we provide. Check out our terms and conditions if you prefer business talks to be laid out in official language.

Read more
## Recent Comments