fizzbuzz in typed racket

fizzbuzz.rkt

#lang typed/racket

(define-type T (U String Integer))
(: fizzbuzz : ((Listof Integer) -> (Listof T)))
(define fizzbuzz
  (lambda (l)
    (cond [(null? l) '()]
          [else (let* ([x (car l)]
                       [xs (cdr l)]
                       [mod3 (eq? 0 (modulo x 3))]
                       [mod5 (eq? 0 (modulo x 5))]
                       [v (cond [(and (eq? #t mod3) (eq? #t mod5)) "fizzbuzz"]
                                [(eq? #t mod3) "fizz"]
                                [(eq? #t mod5) "buzz"]
                                [else x])])
                  (cons v (fizzbuzz xs)))])))

;; in plain racket, this is (build-list 100 values)
(: int-range : (Integer -> (Listof Integer)))
(define int-range
  (lambda (n)
    (: int-range-inner : (Integer Integer -> (Listof Integer)))
    (define int-range-inner
      (lambda (m i)
        (cond [(eq? m i) '()]
              [else (cons i (int-range-inner m (+ i 1)))])))
    (int-range-inner n 0)))

(print (fizzbuzz (int-range 100)))

The definition for int-range can be simplified by using for/list:

(define (int-range n)
  (for/list: ([i : Integer (in-range n)]) i))

You may not even need to build the intermediate list though. Here's what it looks like without building the list: https://gist.github.com/4696161

Good luck!