#lang racket

(define (double x l)
  (list* x x l))

'foldr
(foldr double '() '(1 (2 3) 4 5))

'foldl
(foldl double '() '(1 (2 3) 4 5))

'map
(map + '(10 20 30 40) '(1 2 3 4))

'filter
(filter pair? '(1 (2 3) 4 5 () (6 (7 8)) (9)))

'build-list
(build-list 5 values)

(build-list 5 (lambda (x) x))

(apply + (build-list 5 values))

"for variations"
(for/list ((i '(1 2 4 8 16)))
  i)

; Pairs up the elements, shortest sequence determines number of iterations
(for/list ((i '(1 2 4 8 16))
           (j '(1 3 9 27 81)))
  (+ (* 100 i) j))

; Treats as nested fors, like cartesian product
(for*/list ((i '(1 2 4 8 16))
            (j '(1 3 9 27 81)))
  (+ (* 100 i) j))

(for/fold ((sum 0)
           (product 1)
           (mmin 999999999)
           (mmax -999999999))
  ((i '(5 2 4 6 7 1 3)))
  (values (+ sum i) 
          (* product i) 
          (min mmin i)
          (max mmax i)))

'define-values
(define-values (out1 out2 out3 out4)
  (for/fold ((sum 0)
                 (product 1)
                 (mmin 999999999)
                 (mmax -999999999))
        ((i '(5 2 4 6 7 1 3)))
        (values (+ sum i) 
                (* product i) 
                (min mmin i)
                (max mmax i))))
out4
out3
out2
out1
" "
(define-values (a b c d) (values 11 22 33 44))
a
b
c
d