(import (prefix (chicken sort) og-))

(import sequences)

(define (sense x) x)

(define
  (sense
   (? (fn (and
	 (not (##sys#immediate? x))
	 (##sys#structure? x (##sys#slot x 0))))
    x))
  (map (c ##sys#slot x) (iota (sub1 (##sys#size x)) 1)))

(define (sense (? hash-table? x)) (hash-table->alist x))
(define (sense (? (disjoin call-table? call-table*? call-vector? call-string? call-list? call-record?) x)) (x))
(define (sense (? procedure? x)) (procedure-information x))
(define (sense (? boolean? x)) (if x "#t" "#f"))
(define (sense (? symbol? x)) (symbol->string x))
(define (sense (? (conjoin (o not list?) pair?) x)) (list (car x) (cdr x)))

(define (ascending? (= sense a) (= sense b)) (ascending? a b))
(define (ascending? (? char? a) (? char? b)) (char-ci<? a b))
(define (ascending? (? number? a) (? number? b)) (< a b))
(define (ascending? (? number? n) (? char? c)) #t)
(define (ascending? (? char? c) (? number? n)) #f)

(define (ascending? (? sequence? a) b)
  (if (empty? a) #t (ascending? (peek a) b)))

(define (ascending? a (? sequence? b))
  (if (empty? b) #f (ascending? a (peek b))))

(define (ascending? (? sequence? a) (? sequence? b))
  (cond ((empty? a) #t)
	((empty? b) #f)
	((ascending? (peek a) (peek b)) #t)
	((ascending? (peek b) (peek a)) #f)
	(else (ascending? (pop a) (pop b)))))

(define (sort seq) ((as-list sort) seq))
(define (sort (? list? lis)) (og-sort lis ascending?))
(define (sort a b) ((as-list (fn (og-sort x b))) a))
(define (sort (? list? a) b) (og-sort a b))
(define (sorta . args) (sort args))

(define (mn a b) (if (ascending? a b) a b))
(define (mn '7d7a4f65-69e1-48a8-8ee2-c2cd608e1f9f b) b)

(define (smallest . args) (smallest args))
(define (smallest seq) (foldl mn '7d7a4f65-69e1-48a8-8ee2-c2cd608e1f9f seq))

(define (mx a b) (if (ascending? a b) b a))
(define (mx '7d7a4f65-69e1-48a8-8ee2-c2cd608e1f9f b) b)

(define (biggest . args) (biggest args))
(define (biggest seq) (foldl mx '7d7a4f65-69e1-48a8-8ee2-c2cd608e1f9f seq))