 # paulfioravanti's solution

## to Matching Brackets in the Elm Track

Published at Aug 12 2019 · 0 comments
Instructions
Test suite
Solution

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

## Elm Installation

Refer to the Installing Elm page for information about installing elm.

## Writing the Code

The code you have to write is located inside the src/ directory of the exercise. Elm automatically installs packages dependencies the first time you run the tests so we can start by running the tests from the exercise directory with:

$elm-test  To automatically run tests again when you save changes: $ elm-test --watch


As you work your way through the tests suite in the file tests/Tests.elm, be sure to remove the skip <| calls from each test until you get them all passing!

Ginna Baker

## Submitting Incomplete Solutions

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

### Tests.elm

module Tests exposing (tests)

import Expect
import MatchingBrackets exposing (isPaired)
import String
import Test exposing (..)

tests : Test
tests =
describe "MatchingBrackets"
[ test "paired square brackets" <|
\_ ->
Expect.equal True (isPaired "[]")
, skip <|
test "empty string" <|
\_ ->
Expect.equal True (isPaired "")
, skip <|
test "unpaired brackets" <|
\_ ->
Expect.equal False (isPaired "[[")
, skip <|
test "wrong ordered brackets" <|
\_ ->
Expect.equal False (isPaired "}{")
, skip <|
test "wrong closing bracket" <|
\_ ->
Expect.equal False (isPaired "{]")
, skip <|
test "paired with whitespace" <|
\_ ->
Expect.equal True (isPaired "{ }")
, skip <|
test "partially paired brackets" <|
\_ ->
Expect.equal False (isPaired "{[])")
, skip <|
test "simple nested brackets" <|
\_ ->
Expect.equal True (isPaired "{[]}")
, skip <|
test "seceral paired brackets" <|
\_ ->
Expect.equal True (isPaired "{}[]")
, skip <|
test "paired and nested brackets" <|
\_ ->
Expect.equal True (isPaired "([{}({}[])])")
, skip <|
test "unopened closing brackets" <|
\_ ->
Expect.equal False (isPaired "{[)][]}")
, skip <|
test "unpaired and nested brackets" <|
\_ ->
Expect.equal False (isPaired "([{])")
, skip <|
test "paired and wrong nested brackets" <|
\_ ->
Expect.equal False (isPaired "[({]})")
, skip <|
test "math expression" <|
\_ ->
Expect.equal True (isPaired "(((185 + 223.85) * 15) - 543)/2")
, skip <|
test "complex latex expression" <|
\_ ->
Expect.equal True (isPaired "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)")
]
module BracketPush exposing (isPaired)

import Dict exposing (Dict)

isPaired : String -> Bool
isPaired input =
input
|> String.foldl checkPair []
|> List.isEmpty

-- PRIVATE

checkPair : Char -> List Char -> List Char
checkPair char acc =
case Dict.get char brackets of
Just closingBracket ->
closingBracket :: acc

Nothing ->
if isCloseableBracket char acc then
List.drop 1 acc

else if isTypeOfClosingBracket char then
-- unopened closing bracket
char :: acc

else
acc

isCloseableBracket : Char -> List Char -> Bool
isCloseableBracket char acc =

isTypeOfClosingBracket : Char -> Bool
isTypeOfClosingBracket char =
brackets
|> Dict.values
|> List.member char

brackets : Dict Char Char
brackets =
Dict.fromList
[ ( '[', ']' )
, ( '{', '}' )
, ( '(', ')' )
]