DouKaku?

reverseString2 :: String -> String
reverseString2 str = let (e, s) = foldl f ([],[]) str in foldl (\s1 (s2,c) -> s2++c:s1) s e
    where f (e, s) c
              | c `elem` "({[" = (([], c):e, s)
              | c `elem` ")}]" = case e of
                                   (es1, p1):(es2, p2):rest
                                        | c == opposite p1 -> ((p1:es1++c:es2, p2):rest, s)
                                        | otherwise -> ((c:es1++p1:es2, p2):rest, s)
                                   [(es, p)]
                                       | c == opposite p -> ([], p:es++c:s)
                                       | otherwise -> ([], c:es++p:s)
                                   [] -> (e, c:s)
              | otherwise = case e of
                              (es, p):rest -> ((c:es, p):rest, s)
                              otherwise    -> (e, c:s)
          opposite '(' = ')'
          opposite ')' = '('
          opposite '{' = '}'
          opposite '}' = '{'
          opposite '[' = ']'
          opposite ']' = '['
          opposite c = c

parens = [('(',')'), ('[',']'), ('{','}')]

isOpener c = elem c $ map fst parens
isCloser c = elem c $ map snd parens

closer p = case lookup p parens of
             Just q -> q
             Nothing -> error "huh?"

revs [] rs zs = ([],rs++zs)
revs (x:xs) rs zs
  | isOpener x = case revs xs [] [x] of
                   (xs',rs') -> revs xs' (rs'++rs) zs
  | isCloser x = case zs of
                   [z] | x == closer z -> (xs, [z]++rs++[x])
                   _                   -> (xs, [x]++rs++zs)
  | otherwise  = revs xs (x:rs) zs

reverseString2 s = snd $ revs s [] []

import qualified System.IO.UTF8 as U
import Text.ParserCombinators.ReadP

data Kakko = Maru | Nami | Kaku

data Inline = Plain String
            | Paren Kakko [Inline]

pPlain  = do { s <- many1 $ satisfy (flip notElem "(){}[]"); return (Plain s)}

pMaru = do { char '('; is <- many pInline; char ')'; return (Paren Maru is) }
pNami = do { char '{'; is <- many pInline; char '}'; return (Paren Nami is) }
pKaku = do { char '['; is <- many pInline; char ']'; return (Paren Kaku is) }

pParen = pMaru +++ pNami +++ pKaku
pInline = pPlain +++ pParen

pInlines =   many1 (pPlain +++ pParen)
         +++ do { c  <- satisfy (const True)
                ; is <- pInlines
                ; return (Plain [c] : is)
                }

revInline (Plain s) = Plain (reverse s)
revInline (Paren k is) = Paren k (foldl ((. revInline) . flip (:)) [] is)

instance Show Inline where
  show (Plain s) = s
  show (Paren k is) = case k of
                         Maru -> '(':(concatMap show is)++")"
                         Nami -> '{':(concatMap show is)++"}"
                         Kaku -> '[':(concatMap show is)++"]"

reverseString2 = concatMap show 
               . reverse 
               . map revInline 
               . fst 
               . head 
               . filter (null . snd) 
               . readP_to_S pInlines

sample0 = "文字列(もじれつ)の反転(はんてん)"
sample1 = "対応[の{とれている(さまざまな)括弧}の(例)]です。"
sample2 = "これ(は(対応のとれてない)括弧がある例です。"
sample3 = "これ(も{対応の)とれていない}括弧の例です。"

{-
*Main> U.putStrLn $ reverseString2 $ sample0
(んてんは)転反の(つれじも)列字文
*Main> U.putStrLn $ reverseString2 $ sample1
。すで[(例)の{弧括(なまざまさ)るいてれと}の]応対
*Main> U.putStrLn $ reverseString2 $ sample2
。すで例るあが弧括(いなてれとの応対)は(れこ
*Main> U.putStrLn $ reverseString2 $ sample3
。すで例の弧括}いないてれと)の応対{も(れこ
-}

type Paren = Char
type ParenStack = [Paren]

reverseString2 :: String -> String
reverseString2 str = fst $ reverseStrParen (str, [])

reverseStrParen :: (String, ParenStack) -> (String, ParenStack)
reverseStrParen ([],  _)        = ([], [])
reverseStrParen (x:[], stkOpen) = ([flipParenIfMatch x stkOpen], pushCloseParen x [])
reverseStrParen (x:xs, stkOpen) = 
            (reverseRest ++ [flipParen2Way x stkOpen stkClose], pushCloseParen x stkClose)
        where
        (reverseRest, stkClose) = reverseStrParen (xs ,pushOpenParen x stkOpen)

flipParen2Way :: Char -> ParenStack -> ParenStack -> Char
flipParen2Way x stkOpen stkClose
    | isOpening x = flipParenIfMatch x stkClose
    | isClosing x = flipParenIfMatch x stkOpen
    | otherwise   = x

flipParenIfMatch :: Char -> ParenStack -> Char
flipParenIfMatch x [] = x
flipParenIfMatch x (y:_)
    | isOpposit x y = y
    | otherwise = x

pushCloseParen :: Paren -> ParenStack -> ParenStack
pushCloseParen x xs = pushpopParen isClosing isOpening x xs

pushOpenParen :: Paren -> ParenStack -> ParenStack
pushOpenParen x xs = pushpopParen isOpening isClosing x xs

pushpopParen :: (Paren -> Bool) -> (Paren -> Bool) -> Paren -> ParenStack -> ParenStack
pushpopParen isOpenClose _ x []
    | isOpenClose x = [x]
    | otherwise     = []
pushpopParen isOpenClose isCloseOpen x xs
    | isOpenClose x = x : xs
    | isCloseOpen x = drop 1 xs
    | otherwise     = xs

isClosing :: Paren -> Bool
isClosing x = elem x ")}]"

isOpening :: Paren -> Bool
isOpening x = elem x "({["

isOpposit :: Char -> Paren -> Bool
isOpposit x y
    | x == flipParen y = True
    | otherwise   = False

flipParen :: Paren -> Paren
flipParen '(' = ')'
flipParen '{' = '}'
flipParen '[' = ']'
flipParen ')' = '('
flipParen '}' = '{'
flipParen ']' = '['

import Text.ParserCombinators.Parsec
import qualified System.IO.UTF8 as U

parenParser = do
            op <- oneOf "([{"
            st <- mkParser
            try (oneOf ")]}" >>= return . (f op st)) <|> return (op:st)
    where f op st cp | check op cp = [cp] ++ st ++ [op]
                     | otherwise   = [op] ++ st ++ [cp]
          check '(' ')' = True
          check '{' '}' = True
          check '[' ']' = True
          check _ _     = False                     

strParser = many1 $ noneOf "()[]{}"

mkParser = many1 (try parenParser <|> strParser) >>= return . concat

reverseString str = case parse mkParser "" str of
                         Left err -> show err
                         Right x  -> reverse x

exec = U.putStrLn . reverseString

sample0 = "文字列(もじれつ)の反転(はんてん)"
sample1 = "対応[の{とれている(さまざまな)括弧}の(例)]です。"
sample2 = "これ(は(対応のとれていない)括弧がある例です。"
sample3 = "これ(も{対応の)とれていない}括弧の例です。"

sample = mapM_ exec [sample0,sample1,sample2,sample3]