CSCI-2041: Advanced Programming
Principles 2024 – 2025 CSCI-2041
Exam Quiz Review Questions with
Verified Solutions | 100% Pass
Guaranteed | Graded A+ |
Administrator
[COMPANY NAME] [Company address]
, Everyone, please use this to post items to help study for the
quiz Inductive Proofs
Program as Data
Lambda expressions :
Expressions as disjoint
unions are
Lazy evaluation
In programming language theory, lazy evaluation (call-by-need) is an
evaluation strategy which delays the evaluation of an expression until it
is needed and avoids the use of repeated evaluations.
Implementation: Can be used with streams. If tail is called several times,
the corresponding stream will be recomputed each time. This can be
solved by storing the result of the first evaluation of tail and reusing the
stored result instead of recomputing tail.
(* This is the
filter function
we wrote in
class.
It differs a bit from the one in the file "streams.ml".
*)
let rec filter (f: 'a -> bool) (s: 'a stream) : 'a
stream = match s with
| Cons (h, t) -> if f h then Cons (h, (fun () -> filter f (t
()))) else filter f (t ())
Most programming languages use eager evaluation (call-by-value).
Eager evaluation evaluates function arguments before calling
calling the function.
There are three evaluation strategies: call-by-value semantics, or eager
evaluation, call-by-name semantics, and lazy evaluation. We treat clauses in
function definitions as rewrite rules. The left hand sides are the patterns
that are searched for and the right hand sides replace the matched
pattern.
This study source was downloaded by 100000888893651 from CourseHero.com on 10-18-2024 16:54:51 GMT -05:00
https://www.coursehero.com/file/22686057/2041-Final-review/
Principles 2024 – 2025 CSCI-2041
Exam Quiz Review Questions with
Verified Solutions | 100% Pass
Guaranteed | Graded A+ |
Administrator
[COMPANY NAME] [Company address]
, Everyone, please use this to post items to help study for the
quiz Inductive Proofs
Program as Data
Lambda expressions :
Expressions as disjoint
unions are
Lazy evaluation
In programming language theory, lazy evaluation (call-by-need) is an
evaluation strategy which delays the evaluation of an expression until it
is needed and avoids the use of repeated evaluations.
Implementation: Can be used with streams. If tail is called several times,
the corresponding stream will be recomputed each time. This can be
solved by storing the result of the first evaluation of tail and reusing the
stored result instead of recomputing tail.
(* This is the
filter function
we wrote in
class.
It differs a bit from the one in the file "streams.ml".
*)
let rec filter (f: 'a -> bool) (s: 'a stream) : 'a
stream = match s with
| Cons (h, t) -> if f h then Cons (h, (fun () -> filter f (t
()))) else filter f (t ())
Most programming languages use eager evaluation (call-by-value).
Eager evaluation evaluates function arguments before calling
calling the function.
There are three evaluation strategies: call-by-value semantics, or eager
evaluation, call-by-name semantics, and lazy evaluation. We treat clauses in
function definitions as rewrite rules. The left hand sides are the patterns
that are searched for and the right hand sides replace the matched
pattern.
This study source was downloaded by 100000888893651 from CourseHero.com on 10-18-2024 16:54:51 GMT -05:00
https://www.coursehero.com/file/22686057/2041-Final-review/
