Avatar of gwaerondor

gwaerondor's solution

to Matching Brackets in the OCaml Track

Published at May 13 2019 · 0 comments
Test suite

Given a string containing brackets [], braces {}, parentheses (), or any combination thereof, verify that any and all pairs are matched and nested correctly.

Getting Started

  1. Install the Exercism CLI.

  2. Install OCaml.

  3. For library documentation, follow Useful OCaml resources.

Running Tests

A Makefile is provided with a default target to compile your solution and run the tests. At the command line, type:


Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you can see how others have completed the exercise.

Feedback, Issues, Pull Requests

The exercism/ocaml repository on GitHub is the home for all of the Ocaml exercises.

If you have feedback about an exercise, or want to help implementing a new one, head over there and create an issue or submit a PR. We welcome new contributors!


Ginna Baker


open Base
open OUnit2
open Matching_brackets

let ae exp got _test_ctxt =
  assert_equal exp got ~printer:Bool.to_string

let tests = [
  "paired square brackets" >::
  ae true (are_balanced "[]");
  "empty string" >::
  ae true (are_balanced "");
  "unpaired brackets" >::
  ae false (are_balanced "[[");
  "wrong ordered brackets" >::
  ae false (are_balanced "}{");
  "wrong closing bracket" >::
  ae false (are_balanced "{]");
  "paired with whitespace" >::
  ae true (are_balanced "{ }");
  "partially paired brackets" >::
  ae false (are_balanced "{[])");
  "simple nested brackets" >::
  ae true (are_balanced "{[]}");
  "several paired brackets" >::
  ae true (are_balanced "{}[]");
  "paired and nested brackets" >::
  ae true (are_balanced "([{}({}[])])");
  "unopened closing brackets" >::
  ae false (are_balanced "{[)][]}");
  "unpaired and nested brackets" >::
  ae false (are_balanced "([{])");
  "paired and wrong nested brackets" >::
  ae false (are_balanced "[({]})");
  "paired and incomplete brackets" >::
  ae false (are_balanced "{}[");
  "too many closing brackets" >::
  ae false (are_balanced "[]]");
  "math expression" >::
  ae true (are_balanced "(((185 + 223.85) * 15) - 543)/2");
  "complex latex expression" >::
  ae true (are_balanced "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)");

let () =
  run_test_tt_main ("matching-brackets tests" >::: tests)
open ExtLib
open String
open List

let is_opening c = mem c (explode "({[")
let is_closing c = mem c (explode ")}]")
let are_pair opening closing =
  mem (opening, closing) [('(', ')');
                          ('[', ']');
                          ('{', '}')]

let are_balanced s =
  let ss = explode s in
  let rec a_b cs acc =
    match cs with
    | [] ->
       acc = []
    | (c::r) ->
       if is_opening c then a_b r (c::acc)
       else if is_closing c then
         if acc = [] then false
         else if are_pair (hd acc) c then a_b r (tl acc)
         else false
       else a_b r acc
  a_b ss []

Community comments

Find this solution interesting? Ask the author a question to learn more.

What can you learn from this solution?

A huge amount can be learned from reading other people’s code. This is why we wanted to give exercism users the option of making their solutions public.

Here are some questions to help you reflect on this solution and learn the most from it.

  • What compromises have been made?
  • Are there new concepts here that you could read more about to improve your understanding?