Scheme: Mutating elements in an array for chess

Question

I have been working on a simple chess program in Scheme, and one of the helper functions that I have defined consumes a piece, and its coordinates (current-location) and places it at specified coordinates (move-here) on the chess board, switching out any piece that may be located at the Move-here coordinates. The function was working as I had hoped, yet now for whatever reason it is no longer functioning properly. I have no idea what could be causing this, and have been tracing and re-tracing the code for a while now trying to find the bug. I am hoping someone may be able to shed light on the situation.

Here is the code for the piece-switching function, along with the structures used within the code:

(define-struct place (row column piece))
;; Place is a structure (make-place r c p) where r is the rank of a piece
;; which is a symbol of 'Pawn, 'Rook, 'Knight, 'Bishop, 'King or 'Queen
;; and column and place. Together c and p give the placement coordinates,
;; where column is one symbol from '(a b c d e f g h) and row is a number from 
;; 1 - 8 inclusive.

(define-struct piece (rank color))
;; Piece is a structure (make-piece r col) where rank is as described for a place   structure, 
;; and colour is a symbo either 'black or 'white.

(define move-counter 1) ; Keeps track of the current number of mves made.
;; Odd indicates white to move, else black to move.

;; Swap-in: '(Symbol Symbol Nat) '(Symbol Nat) -> '(-2- void)
;; Conditions:
;;   Pre: Swap-in is '(rank column row) From is '(column row)
;;   Post: produces list of lists containing -2- and void. where void represents
;;         any changed values.
;; Purpose: Swap-piece is a helper for any X-Move function that dictates the legal
;;          moves of a given piece.

(define (swap-piece swap-in from)
  (map (λ (x)
         (map (λ (piece)
                (cond
                  [(and (= (third swap-in) (place-row piece)) 
                        (symbol=? (second swap-in) (place-column piece)))
                   (set-place-piece! piece 
                                     (make-piece (first swap-in) (cond
                                                                   [(odd? move-counter)     'white]
                                                                   [else 'black])))]
                  [(and (= (second from) (place-row piece))
                        (symbol=? (first from) (place-column piece)))
                   (set-place-piece! piece (make-piece empty empty))]
                  [else void]))
              x)) 
       board))

Here are two examples; the first of which is what it outputs, and the second is what it should output (in the example, there is a small modification to Swap-piece so that one of its parameters is a board, as to not use the entire array I have for my chess board).

(define Example-board (list
                         (list
                          (make-place 8 'a (make-piece 'Rook 'black))
                          (make-place 7 'a (make-piece 'Pawn 'black)))
                         (list
                          (make-place 4 'a (make-piece 'Queen 'white))
                          (make-place 6 'b (make-piece 'King 'White))))) 

> (swap-piece '(Queen a 4) '(a 7) Example-board)
(shared ((-2- void)) (list (list -2- (void)) (list (void) -2-)))

So I call Example Board to get the updated board:

> Example-board
(list
 (list 
  (make-place 8 'a (make-piece 'Rook 'black)) 
  (make-place 7 'a (make-piece empty  empty)))
 (list 
  (make-place 4 'a (make-piece 'Queen 'white)) 
  (make-place 6 'b (make-piece 'King  'White))))

However, the output I expect is:

> Example-board
(list
 (list 
  (make-place 8 'a (make-piece 'Rook 'black)) 
  (make-place 7 'a (make-piece 'Queen 'white)))
 (list 
  (make-place 4 'a (make-piece empty empty)) 
  (make-place 6 'b (make-piece 'King  'White))))

Sorry, for the long post, however I just cannot figure out what is causing this to happen. As I said, I am sure this code was working just a few hours ago.

EDIT: I should add that the list, board, that the map function is acting on in my Swap-piece function is the chessboard.

Answer 1

I realised what was causing the incorrect piece placing/swapping. I had the swap part backwards, almost surely because I labelled my parameters incorrectly. My code basically said: "If the coordinates of the square I'm looking at are equal to the coordinates of the piece I am placing, don't change the square", which defeats the purpose of moving a piece, obviously. For anyone who is interested, the proper code is:

(define (swap-piece swap-in from)
  (map (λ (x)
         (map (λ (piece)
                (cond
                   ; comparing coordinates of current square to swap-in
                  [(and (= (third swap-in) (place-row piece)) 
                        (symbol=? (second swap-in) (place-column piece)))
                   ; If they are equal place, remove swap-in from that square
                   (set-place-piece! piece (make-piece empty empty))]
                   ; If the coordinates of the square equal the coordinates of From
                   ; place the swap-in piece there
                  [(and (= (second from) (place-row piece))
                        (symbol=? (first from) (place-column piece)))
                   (set-place-piece! piece 
                                     (make-piece (first swap-in) (cond
                                                                   [(odd? move-counter)  'white]
                                                                   [else 'black])))]
                  [else void]))
              x)) 
       board))