Turning a vector into a list and then into an image in Racket

Question

So, my brain is fried and in class we are working on Conway's Game of Life in DrRacket. This is an Intro to CS class so this is proving to be difficult for me, since coding is very new to me.

I have used lists in animation before but I am lost as to how to turn a vector into an image. Our prof gave us the hint of turning a vector into a list and then we should be able to create the image. I can turn the vector into a list but then I get lost. Any help, guidance or advice would be so greatly appreciated...greatly greatly appreciated.

This isn't all of the code, just a sample.

(define small-board (vector
                     (vector 1 0)
                     (vector 0 1))
  )

(define live-square (square 10 "solid" "blue"))
(define dead-square (square 10 "solid" "red"))

;Purpose: Create a function that turns board into an image
;Signature: Vector of Vectors -> Image
;Example
(check-expect (board->image small-board)
              (above (beside live-square dead-square)
                     (beside dead-square live-square))
              ) 

;Code
(define (board->image brd)
...

Answer 1

Since you can turn the 2d vector into a 2d list, I can show you how to turn the 2d list into an image.

(require 2htdp/image)

(define small-board (vector (vector 1 0) (vector 0 1)))
(define small-board-as-list (list (list 1 0) (list 0 1)))

(define live-square (square 10 "solid" "blue"))
(define dead-square (square 10 "solid" "red"))
(define MT empty-image)

Recur over the board and put every rendered row above the rest of the rendered board. Within a helper, recur over the row and put each rendered cell beside the rendered "rest" of the row.

; [List-of [List-of (U 1 0)]] -> Image
(define (board->image b)
  (cond [(empty? b) MT]
        [else (above (row->image (first b))
                     (board->image (rest b)))]))
; [List-of (U 1 0)] -> Image
(define (row->image r)
  (cond [(empty? r) MT]
        [else (beside (cell->image (first r))
                      (row->image (rest r)))]))

; Cell -> Image
(define (cell->image c)
  (if (= 1 c) live-square dead-square))

The recursive structure can be abstracted using foldr:

; [List-of [List-of (U 1 0)]] -> Image
(define (board->image-abs.v1 b)
  (foldr (λ (r b) (above (foldr (λ (c r) (beside (cell->image c) r)) MT r) b)) MT b))

We can also use map and apply

; [List-of [List-of (U 1 0)]] -> Image
(define (board->image-abs.v2 b)
  (apply above (map (λ (r) (apply beside (map (λ (c) (cell->image c)) r))) b)))

The result

(board->image small-board-as-list)
(board->image-abs.v1 small-board-as-list)
(board->image-abs.v2 small-board-as-list)