    ; This is a test file to test kates scheme highlighting
    ; This is a comment

    ;; Another comment, usually used.
    ;BEGIN region marker
    ;; a vektor
    #(1 2 3 4 5)
    ;END region marker
    ;; this represents integer 28 (FIXME: does not work perfectly atm!)
    28 028 #e28 #i28       ;; Normal, normal, exact, inexact
    #b11100 #o34 #d28 #x1c ;; Bin, okt, dec, hex
    #oe34 #eo34            ;; combined.

    ;; char.
    (#\y #\space) ;; list: `y' space.
    (#\  #\\ #\)) ;; list of spaces, backslash and`)'.
    #\newline     ;; a newline-char
    #\NewLine     ;; another one :)

    "Hello, world" ;; a string

    "hoho, what do you
    want to do  ;; this is NO comment
    with that?"

    ;; R5RS definiert diese beiden.
    "Das ist \"in Anführungszeichen\" und mit \\ Backslash."

    (let ((x (+ 1 2)) (y "blah")) ;; `let' highlighting.
      (and (number? x)            ;; `and' highlighting.
           (string? y)))

    (let* ((x 2) (y (+ x 1))) ;; `let*' too.
      (or (negative? x)       ;; `or' anyways.
          (negative? y)))

    (do ((vec (make-vector 5)) ;; `do' you may guess!
         (i 0 (+ i 1)))
        ((= i 5) vec)
      (vector-set! vec i i))

    (quasiquote ((+ 1 2) (unquote (+ 1 2))))
    ;; same as: `((+ 1 2) ,(+ 1 2))

    ;; see above.
    (quasiquote ((+ 1 2) (unquote-splicing (list 1 2 3))))
    ;; same as: `((+ 1 2) ,@(+ 1 2))

    ;; not necessary.
    (quote ())

    (cond ((string? x) (string->symbol x)) ;; `cond' highlighting.
          ((symbol? x) => (lambda (x) x))  ;; `=>' highlighting.
          (else ;; `else' highlighting.
           (error "Blah")))

    (case x ;; `case' highlighting.
      ((#t) 'true) ((#f) 'false)
      ((()) 'null)
      ((0) 'zero))

    ;; highlight `let-syntax' and `syntax-rules' .
    (let-syntax ((when (syntax-rules ()
                         ((when test stmt1 stmt2 ...)
                          ;; hl `begin' .
                          (if test (begin stmt1 stmt2 ...))))))
      (let ((if #t)) ;; here`if' is actually no keyword.
        (when if (set! if 'now)) ;; nor here.
        if))

    (letrec-syntax ...) ;; hl `letrec-syntax'.

    (define-syntax when
      (syntax-rules ()
        ((when test stmt1 stmt2 ...)
         (if test (begin stmt1 stmt2 ...))))))

    ;; variable definitions.
    (define natural-numbers ;; hl `define' and the var name
      ;; endless stream of all natual numbers.
      (letrec ((next-cell    ;; hl `letrec'.
                (lambda (x)  ;; hl `lambda'.
                  ;; hl `delay' .
                  (cons x (delay (next-cell (+ x 1)))))))
        (next-cell 0)))

    ;; a procedure with unusual but allowed name.
    (define 1+
      (lambda (x)
        (+ x 1)))

    ;; a predicate
    (define between?
      (lambda (x y z)
        (if (and (>= x y) (<= x z))
            #t ;; True
          #f))) ;; False.

    ;; imperative procedure
    (define set-something!
      (lambda (required-argument another-one . all-remaining-args)
        (set-car! another-one (lambda all-args
                                (set-cdr! required-argument
                                          (append all-remaining-args
                                                  all-args))))))

    (define compose
      (lambda (f g)
        (lambda (x)
          (f (g x)))))

    ;; syntactical sugar for procedure-definitions.
    (define (compose f g)
      (lambda (x)
        (f (g x))))

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; NOW: Guile extensions ;;
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;

    ;; procedure-generator.
    (define ((compose f g) x)
      (f (g x)))

    ;; scheme doesn't say, which chars may be in variables...
    ;; At least: Guile accepts umlauts
    (define-private (timetr??? sprache) ;; hl `define-private'.
      (list-dialekt? sprache))

    (define-public x #t)  ;; hl `define-public'.
    (define-module (foo bar)) ;; hl `define-module'.
    (define-macro (neither . exprs) ;; hl `define-macro'.
      `(and ,@(map (lambda (x) `(not ,x)) exprs)))

    (defmacro neither exprs ;; `defmacro' as well.
      `(and ,@(map (lambda (x) `(not ,x)) exprs)))

    ;; hl, but I really don't know what this is supposed to do :-)
    (define-syntax-macro ...)

    ;; hl GOOPS-`defines'
    (define-method (foo bar (baz <vector>) qux) ...)
    (define-class <foo> ...)
    (define-generic foo)
    (define-accessor bar)

    ;; Keywords!
    (blah #:foo 33 #:bar 44)

    ;; another convention for symbols:
    #{foo}#

    #{a
    few
    lines}#

    #{4711}#

    ;; more chars.
    #\nul #\nl #\esc #\bs #\bel #\syn #\ack #\sp ;; etc, utc, itc, oops (this is boring)

    #!
     guile block-comment.
    !#

    ;; now, a bit hairy:
    #! comment !#
    still comment!!!
    !#
    'now-no-comment-anymore

    ;; more precise:
    #! comment !#
    still comment
    !# still comment!
    !#
    'now-no-comment-anymore

    (while (> foo 10) ;; Highlight `while'.
      (set! foo (- foo 1))
      (catch #t ;; Highlight `catch'.
        (lambda () (display foo))
        (lambda (key . args)
          (if (eq? key 'system-error)
              (break) ;; Highlight `break'.
            (continue))))) ;; Highlight `continue'.