Day 15 - Variables and loops

Date: October 15, 2026

⚠️Homework

Homework 5 due October 18, 2026

‼️Ending Skills

Last week for skills: 1

Skills: 3

Pre-reading: 9.1.8.5 (except 9.1.8.5.4)

Supplementary Videos

Variables and Loops

Intro (15 mins)

• To design our own list processing functions, we need a way to do computations for each element in the list. There are multiple ways to do that, today we will show iteration with for each().
• This requires being able to modify variables, which in Pyret means they must be declared with var, and must be updated with the special operator :=.
• The pattern is:

  var my-var = initial-value
  for each(my-elt from my-list):
    code
    to
    handle
    my-elt
    and update
    my-var
  end
  my-var # final result

• Example: while sum is built in, we could have designed it ourselves as:

  fun my-sum(num-list :: List<Number>) -> Number block:
    var total = 0
    for each(n from num-list):
      total := total + n
    end
    total
  where:
    my-sum([list: 0, 1, 2, 3]) is 6
  end

• Note that any function that has multiple expressions (aside from definitions), as my-sum does (the for each loop and the total variable at the end) must be declared as a block; otherwise Pyret signals an error, given that unless the first expression changes something, it will be ignored, and thus is possible an indication of a mistake. e.g., if I write:

  fun my-fun(x :: Number):
    1 + x
    2
  end

  Because I accidentally hit the return/enter key instead of the + (intending the body to be 1 + x + 2), if Pyret accepted this, the function would always return 2, ignoring the 1 + x entirely. If I truely wanted that behavior, I would need to add block, as:

  fun my-fun(x :: Number) block:
    1 + x
    2
  end

  Using block conveys to Pyret that I expect there to be multiple expressions, with only the last one returned. In this case, it is pointless, but if the earlier expressions (as in my-sum) modify the variable that is to be returned, this makes sense.

Class Exercises (40 mins)

1. Design your own product function that takes a list of numbers and returns their product (multiply all of them together).
2. Design a function sum-even-numbers that takes a list of integers and adds up only the even numbers -- the rest should be ignored (num-modulo may be helpful)!
3. Design a function my-length that takes a list of any value and returns the number of elements in the list.
4. Design a function any-negative that takes a list of numbers and returns true if there is at least one negative number in the list, false otherwise.
5. Design a function all-short-words that takes a list of strings and returns true if every word has 4 or fewer characters, false otherwise.
6. Design a function reverse-list that takes a list and returns a new list with all the elements in reverse order. You'll need to build up the result by adding each element to the front of your accumulator list (push may be helpful).
7. Design a function concat-all that takes a list of strings and concatenates them all together into one string (with no separator between them).

Wrap-up (5 mins)

• Mutable variables can be declared with var and updated with :=.
• for each can run code for each element of a list; combined with mutable variables, this allows writing custom list operations.