Scheme/Racket: idiomatic infix math evaluator
Here are my review comments on the tokeniser:


It's unusual to prefix symbols with -. The indentation should be enough to tell you the "nesting level" of the inner functions, without having to put -s in front.
Your inner -tokenize could be hoisted into a named let, so that your tokenize function looked like this (I will make other changes to the function later, but for now I try to keep as close to your original code as possible):

(define (tokenize)
  ;; other internal definitions

  (let recur ([first (read-char)]
              [endchar #\newline])
    (if (equal? first endchar)
        '()
        (let ([operator (-tokenize-operator first)]
              [number (-tokenize-number first)]
              [openparen (-tokenize-openparen first)])
          (cond
            ([pair? operator] (cons (car operator) (recur (cadr operator) endchar)))
            ([pair? number] (cons (car number) (recur (cadr number) endchar)))
            ([pair? openparen] (list (recur (cadr openparen) #\))))
            (else (recur (read-char) #\newline)))))))

Character comparisons can use eqv? instead of equal?. Not really a biggie, but usually I reserve equal? for deep comparisons.
Use #f for false/null values, not '(). In Scheme, #f is the only false value there is; '() is a true value (like everything else). Though, instead of all those different tokenising helpers, and calling them all and then only using one of the return values, it would be nicer to test directly in the cond.
Instead of all the repeated (read-char)s, you might consider using a port stream instead. Create one using sequence-&gt;stream, then you can call stream-first and stream-rest on it.


With all that in mind, I'd write the tokeniser like so:

(define (tokenize [port (current-input-port)])
  (let recur ([str (sequence-&gt;stream (in-input-port-chars port))])
    (cond [(stream-empty? str) '()]
          [(char-numeric? (stream-first str))
           (let loop [(str str)
                      (digits '())]
             (if (and (not (stream-empty? str))
                      (char-numeric? (stream-first str)))
                 (loop (stream-rest str) (cons (stream-first str) digits))
                 (cons (string-&gt;number (list-&gt;string (reverse digits)))
                       (recur str))))]
          [(char-whitespace? (stream-first str))
           (recur (stream-rest str))]
          [else (cons (stream-first str) (recur (stream-rest str)))])))


(Comments on the evaluator to come later.)