;;; Return a list of pairs containing the elements of s.
    ;;;
    ;;; scm> (pair-up '(3 4 5 6 7 8))
    ;;; ((3 4) (5 6) (7 8))
    ;;; scm> (pair-up '(3 4 5 6 7 8 9))
    ;;; ((3 4) (5 6) (7 8 9))
    (define (pair-up s)
        (if (<= (length s) 3)
            (list s)
            (cons (list (car s) (car (cdr s))) (pair-up (cdr (cdr s))))
        ))

    (expect (pair-up '(3 4 5 6 7 8)) ((3 4) (5 6) (7 8)) )
    (expect (pair-up '(3 4 5 6 7 8 9)) ((3 4) (5 6) (7 8 9)) )

    (define (insert element lst index)
        (if (= index 0)
            (cons element lst)
            (cons (car lst) (insert element (cdr lst) (- index 1))))
    )

    (expect (insert 2 '(1 7 9) 2) (1 7 2 9))

    (expect (insert 'a '(b c) 0) (a b c))

(define (interleave lst1 lst2)
    (if (or (null? lst1) (null? lst2))
        (append lst1 lst2)
        (cons (car lst1)
                (cons (car lst2)
                    (interleave (cdr lst1) (cdr lst2)))))

; Alternate Solution 
    (cond 
        ((null? lst1) lst2)
        ((null? lst2) lst1)
        (else (cons (car lst1) (interleave lst2 (cdr lst1))))
    )
)

The base cases for both solutions (which are equivalent), follow directly from the spec. That is, if we run out of elements in one list, then we should simply append the remaining elements from the longer list.

The first solution constructs the interleaved list two elements at a time, by cons-ing together the first two elements of each list alongside the result of recursively calling interleave on the cdr's of both lists.

The second solution constructs the interleaved list one element at a time by swapping which list is passed in for lst1. Thus, we can then grab elements from only lst1 to construct the list.

Answer 1: (+ (* 3 4) 5)

Answer 2: (+ 1 (* 2 3))

Answer 3: (and (< 1 0) (/ 1 0))

1. We look at the if first

However, we do not evaluate if since it is a special form. Special forms are looked up and not evaluated (See Scheme Project). Given x = -2, we then evaluate the condition (< x 0):

1. As usual, we evaluate the operator first, then the operands
2. So we evaluate < and then we evaluate x and 0
3. (< -2 0) evaluates to true

Since the condition is true, we evaluate the return value (- x):

1. We evaluate the operator - and then we evaluate x
2. x evaluates to -2
3. Now we have (- -2) so this evaluates to 2.

Since the condition (< x 0) is true, the alternative (if (= x -2) 100 y) is not evaluated.
So, the elements that are evaluated in the process are: <, x, 0, -

    def print_evals(expr):
        """Print the expressions that are evaluated while evaluating expr.

        expr: a Scheme expression containing only (, ), +, *, and numbers.

        >>> nested_expr = Pair('+', Pair(Pair('*', Pair(3, Pair(4, nil))), Pair(5, nil)))
        >>> print_evals(nested_expr)
        (+ (* 3 4) 5)
        +
        (* 3 4)
        *
        3
        4
        5
        >>> print_evals(Pair('*', Pair(6, Pair(7, Pair(nested_expr, Pair(8, nil))))))
        (* 6 7 (+ (* 3 4) 5) 8)
        *
        6
        7
        (+ (* 3 4) 5)
        +
        (* 3 4)
        *
        3
        4
        5
        8
        """
        if not isinstance(expr, Pair):
            print(expr)
        else:
            print(expr)
            while expr is not nil:
                print_evals(expr.first)
                expr = expr.rest

(define (get-slicer a b)
  (define (slicer lst)
    (define (slicer-helper c i j)
      (cond 
        ((or (null? c) (<= j i)) nil)
        ((= i 0) (cons (car c) (slicer-helper (cdr c) i (- j 1))))
        (else (slicer-helper (cdr c) (- i 1) (- j 1)))))
    (slicer-helper lst a b))
  slicer)

; DOCTESTS (No need to modify)
(define a '(0 1 2 3 4 5 6))
(define one-two-three (get-slicer 1 4))
(define one-end (get-slicer 1 10))
(define zero (get-slicer 0 1))
(define empty (get-slicer 4 4))

(expect (one-two-three a) (1 2 3))
(expect (one-end a) (1 2 3 4 5 6))
(expect (zero a) (0))
(expect (empty a) ())