(define (solve-8-queens)

  (define (num-range start end)
  (map num (range start (+ end 1))))

  (define (1-to-8o sequence x)
    (fresh (head tail)
         (== sequence (cons head tail))
         (conde [(== x head)]
                [(1-to-8o tail x)])))

  (define (safeo sequence x index result)
    (conde [(== sequence empty) (== result #t)]
           [(fresh (head tail head-x x-head index2)
                   (== sequence (cons head tail))
                   (conde [(== x head) (== result #f)]
                          (conde
                            [(<=o x head) (minuso head x head-x) (== head-x index) (== result #f)]
                            [(<=o head x) (minuso x head x-head) (== x-head index) (== result #f)])
                          [(minuso index (num 1) index2) (safeo tail x index2 result)]))]))

  (pretty-print (run* (q) (fresh (a b c d e f g h)
                                 [1-to-8o (num-range 1 8) a]

                                 [1-to-8o (num-range 1 8) b]
                                 [safeo (list a) b (num 1) #t]

                                 [1-to-8o (num-range 1 8) c]
                                 [safeo (list a b) c (num 2) #t]

                                 [1-to-8o (num-range 1 8) d]
                                 [safeo (list a b c) d (num 3) #t]

                                 [1-to-8o (num-range 1 8) e]
                                 [safeo (list a b c d) e (num 4) #t]

                                 [1-to-8o (num-range 1 8) f]
                                 [safeo (list a b c d e) f (num 5) #t]

                                 [1-to-8o (num-range 1 8) g]
                                 [safeo (list a b c d e f) g (num 6) #t]

                                 [1-to-8o (num-range 1 8) h]
                                 [safeo (list a b c d e f g) h (num 7) #t]

                                 [== (list a b c d e f g h) q]))))

(solve-8-queens)