Checking if a string consists of balanced parenthesis

Question

I wrote the following program to check strings for balanced parenthesis:

isBalanced xs = isBalanced' xs []

isBalanced' [] [] = True
isBalanced' [] _  = False

isBalanced' ('(':xs) ys = isBalanced' xs (')':ys)
isBalanced' ('[':xs) ys = isBalanced' xs (']':ys)
isBalanced' ('{':xs) ys = isBalanced' xs ('}':ys)

isBalanced' _  [] = False

isBalanced' (x:xs) (y:ys) = (x == y) && (isBalanced' xs ys)

Here is some example data:

positives = [
    isBalanced "",
    isBalanced "()",
    isBalanced "[]",
    isBalanced "{}",
    isBalanced "([]){}[{}]"
    ]

negatives = [
    isBalanced "(",
    isBalanced "[",
    isBalanced "{",
    isBalanced ")",
    isBalanced "]",
    isBalanced "}",
    isBalanced "([)]",
    isBalanced "{]",
    isBalanced ")("
    ]

Since this program uses only the most basic building blocks of explicit recursion, I wondered if there was a shorter, more high-level approach involving language facilities I am not yet aware of.

Okay, I distilled the following solution from several answers and comments (and my own thoughts):

import Text.Parsec

grammar = many parens >> return () where
 parens = choice [ between (char opening) (char closing) grammar
                 | [opening, closing] <- ["()", "[]", "{}"]]

isBalanced = isRight . parse (grammar >> eof) ""

isRight (Right _) = True
isRight _         = False

score 18 · Accepted Answer · edited May 23 '17 at 12:25

18

As Henning said, parser combinators would work for this. Here's an example using Parsec:

import Text.Parsec

grammar = many braces >> return ()
    where braces = choice [ between (char '(') (char ')') grammar
                          , between (char '[') (char ']') grammar
                          , between (char '{') (char '}') grammar
                          ]

isBalanced :: String -> Bool
isBalanced input = case parse (grammar >> eof) "" input of
                       Left  _ -> False
                       Right _ -> True

edited May 23 '17 at 12:25

Community

1
1

answered Aug 26 '11 at 19:30

hammar

138,522
17
304
385

3

or even `braces = choice [between (char o) (char c) grammar | (o,c) <- [('(',')'),('[',']'),('{','}')]]` – sdcvvc Aug 26 '11 at 19:43

Michael Steele · Answer 2 · 2011-08-26T20:46:36.333

Using a left fold

import Data.List (foldl')

isBalanced xs = null $ foldl' op [] xs
  where
    op ('(':xs) ')' = xs
    op ('[':xs) ']' = xs
    op ('{':xs) '}' = xs
    op xs x = x:xs

The fold builds up a stack of previously encountered characters, stripping away any matches as it finds them. If you end up with an empty list, the string is balanced.

Using a left fold in the Maybe monad

The disadvantage of using a left fold is that the entire string must always be scanned through. It would be nice to abort the operation with a failure should a closing brace be found without a matching opening brace. Here's a version that does just that.

import Control.Monad (foldM)

isBalanced' xs = maybe False null $ foldM op [] xs
  where
    op ('(':xs) ')'          = Just xs
    op ('[':xs) ']'          = Just xs
    op ('{':xs) '}'          = Just xs
    op xs x | x `elem` ")]}" = Nothing
            | otherwise      = Just (x:xs)

isBalanced "0" === False – Yura Lazarev Mar 29 '20 at 08:31 — Yura Lazarev, Mar 29 '20 at 08:31

score 3 · Answer 3 · answered Aug 26 '11 at 19:41

I think hammar's answer is the best, but here are smaller steps you can do - use null and lookup:

{-# LANGUAGE PatternGuards #-}
isBalanced xs = isBalanced' xs []

isBalanced' [] x = null x

isBalanced' (c:xs) ys | Just d <- lookup c par = isBalanced' xs (d:ys)
  where par = [('(',')'), ('[',']'),('{','}')]

isBalanced' _  [] = False

isBalanced' (x:xs) (y:ys) = x == y && isBalanced' xs ysl

Your example positives and negatives data should definitely use map, or even all.

score 2 · Answer 4 · answered Aug 26 '11 at 18:58

2

Probably overkill for a problem this simple, but you could try looking up parser combinators.

As a more elementary simplification, you could rewrite your recursion into folding over a function that takes a stack and a character from the string to a new stack. (Whether this would make actually it simpler is in the eye of the beholder, though).

answered Aug 26 '11 at 18:58

hmakholm left over Monica

23,074
3
51
73

1

Indeed parser combinators can be useful. Something like `embrace s left right = char left *> s <* char right; balanced = empty <|> msum $ zipWith (embrace balanced) "([{" ")]}"`. – Rotsor Aug 26 '11 at 19:19
@Rotsor That code doesn't look right. Shouldn't the `empty <|> ...` be something like `many (...)` instead? (e.g. try parsing `"()()"`) – Daniel Wagner Aug 26 '11 at 19:37
@Daniel, oh, indeed... Also, the operator precedence is wrong. – Rotsor Aug 26 '11 at 23:13

Checking if a string consists of balanced parenthesis

4 Answers4

Using a left fold

Using a left fold in the Maybe monad

Linked