def string_replace(str, replacements):
    for replacement in replacements:
        str = str.replace(replacement[0], replacement[1], 1)
    return str

s = "JSON-RPC is a stateless, light-weight remote procedure call (RPC) protocol. Primarily this specification defines several data structures and the rules around their processing. It is transport agnostic in that the concepts can be used within the same process, over sockets, over http, or in many various message passing environments. It uses JSON (RFC 4627) as data format."

rpls = [["so", "--"], ["http", "xxxx"], ["abc", "---"], ["json", "xxxx"]]

i = 10000
a = ''
while i > 0:
    a = string_replace(s, rpls)
    i = i - 1

print a

(use data-structures)

(define iters 10000)
(define s "JSON-RPC is a stateless, light-weight remote procedure call (RPC) protocol. Primarily this specification defines several data structures and the rules around their processing. It is transport agnostic in that the concepts can be used within the same process, over sockets, over http, or in many various message passing environments. It uses JSON (RFC 4627) as data format.")
(define rpls '(("so" . "--") ("http" . "xxxx") ("abc" . "---") ("json" . "xxxx")))

(define (bench-string-translate)
  (let loop ((i iters))
    (unless (fx= i 0)
      (string-translate* s rpls)
      (loop (fx- i 1)))))

(print (string-translate* s rpls))
(time (bench-string-translate))

(use data-structures)

(define iters 10000)
(define s "JSON-RPC is a stateless, light-weight remote procedure call (RPC) protocol. Primarily this specification defines several data structures and the rules around their processing. It is transport agnostic in that the concepts can be used within the same process, over sockets, over http, or in many various message passing environments. It uses JSON (RFC 4627) as data format.")
(define rpls '(("so" . "--") ("http" . "xxxx") ("abc" . "---") ("json" . "xxxx")))

(define (replace subject target replacement)
  (let ((sl (string-length subject))
        (rl (string-length replacement))
        (i (substring-index subject target)))
    (if (not i)
        subject
        (string-append (substring subject 0 i)
                       replacement
                       (substring s (+ i rl) (+ sl 1))))))

(define (my-replace str replacements)
  (foldl (lambda (s r)
           (replace s (car r) (cdr r)))
         str
         replacements))

(define (bench-string-translate)
  (let loop ((i iters))
    (unless (fx= i 0)
      (my-replace s rpls)
      (loop (fx- i 1)))))

(print (my-replace s rpls))
(time (bench-string-translate))

(use srfi-13 data-structures)

(define iters 10000)
(define s "JSON-RPC is a stateless, light-weight remote procedure call (RPC) protocol. Primarily this specification defines several data structures and the rules around their processing. It is transport agnostic in that the concepts can be used within the same process, over sockets, over http, or in many various message passing environments. It uses JSON (RFC 4627) as data format.")
(define rpls '(("so" . "--") ("http" . "xxxx") ("abc" . "---") ("json" . "xxxx")))

(define (my-replace str replacements)
  (foldl (lambda (s r)
           (let ((i (substring-index s (car r))))
             (if i (string-replace s (cdr r) i (string-length (car r))) s)))
         str
         replacements))

(define (bench-string-translate)
  (let loop ((i iters))
    (unless (fx= i 0)
      (my-replace s rpls)
      (loop (fx- i 1)))))

(print (my-replace s rpls))
(time (bench-string-translate))

(use data-structures)

(define iters 100000)
(define s "JSON-RPC is a stateless, light-weight remote procedure call (RPC) protocol. Primarily this specification defines several data structures and the rules around their processing. It is transport agnostic in that the concepts can be used within the same process, over sockets, over http, or in many various message passing environments. It uses JSON (RFC 4627) as data format.")
(define rpls '(("so" . "--") ("http" . "xxxx") ("abc" . "---") ("json" . "xxxx")))

(define (replace subject target replacement)
  (let ((i (substring-index target subject)))
    (if i
        (string-append (substring subject 0 i)
                       replacement
                       (substring subject (+ i (string-length target))))
        subject)))


(define (my-replace str replacements)
  (foldl (lambda (s r)
           (replace s (car r) (cdr r)))
         str
         replacements))

(define (bench-string-translate)
  (let loop ((i iters))
    (unless (fx= i 0)
      (my-replace s rpls)
      (loop (fx- i 1)))))

(print (my-replace s rpls))
(time (bench-string-translate))