Error checking with Aeson - json

Question

This code parses a recursive JSON structure into a haskell object that I made. I'm using the Aeson library. The problem that I'm encountering is that I want to be able to do error checking easily, even with a recursive call. Right now I use a dummy value (ayyLmao) whenever an error occurs. However I would like to leverage the error checking I get from the Parser monad. How can I do this and possibly clean up my code in the process? If necessary I can also post some sample JSON.
EDIT: I'd like to point out that I'd like to get rid of "ayyLmao" (hence the stupid name), and somehow use 'mzero' for the Parser monad for my error checking instead.
type Comments = Vector Comment
data Comment = Comment
{ author :: Text
, body :: Text
, replies :: Comments
} deriving Show
-- empty placeholder value (only should appear when errors occur)
ayyLmao :: Comment
ayyLmao = Comment "Ayy" "Lmao" V.empty
parseComment :: Object -> Maybe Comments
parseComment obj = flip parseMaybe obj $ \listing -> do
-- go through intermediate objects
comments <- listing .: "data" >>= (.: "children")
-- parse every comment in an array
return $ flip fmap comments $ \commentData -> case commentData of
-- if the data in the array is an object, parse the comment
-- (using a dummy value on error)
Object v -> fromMaybe ayyLmao (parseMaybe parseComment' v)
-- use a dummy value for errors (we should only get objects in
-- the array
_ -> ayyLmao
where
parseComment' :: Object -> Parser Comment
parseComment' v = do
-- get all data from the object
comment <- v .: "data"
authorField <- comment .: "author"
bodyField <- comment .: "body"
replyObjs <- comment .: "replies"
return $ case replyObjs of
-- if there are more objects, then parse recursively
Object more -> case parseComment more of
-- errors use the dummy value again
Just childReplies -> Comment authorField bodyField childReplies
Nothing -> ayyLmao
-- otherwise, we've reached the last comment in the
-- tree
_ -> Comment authorField bodyField V.empty
EDIT: The code in the answer below is correct, but I'd like to add my modified solution. The solution given assumes that "null" indicates no more replies, but for some reason the API designers decided that that should be represented by the empty string.
instance FromJSON Comment where
parseJSON = withObject "Comment" $ \obj -> do
dat <- obj .: "data"
commReplies <- dat .: "replies"
Comment
<$> dat .: "author"
<*> dat .: "body"
<*> case commReplies of
Object _ -> getComments <$> dat .: "replies"
String "" -> return V.empty
_ -> fail "Expected more comments or a the empty string"

Answer 1

You hit the mark with "Or I could have a list of Parsers and then fold it into one larger parser". This is exactly how you would propagate errors from nested parsers. The minimum change to your code to remove ayyLmao would be:
parseComment :: Object -> Maybe Comments
parseComment obj = flip parseMaybe obj $ \listing -> do
-- go through intermediate objects
comments <- listing .: "data" >>= (.: "children")
-- parse every comment in an array
V.sequence $ flip fmap comments $ \commentData -> case commentData of
-- if the data in the array is an object, parse the comment
-- (using a dummy value on error)
Object v -> parseComment' v
-- use a dummy value for errors (we should only get objects in
-- the array
_ -> mzero
where
parseComment' :: Object -> Parser Comment
parseComment' v = do
-- get all data from the object
comment <- v .: "data"
authorField <- comment .: "author"
bodyField <- comment .: "body"
replyObjs <- comment .: "replies"
case replyObjs of
-- if there are more objects, then parse recursively
Object more -> case parseComment more of
-- errors use the dummy value again
Just childReplies -> return $ Comment authorField bodyField childReplies
Nothing -> mzero
-- otherwise, we've reached the last comment in the
-- tree
_ -> return $ Comment authorField bodyField V.empty
This uses mzero for the error cases and propagates errors from the list of replies with V.sequence. sequence is a exactly the thing that takes a list of parsers (or, in this case, a vector) and folds into a single parser that either succeeds or fails.
However, the above is not a very good way to use aeson. It's usually better to derive an instance of the FromJSON type-class and work from there. I would implement the above as
{-# LANGUAGE OverloadedStrings #-}
import qualified Data.Vector as V
import Data.Vector (Vector)
import Data.Text (Text)
import Data.Aeson
import Data.Maybe (fromMaybe)
import Control.Applicative
type Comments = Vector Comment
data Comment = Comment
{ author :: Text
, body :: Text
, replies :: Comments
} deriving Show
newtype CommentList = CommentList { getComments :: Comments }
instance FromJSON Comment where
parseJSON = withObject "Comment" $ \obj -> do
dat <- obj .: "data"
Comment
<$> dat .: "author"
<*> dat .: "body"
<*> (fromMaybe V.empty . fmap getComments <$> dat .: "replies")
instance FromJSON CommentList where
parseJSON = withObject "CommentList" $ \obj -> do
dat <- obj .: "data"
CommentList <$> dat .: "children"
This introduces a wrapper type CommentList which is used to fetch the obj.data.children attribute from the JSON. This takes advantages of the existing FromJSON instance for Vector so you don't have to manually loop through the replies and parse them separately.
The expression
fromMaybe V.empty . fmap getComments <$> dat .: "replies"
assumes that the replies attribute in the JSON contains either a null value or a valid CommentList so it tries to parse a Maybe CommentList value (null is parsed to Nothing) and then replaces a Nothing value with an empty vector using fromMaybe.