Question

Since all the examples in the guide are with lists, I find it difficult to see how to use pattern matching in Racket to write conditional matching like OCaml does, for example:

read ~var_a var_b s = match s.[0] with
    | _ when var_b >= var_a + 4 ->
        (* Do something *)
    | "a" when is_negative var_b -> 
        (* Do something else *)
    ...

How would I write something similar in Racket?

Thanks.

Answer 1

The racket/match library includes pattern matching that can use arbitrary predicates through the ? pattern. Along with and, you should be able to get Racket’s matcher to behave. Although I’m a little weak in my OCaml, I think the following translation of the code above matches its meaning:

(define (my-read #:var-a var-a var-b s)
  (match (string-ref s 0)
    [(and _
          (? (lambda (_)
               (>= var-b (+ var-a 4)))))
     "do something"]
    [(and '#\a
          (? (lambda (_)
               (< var-b 0))))
     "do something else"]))

;; Exercising the first case:     
(my-read #:var-a 50
         60 "blah")

;; Exercising the second case:
(my-read #:var-a 50
         -40 "alphabet")

The ? matcher has an implicit and embedded within it, so the code can be expressed slightly more succinctly as:

(define (my-read #:var-a var-a var-b s) 
  (match (string-ref s 0)
    [(? (lambda (_)
          (>= var-b (+ var-a 4))))
     "do something"]
    [(? (lambda (_)
          (< var-b 0))
        #\a)
     "do something else"]))

In both, the lambdas in there aren’t watching what got matched, so I just named them _ to denote a don’t-care. But you can imagine more sophisticated patterns where the predicates could care deeply about what exactly got matched.

Eli suggests using a general cond here, since there isn’t any significant pattern matching in the code. I agree. The code would look like this:

(define (my-read #:var-a var-a var-b s) 
  (cond
    [(>= var-b (+ var-a 4))
     "do something"]
    [(and (char=? (string-ref s 0) #\a)
          (< var-b 0))
     "do something else"]))