Tangential comment: These string operations are convenient to have
around, and they can be expedient, but composing with them can make for
inefficient evaluation.
For example, my first attempt to implement "string->number" (after
briefly considering just using "read"), was 17 times faster in a
shootout on my computer, compared to the one that was built using
"string-strip" and other string operations. (It also helped that I used
Racket regexps rather than pregexps.)
(define (string->number-list/mk2 str)
(let loop ((start 0))
(cond ((regexp-match-positions #rx"^[ \t\r\n\f]*([0-9]+(?:[0-9]+)?)"
str
start)
=> (lambda (m)
(let* ((range (cadr m))
(end (cdr range)))
(cons (string->number (substring str
(car range)
(cdr range)))
(loop end)))))
(else (if (regexp-match? #rx"^[ \t\r\n\f]*$" str start)
'()
(error 'string->number-list
"could not parse string ~S at start position ~S"
str
start))))))
If I was writing performance-sensitive code, I would also see whether a
procedure that scanned a character at a time, and didn't need
"string->number", was faster.
As everyone knows, if the code is not performance-sensitive, do whatever
is easiest to develop in a correct and maintainable way. But, when
performance matters -- such as in code that takes a significant
percentage of time in serving a HTTP request, or is in a PLaneT package
that other people might use in performance-sensitive context -- we also
have to think about algorithmic efficiency, as well as costs specific to
the language implementation.
--
http://www.neilvandyke.org/
____________________
Racket Users list:
http://lists.racket-lang.org/users
