OCaml Code: Attached are images of the instructions. Below is the skeleton code that must be used to produce the example output. Make sure to use the skeleton code to add all the functions needed that is mentioned in the instructions attached. Make sure to attach screenshots of the code and output. I need to make sure the code works. streams.mltype 'a str = Cons of 'a * ('a stream) | Niland 'a stream = unit -> 'a str exception Subscriptexception Empty let head (s :'a stream) : 'a = match s () with Cons (hd,tl) -> hd | Nil -> raise Empty let tail (s :'a stream) : 'a stream = match s () with Cons (hd,tl) -> tl | Nil -> raise Empty let null (s : 'a stream) = match s () with Nil -> true | _ -> false let rec take (n: int) (s: 'a stream) : 'a list = match n with n when n > 0 -> head s :: take (n - 1) (tail s) | 0 -> [] | _ -> raise Subscript let rec nth (n: int) (s: 'a stream) : 'a = match n with n when n > 0 -> nth (n - 1) (tail s) | 0 -> head s | _ -> raise Subscriptlet rec map (f: 'a -> 'b) (s:'a stream) : 'b stream = fun () -> Cons (f (head s), map f (tail s)) let rec filter (s: 'a stream) (f: 'a -> bool) : 'a stream = if f (head s) then fun () -> Cons (head s, filter (tail s) f) else filter (tail s) flet rec sieve (s: int stream) : int stream = fun () -> Cons(head s, sieve (filter (tail s) (fun x -> x mod (head s) <> 0)))let rec fromn (n: int) = fun () -> Cons (n, fromn (n + 1))let rec fib n m = fun () -> Cons (n, fib m (n+m)) (* implement the streams and functions below *)let even : int -> bool = fun x -> truelet odd : int -> bool = fun x -> truelet squares : int stream = fun () -> Nillet fibs : int stream = fun () -> Nillet evenFibs : int stream = fun () -> Nillet oddFibs : int stream = fun () -> Nillet primes : int stream = fun () -> Nillet rev_zip_diff : 'a stream -> 'b stream -> ('b * 'a -> 'c) -> ('b * 'a * 'c) stream = fun a b f -> fun () -> Nillet rec printGenList : 'a list -> ('a -> unit) -> unit = fun l f -> () let rec printList : int list -> string -> unit = fun l f -> let oc = open_out f in close_out oc let rec printPairList : (int * int) list -> string -> unit = fun l f -> let oc = open_out f in close_out oc Example Output: even 2;;- : bool = trueeven 3;;- : bool = falseodd 2;;- : bool = falseodd 3;;- : bool = truetake 10 squares;;- : int list = [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]take 10 fibs;;- : int list = [0; 1; 1; 2; 3; 5; 8; 13; 21; 34]take 10 evenFibs;;- : int list = [0; 2; 8; 34; 144; 610; 2584; 10946; 46368; 196418]take 10 oddFibs;;- : int list = [1; 1; 3; 5; 13; 21; 55; 89; 233; 377]take 10 primes;;- : int list = [2; 3; 5; 7; 11; 13; 17; 19; 23; 29]take 5 (rev_zip_diff evenFibs oddFibs (fun (x,y) -> x - y));;- : (int * int * int) list =[(1, 0, 1); (1, 2, -1); (3, 8, -5); (5, 34, -29); (13, 144, -131)]printGenList ["how"; "the"; "turntables"] (fun s -> print_string (s ^ " "));;how the turntables - : unit = ()printList [2; 4; 6; 8] "printList.txt";; (* "2 4 6 8 " *)printPairList [(2, 1); (3, 2); (4, 3)] "printPairList.txt";; (* "(2, 1) (3, 2) (4, 3) " *) To start, write a function called even which returns true if the integer argument is even, false oth-erwise. Write a function called odd which returns true if the integer argument is odd, false otherwise.Now create five streams: squares, fibs, evenFibs, oddFibs, and primes. squares contains thesequence of perfect squares starting from 1. You may find the map function helpful to create sucha stream. Then, create a stream called fibs that contains the Fibonacci sequence. evenFibs andoddFibs are similar but they only contain the even Fibonacci numbers and odd Fibonacci numbers,respectively. The last stream is primes, which has the sequence of prime numbers.Write a function called rev_zip_diff which will zip together two streams in reverse order (hint:take a look at how the zip function works that we went over in class) and leverage an arbitrarydifference function to obtain the difference of every two elements. rev_zip_diff should have thefollowing type signature:val zip'a stream -> 'b stream -> ('b* 'a -> 'c) -> ('b * 'a * 'c) streamYou may wish to test rev_zip_diff by zipping together evenFibs and oddFibs and a functionthat gets the integer difference, and then create a concrete list with the take function.4 Generalized PrintingYou are tasked with creating generalized list printing functions. Write a function called print GenListwhich takes a list and a printing function f and applies the function to each element of the listrecursively. The function should have the following type signature:val printGenList : 'a list -> ('a -> unit) -> unitCreate a function called printList that will pretty print an integer list. You will find the stringconcatenation operator (^) and the string_of_int function useful. printList will take an integer list followed by a string. The string is the name of the output file that you will write the listto. This function should leverage printGenList and provide an anonymous function (the fun ...->... construct) that will do the appropriate pretty printing to the output file. This anonymousfunction should print the element of the list and then a space character. printList should have thefollowing type signature:val printList: int list -> string -> unitCreate a function called printPairList that will pretty print a list consisting of integer pairs.The function will take an (int *int) list followed by a string. The string is the name of theoutput file that you will write the list to. printPairList should leverage print GenList andprovide an anonymous function (the fun ->... construct) that will do the appropriatepretty printing. This anonymous function should print an open parenthesis, the first element ofthe pair, a comma, a space, the second element of the pair, and then a close parenthesis followedby a space. printPairList should have the following type signature:val printPairList : (int int) list -> string -> unit

OCaml Code: Attached are images of the instructions. Below is the skeleton code that must be used to produce the example output. Make sure to use the skeleton code to add all the functions needed that is mentioned in the instructions attached. Make sure to attach screenshots of the code and output. I need to make sure the code works. streams.ml type 'a str = Cons of 'a * ('a stream) | Nil and 'a stream = unit -> 'a str exception Subscript exception Empty let head (s :'a stream) : 'a = match s () with Cons (hd,tl) -> hd | Nil -> raise Empty let tail (s :'a stream) : 'a stream = match s () with Cons (hd,tl) -> tl | Nil -> raise Empty let null (s : 'a stream) = match s () with Nil -> true | _ -> false let rec take (n: int) (s: 'a stream) : 'a list = match n with n when n > 0 -> head s :: take (n - 1) (tail s) | 0 -> [] | _ -> raise Subscript let rec nth (n: int) (s: 'a stream) : 'a = match n with n when n > 0 -> nth (n - 1) (tail s) | 0 -> head s | _ -> raise Subscript let rec map (f: 'a -> 'b) (s:'a stream) : 'b stream = fun () -> Cons (f (head s), map f (tail s)) let rec filter (s: 'a stream) (f: 'a -> bool) : 'a stream = if f (head s) then fun () -> Cons (head s, filter (tail s) f) else filter (tail s) f let rec sieve (s: int stream) : int stream = fun () -> Cons(head s, sieve (filter (tail s) (fun x -> x mod (head s) <> 0))) let rec fromn (n: int) = fun () -> Cons (n, fromn (n + 1)) let rec fib n m = fun () -> Cons (n, fib m (n+m)) (* implement the streams and functions below *) let even : int -> bool = fun x -> true let odd : int -> bool = fun x -> true let squares : int stream = fun () -> Nil let fibs : int stream = fun () -> Nil let evenFibs : int stream = fun () -> Nil let oddFibs : int stream = fun () -> Nil let primes : int stream = fun () -> Nil let rev_zip_diff : 'a stream -> 'b stream -> ('b * 'a -> 'c) -> ('b * 'a * 'c) stream = fun a b f -> fun () -> Nil let rec printGenList : 'a list -> ('a -> unit) -> unit = fun l f -> () let rec printList : int list -> string -> unit = fun l f -> let oc = open_out f in close_out oc let rec printPairList : (int * int) list -> string -> unit = fun l f -> let oc = open_out f in close_out oc Example Output: even 2;; - : bool = true even 3;; - : bool = false odd 2;; - : bool = false odd 3;; - : bool = true take 10 squares;; - : int list = [1; 4; 9; 16; 25; 36; 49; 64; 81; 100] take 10 fibs;; - : int list = [0; 1; 1; 2; 3; 5; 8; 13; 21; 34] take 10 evenFibs;; - : int list = [0; 2; 8; 34; 144; 610; 2584; 10946; 46368; 196418] take 10 oddFibs;; - : int list = [1; 1; 3; 5; 13; 21; 55; 89; 233; 377] take 10 primes;; - : int list = [2; 3; 5; 7; 11; 13; 17; 19; 23; 29] take 5 (rev_zip_diff evenFibs oddFibs (fun (x,y) -> x - y));; - : (int * int * int) list = [(1, 0, 1); (1, 2, -1); (3, 8, -5); (5, 34, -29); (13, 144, -131)] printGenList ["how"; "the"; "turntables"] (fun s -> print_string (s ^ " "));; how the turntables - : unit = () printList [2; 4; 6; 8] "printList.txt";; (* "2 4 6 8 " *) printPairList [(2, 1); (3, 2); (4, 3)] "printPairList.txt";; (* "(2, 1) (3, 2) (4, 3) " *)

OCaml Code: Attached are images of the instructions. Below is the skeleton code that must be used to produce the example output. Make sure to use the skeleton code to add all the functions needed that is mentioned in the instructions attached. Make sure to attach screenshots of the code and output. I need to make sure the code works. streams.ml type 'a str = Cons of 'a * ('a stream) | Nil and 'a stream = unit -> 'a str exception Subscript exception Empty let head (s :'a stream) : 'a = match s () with Cons (hd,tl) -> hd | Nil -> raise Empty let tail (s :'a stream) : 'a stream = match s () with Cons (hd,tl) -> tl | Nil -> raise Empty let null (s : 'a stream) = match s () with Nil -> true | _ -> false let rec take (n: int) (s: 'a stream) : 'a list = match n with n when n > 0 -> head s :: take (n - 1) (tail s) | 0 -> [] | _ -> raise Subscript let rec nth (n: int) (s: 'a stream) : 'a = match n with n when n > 0 -> nth (n - 1) (tail s) | 0 -> head s | _ -> raise Subscript let rec map (f: 'a -> 'b) (s:'a stream) : 'b stream = fun () -> Cons (f (head s), map f (tail s)) let rec filter (s: 'a stream) (f: 'a -> bool) : 'a stream = if f (head s) then fun () -> Cons (head s, filter (tail s) f) else filter (tail s) f let rec sieve (s: int stream) : int stream = fun () -> Cons(head s, sieve (filter (tail s) (fun x -> x mod (head s) <> 0))) let rec fromn (n: int) = fun () -> Cons (n, fromn (n + 1)) let rec fib n m = fun () -> Cons (n, fib m (n+m)) (* implement the streams and functions below ) let even : int -> bool = fun x -> true let odd : int -> bool = fun x -> true let squares : int stream = fun () -> Nil let fibs : int stream = fun () -> Nil let evenFibs : int stream = fun () -> Nil let oddFibs : int stream = fun () -> Nil let primes : int stream = fun () -> Nil let rev_zip_diff : 'a stream -> 'b stream -> ('b 'a -> 'c) -> ('b * 'a * 'c) stream = fun a b f -> fun () -> Nil let rec printGenList : 'a list -> ('a -> unit) -> unit = fun l f -> () let rec printList : int list -> string -> unit = fun l f -> let oc = open_out f in close_out oc let rec printPairList : (int * int) list -> string -> unit = fun l f -> let oc = open_out f in close_out oc Example Output: even 2;; - : bool = true even 3;; - : bool = false odd 2;; - : bool = false odd 3;; - : bool = true take 10 squares;; - : int list = [1; 4; 9; 16; 25; 36; 49; 64; 81; 100] take 10 fibs;; - : int list = [0; 1; 1; 2; 3; 5; 8; 13; 21; 34] take 10 evenFibs;; - : int list = [0; 2; 8; 34; 144; 610; 2584; 10946; 46368; 196418] take 10 oddFibs;; - : int list = [1; 1; 3; 5; 13; 21; 55; 89; 233; 377] take 10 primes;; - : int list = [2; 3; 5; 7; 11; 13; 17; 19; 23; 29] take 5 (rev_zip_diff evenFibs oddFibs (fun (x,y) -> x - y));; - : (int * int * int) list = [(1, 0, 1); (1, 2, -1); (3, 8, -5); (5, 34, -29); (13, 144, -131)] printGenList ["how"; "the"; "turntables"] (fun s -> print_string (s ^ " "));; how the turntables - : unit = () printList [2; 4; 6; 8] "printList.txt";; (* "2 4 6 8 " ) printPairList [(2, 1); (3, 2); (4, 3)] "printPairList.txt";; ( "(2, 1) (3, 2) (4, 3) " *)

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Related questions

Question

streams.ml

type 'a str = Cons of 'a * ('a stream) | Nil
and 'a stream = unit -> 'a str

exception Subscript
exception Empty

let head (s :'a stream) : 'a =
match s () with
Cons (hd,tl) -> hd
| Nil -> raise Empty

let tail (s :'a stream) : 'a stream =
match s () with
Cons (hd,tl) -> tl
| Nil -> raise Empty

let null (s : 'a stream) =
match s () with
Nil -> true
| _ -> false

let rec take (n: int) (s: 'a stream) : 'a list =
match n with
n when n > 0 -> head s :: take (n - 1) (tail s)
| 0 -> []
| _ -> raise Subscript

let rec nth (n: int) (s: 'a stream) : 'a =
match n with
n when n > 0 -> nth (n - 1) (tail s)
| 0 -> head s
| _ -> raise Subscript

let rec map (f: 'a -> 'b) (s:'a stream) : 'b stream =
fun () -> Cons (f (head s), map f (tail s))

let rec filter (s: 'a stream) (f: 'a -> bool) : 'a stream =
if f (head s)
then fun () -> Cons (head s, filter (tail s) f)
else filter (tail s) f

let rec sieve (s: int stream) : int stream =
fun () -> Cons(head s, sieve (filter (tail s) (fun x -> x mod (head s) <> 0)))

let rec fromn (n: int) = fun () -> Cons (n, fromn (n + 1))
let rec fib n m = fun () -> Cons (n, fib m (n+m))

(* implement the streams and functions below *)

let even : int -> bool = fun x -> true
let odd : int -> bool = fun x -> true

let squares : int stream = fun () -> Nil
let fibs : int stream = fun () -> Nil
let evenFibs : int stream = fun () -> Nil
let oddFibs : int stream = fun () -> Nil
let primes : int stream = fun () -> Nil

let rev_zip_diff : 'a stream -> 'b stream -> ('b * 'a -> 'c) -> ('b * 'a * 'c) stream =
fun a b f -> fun () -> Nil

let rec printGenList : 'a list -> ('a -> unit) -> unit =
fun l f -> ()

let rec printList : int list -> string -> unit =
fun l f ->
let oc = open_out f in
close_out oc

let rec printPairList : (int * int) list -> string -> unit =
fun l f ->
let oc = open_out f in
close_out oc

Example Output:

even 2;;
- : bool = true
even 3;;
- : bool = false
odd 2;;
- : bool = false
odd 3;;
- : bool = true
take 10 squares;;
- : int list = [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]
take 10 fibs;;
- : int list = [0; 1; 1; 2; 3; 5; 8; 13; 21; 34]
take 10 evenFibs;;
- : int list = [0; 2; 8; 34; 144; 610; 2584; 10946; 46368; 196418]
take 10 oddFibs;;
- : int list = [1; 1; 3; 5; 13; 21; 55; 89; 233; 377]
take 10 primes;;
- : int list = [2; 3; 5; 7; 11; 13; 17; 19; 23; 29]
take 5 (rev_zip_diff evenFibs oddFibs (fun (x,y) -> x - y));;
- : (int * int * int) list =
[(1, 0, 1); (1, 2, -1); (3, 8, -5); (5, 34, -29); (13, 144, -131)]
printGenList ["how"; "the"; "turntables"] (fun s -> print_string (s ^ " "));;
how the turntables - : unit = ()
printList [2; 4; 6; 8] "printList.txt";; (* "2 4 6 8 " *)
printPairList [(2, 1); (3, 2); (4, 3)] "printPairList.txt";; (* "(2, 1) (3, 2) (4, 3) " *)

To start, write a function called even which returns true if the integer argument is even, false oth-
erwise. Write a function called odd which returns true if the integer argument is odd, false otherwise.
Now create five streams: squares, fibs, evenFibs, oddFibs, and primes. squares contains the
sequence of perfect squares starting from 1. You may find the map function helpful to create such
a stream. Then, create a stream called fibs that contains the Fibonacci sequence. evenFibs and
oddFibs are similar but they only contain the even Fibonacci numbers and odd Fibonacci numbers,
respectively. The last stream is primes, which has the sequence of prime numbers.
Write a function called rev_zip_diff which will zip together two streams in reverse order (hint:
take a look at how the zip function works that we went over in class) and leverage an arbitrary
difference function to obtain the difference of every two elements. rev_zip_diff should have the
following type signature:
val zip
'a stream -> 'b stream -> ('b* 'a -> 'c) -> ('b * 'a * 'c) stream
You may wish to test rev_zip_diff by zipping together evenFibs and oddFibs and a function
that gets the integer difference, and then create a concrete list with the take function.
4 Generalized Printing
You are tasked with creating generalized list printing functions. Write a function called print GenList
which takes a list and a printing function f and applies the function to each element of the list
recursively. The function should have the following type signature:
val printGenList : 'a list -> ('a -> unit) -> unit
Create a function called printList that will pretty print an integer list. You will find the string
concatenation operator (^) and the string_of_int function useful. printList will take an integer

list followed by a string. The string is the name of the output file that you will write the list
to. This function should leverage printGenList and provide an anonymous function (the fun ...
->... construct) that will do the appropriate pretty printing to the output file. This anonymous
function should print the element of the list and then a space character. printList should have the
following type signature:
val printList: int list -> string -> unit
Create a function called printPairList that will pretty print a list consisting of integer pairs.
The function will take an (int *int) list followed by a string. The string is the name of the
output file that you will write the list to. printPairList should leverage print GenList and
provide an anonymous function (the fun ->... construct) that will do the appropriate
pretty printing. This anonymous function should print an open parenthesis, the first element of
the pair, a comma, a space, the second element of the pair, and then a close parenthesis followed
by a space. printPairList should have the following type signature:
val printPairList : (int int) list -> string -> unit

Expert Solution

Trending now

This is a popular solution!

Step by step

Solved in 3 steps

SEE SOLUTION Check out a sample Q&A here

Follow-up Questions

Read through expert solutions to related follow-up questions below.

Follow-up Question

What the hell is this? You just copied the skeleton code given. Please read the instructions and make sure to produce the example output. Make sure to give the correct code and include screenshots of the example output. I included the instructions again.

Solution

by Bartleby Expert

SEE SOLUTION

Knowledge Booster

Learn more about

Need a deep-dive on the concept behind this application? Look no further. Learn more about this topic, computer-science and related others by exploring similar questions and additional content below.