(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 
> flatten1 [[1;2];;;[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 [;;;...;[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 Exprepresenting 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 evaluatethat 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 Nonein 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 | ...
We value our customers and so we ensure that what we do is 100% original..
At Custom Writing, we believe in exemplary services that are fully geared toward customer satisfaction. That is why we don’t shy away from giving you the following guarantees;
Trusting us with your work is the best decision you have made, our pleasure lies in seeing you satisfied at 100%. If in the rear chance it happens that you are not satisfied, then know that we will equally not be satisfied. But worry not, our 30 days- Money back guarantee is all you need and that is what we promise you..Read more
We utilize profoundly equipped and gifted writers who produce unique papers liberated from any form of plagiarism. To guarantee this, we run all papers finished by our scholars through a Plagiarism checker to ensure uniqueness and originality. In any case, on the off chance that you have vulnerabilities about the originality or falsification of any paper we have finished and conveyed to you, please get in touch with us straight away. We will quickly investigate, and if the paper is seen as counterfeited, we will take suitable actions including but not limited to, revising the paper for free and in extreme cases we will activate the money back guarantee.Read more
We have an obligation deliver great and specially composed assignments. Our revision strategy endeavors to ensure total client satisfaction, comfort, and a genuine feelings of serenity. We make minor updates and corrections to the underlying request as part of our continuous assistance. However, revisions should just incorporate changes and alterations that were not effectively met, in the underlying request and that are inside the rules as per the current request structure..Read more
Our client's Data is an Integral part of our business but clearly, we are not in the business of offering our clients' very own data to others. We realize that you care how your online data is utilized and shared, we equally value your trust that we will do so cautiously and sensibly. We Promise to ensure the security of your own data during transmission by utilizing encryption conventions and programming. Likewise assist us with securing your information by not sharing your passwords and usernames.Read more
In submitting a request with us, you consent to the services we give. We will strive to take the necessary steps to convey a far reaching paper according to your prerequisites. Equally we depend on your cooperation to guarantee that we convey on this order.Read more