(module easy-args (define-arguments)
  (import scheme chicken)
  (use srfi-13)

  (define-syntax define-arguments
    (syntax-rules ()
      ((_ (<name> <value/guard> ...) ...)
       (begin (define <name>) ...
         (define command-line-arguments*
           (make-parameter (command-line-arguments)))
         (let* ((argument-list '()) ; accumulate parameters
                (assert-val (lambda (option)
                              (or (> (length option) 1)
                                  (error 'define-arguments
                                         "No argument value given"
                                         (car option)))))
                (make-arg (lambda (name #!optional value (guard (lambda (x) x)))
                            (let ((flag (string-delete #\* (format "-~a" name)))
                                  (parameter (make-parameter value guard))
                                  (type (cond ((boolean? value) 'boolean)
                                              ((string? value) 'string)
                                              ((symbol? value) 'symbol)
                                              ((number? value) 'number)
                                              (else (error 'define-arguments
                                                           "Invalid default value"
                                                           value)))))
                              (set! argument-list
                                (cons (list flag parameter type)
                                      argument-list))
                              parameter))))
           ; set parameter value for each argument
           (set! <name> (make-arg '<name> <value/guard> ...)) ...
           ; process (command-line-arguments) against defined parameters
           (command-line-arguments ; remove any we handle
             (let try-match ((unmatched '()) (lst (command-line-arguments)))
               (if (null? lst)
                 (reverse unmatched)
                 (let ((match (assoc (car lst) argument-list)))
                   (if match
                     (try-match unmatched
                       (case (caddr match)
                         ((boolean) ((cadr match) #t) (cdr lst))
                         ((string) (assert-val lst)
                                   ((cadr match) (cadr lst)) (cddr lst))
                         ((symbol) (assert-val lst)
                                   ((cadr match)
                                    (string->symbol (cadr lst)))
                                   (cddr lst))
                         ((number) (assert-val lst)
                                   ((cadr match)
                                    (string->number (cadr lst)))
                                   (cddr lst))))
                     (try-match (cons (car lst) unmatched)
                                (cdr lst)))))))))))))