133 lines
4.8 KiB
Markdown
133 lines
4.8 KiB
Markdown
# Lab 10: Lazy Evaluation
|
|
|
|
*CSci 2041: Advanced Programming Principles, Spring 2017*
|
|
|
|
**Due:** Friday, March 31 at 5:00pm. You should be able to complete
|
|
this work during lab.
|
|
|
|
## Lab goals
|
|
Doing this lab should get you set up to work on the programming
|
|
portion of Homework 05 as some of the programming tasks in this lab
|
|
are similar to those in the homework.
|
|
|
|
## Getting started.
|
|
Copy the file ``streams.ml`` from the public class repository into a
|
|
new directory named ``Lab_10``. Name the copy of this file
|
|
``lab_10.ml``.
|
|
|
|
Add the following functions to the end of that file. But you should
|
|
clearly mark the parts of this file that you did not write and
|
|
attribute them to their author (your instructor) and then indicate
|
|
where your work starts in the file by adding you name and a comment to
|
|
this effect.
|
|
|
|
Read over the contents of this file and test out the various functions
|
|
by running them so that you understand how these streams work.
|
|
|
|
## Streams
|
|
Below you are asked to define a series of values (some are functional
|
|
values) that lead to the definition of ``str_105_nats`` of type
|
|
``string`` so that it prints out as seen in the following interaction
|
|
in utop:
|
|
```
|
|
utop # print_endline str_105_nats ;;
|
|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
|
|
11, 12, 13, 14, 15, 16, 17, 18, 19, 20
|
|
21, 22, 23, 24, 25, 26, 27, 28, 29, 30
|
|
31, 32, 33, 34, 35, 36, 37, 38, 39, 40
|
|
41, 42, 43, 44, 45, 46, 47, 48, 49, 50
|
|
51, 52, 53, 54, 55, 56, 57, 58, 59, 60
|
|
61, 62, 63, 64, 65, 66, 67, 68, 69, 70
|
|
71, 72, 73, 74, 75, 76, 77, 78, 79, 80
|
|
81, 82, 83, 84, 85, 86, 87, 88, 89, 90
|
|
91, 92, 93, 94, 95, 96, 97, 98, 99, 100
|
|
101, 102, 103, 104, 105
|
|
- : unit = ()
|
|
```
|
|
|
|
#### natural numbers as strings
|
|
|
|
First define a function ``str_from`` of type ``int -> string
|
|
stream``. This function has the same behavior as ``from`` defined in
|
|
``streams.ml`` except that the numbers are converted into strings.
|
|
|
|
For example, ``take 5 (str_from 10)`` should evaluate to the string
|
|
list ``["10"; "11"; "12"; "13"; "14"]``.
|
|
|
|
Next, define ``str_nats`` of type ``string stream``. It corresponds
|
|
to ``nats``.
|
|
|
|
The expression ``take 5 str_nats`` should evaluat to the string list
|
|
``["1"; "2"; "3"; "4"; "5"]``.
|
|
|
|
#### a stream of separator strings
|
|
In the output above, you'll notice that some numbers are separated by
|
|
a comma and a space and that others are separated by a newline. You
|
|
now need to define
|
|
the stream of strings that are these appropriate separator values.
|
|
|
|
Write a function ``separators`` with the type
|
|
``int -> string -> string stream``.
|
|
|
|
Let's call the first argument ``n`` and the second one ``sep``.
|
|
|
|
This function returns a stream of strings in which the first ``n``
|
|
elements of the stream are the string ``sep``, and the next one is
|
|
that string containing a single new line character, that is ("\n").
|
|
Then there are ``n`` more copies of ``sep`` before another string with
|
|
the newline character. This pattern repeats indefinitely.
|
|
|
|
For example, the expression
|
|
``take 10 (separators 2 "$$")`` will evaluate to the following string
|
|
list
|
|
```
|
|
["$$"; "$$"; "\n"; "$$"; "$$"; "\n"; "$$"; "$$"; "\n"; "$$"]
|
|
```
|
|
|
|
Keep in mind that the second input to ``take`` is a steam, not a
|
|
list. Only its output is a list.
|
|
|
|
When you look at the result of the test for this function in your
|
|
Feedback file on GitHub please note that the newline characters do not
|
|
appear in the sample output that your expression is supposed to match.
|
|
That output displays the values and the embedded newline characters
|
|
just create new lines. But Markdown does not treat newlines as
|
|
paragraph brakes so the strings just appear mashed together in the
|
|
output. Just make sure your output of this function looks correct.
|
|
|
|
|
|
Next define the value ``ten_per_line`` of type ``string stream`` that
|
|
can be used in the following functions to help create the output of
|
|
``str_105_nats`` seen above.
|
|
|
|
#### alternate
|
|
Next, write the function ``alternate`` that has the type
|
|
```
|
|
'a stream -> 'a stream -> 'a stream
|
|
|
|
```
|
|
and combines two streams into one by alternating their values. The
|
|
result of evaluating the expression ``take 10 (alternate nats (from
|
|
100))`` is the int list
|
|
```
|
|
[1; 100; 2; 101; 3; 102; 4; 103; 5; 104]
|
|
```
|
|
|
|
#### the string with 105 natural numbers
|
|
Finally, define ``str_105_nats`` that as type ``string`` and whose
|
|
value can be seen above.
|
|
|
|
To this you'll need to combine the functions and values you've defined
|
|
above, perhaps some from ``streams.ml``, and also either
|
|
``List.fold_left`` or ``List.fold_right`` to fold up some list of
|
|
strings (that originally came from ``str_nats`` and out of a call to
|
|
``separators``) into the single string seen above.
|
|
|
|
|
|
Note that the newline characters don't appear in the output in the
|
|
Feedback file on GitHub for the test for ``str_105_nats`` either.
|
|
Just make sure that your output looks like the example above
|
|
and that there are now extra spaces except as part of the
|
|
"comma and space" separator value passed into your function
|
|
``separators``.
|
|
|