Magic square

#lang racket

; reduce
( define ( reduce op start-value l )
   ( cond
      ( ( null? l ) start-value )
      ( else ( op ( car l ) ( reduce op start-value ( cdr l ) ) ) )
    )
 )
; nth
(define (nth index list)
(cond
((= index 0) (car list))
(else (nth (- index 1) (cdr list)))))

; 2)
( define ( row index M )
   ( nth index M )
 )

; 3)
( define ( column index M )
   (map (lambda (row) ( nth index row )) M)
 )

; 4)
( define ( diagonal M )
   ( map ( lambda (index row) ( nth index row ) ) (range 0 (- (length (car M )) 0) ) M ) ; something is broken when -1 ; same sh*t with car
 )

( define ( secondary M )
   ( diagonal (transpose M ) )
)

; 5)
( define (transpose M)
   ( map ( lambda (index) (column index M) ) (range 0 (- (length M) 0) ) ) ; something is broken when -1
 )

( define ( sum-list row )
   ( reduce + 0 row )
 )

( define ( all? pred? l )
  ( reduce ( lambda ( x y ) ( and x y ) ) #t ( map pred? l ) )
 )

( define ( same? items )
  (all? (lambda(x)( equal? (car items) x) ) (cdr items))
)

( define ( sum-rows M )
   ( map ( lambda (x) ( sum-list x ) ) M )
 )

( define ( sum-diags M )
    ( list ( sum-list ( diagonal M ) ) ( sum-list ( secondary M ) ) )
 )

( define ( sum-cols M )
   ( sum-rows ( transpose M ) )
 )

( define ( magic-square? M )
   ( and ( same? ( sum-rows M ) ) ( same? ( sum-cols M ) ) ( same? ( sum-diags M ) ) )
 )