Pattern Match Vector Value in Data.Aeson

Question:

I am using Data.Aeson to parse JSON to my custom type. I try to pattern match Vector Value (Array) in my FromJSON instance, but don't know how I can do it. JSON value key can have a value of a String, a list of String or a list of list of String.

instance FromJSON Foo where
  parseJSON (Object o) =
    case lookup "value" o of
      Just (String s) -> pure $ SimpleText s
      Just [email protected](Array (String s)) -> pure $ ListOfText $ V.toList <$> V.mapM (parseJSON :: Value -> Parser Text) foo
      Just [email protected](Array (Array (String s))) -> pure $ ListOfListOfText $ V.toList <$> V.mapM (parseJSON :: Value -> Parser Text) $ V.toList <$> V.mapM (parseJSON :: Value -> [Parser Value]) foo

with

data Foo = SimpleText Text
         | ListOfText [Text]
         | ListOfListOfText [[Text]]
         deriving (Show, Eq, Ord)

Can I use pattern matching on Array to handle this case? or should I manually check the type of every Value? and how do to it?

No, you cannot pattern match the way you are trying to do here. A JSON Array can contain values of different types, and you cannot pattern match on all values in a list like they where one.

There are several ways to solve your actual problem here. There is a easy way, and there is an explicit way that will give you better error messages.

Easy way

The easy way is to use the fact that there already exist FromJSON instances for Text and [a]. Because of this you can use the Alternative operator to write your instance like this:

instance FromJSON Foo where
    parseJSON v =  (SimpleText <$> parseJSON v) 
               <|> (ListOfText <$> parseJSON v) 
               <|> (ListOfListOfText <$> parseJSON v)

The trick here is that Aeson first will try to parse a Text value, then if it fails it will try a [Text], if it fails again it will try [[Text]].

The problem with this solution is that if your JSON is malformed the error messages might not make sense. For example if you give it a top level Null value your error will be that it expects a [[Text]], since you will always get the error for the last value in the chain.

Explicit way

To get better error messages you have to be more expicit about what values you expect. What if the result is an empty array, should it be a ListOfText or a ListOfListOfText? Since we cant pattern match on a Vector directly, we can turn it into a list and pattern match on it:

instance FromJSON Foo where
    parseJSON v = case v of
        -- If its a string, we return the string as a SimpleText
        (String s) -> return $ SimpleText s

        -- If its an array, we turn the vector to a list so we can pattern match on it
        (Array a)  -> case V.toList a of

            -- If its a empty list, we return a empty ListOfText
            []             -> return $ ListOfText []

            -- If the first value is a string, we put it as the first element of our ListOfTexts and try to parse the rest.
            (String s: xs) -> ListOfText . (s:) <$> mapM parseJSON xs

            -- If the first value is an array, we try to parse it as [Text], then parse the rest.
            (Array a: xa)  -> ListOfListOfText <$> ((:) <$> parseJSON (Array a) <*> mapM parseJSON xa)

            -- If the first value is neither a string or array we return a error message.
            _              -> fail "Expected an Array or an Array of Arrays."

        -- If the top level value is not a string or array we return a error message.
        _ -> fail "Expected a String or Array"

Related:

Haskell make recipe fails for Paradox theorem prover using GHC

How can I express foldr in terms of foldMap for type-aligned sequences?

Refactor an IO recursive loop into a monad folding in Haskell

Replace all [ ] with {} - as short as possible [on hold]

apply a transformation with function inline

Haskell: `==' is not a (visible) method of class

Stopping condition on a recursive function - Haskell

Where to store API keys and other 'secrets' in a yesod app

Haskell: When declaring a class, how can I use a type variable that is not immediately in the constructors?

When will travis-ci support ghc 7.10?

Instance of Show for Lambda

IO Monad Example

Combining Event and an attribute in threepenny-gui

Why is lazy evaluation in Haskell “not being lazy”?

From and ToJSON in Haskell - a nested data

attoparsec: succeeding on part of the input instead of failing

Why doesn't `iterate` from the Prelude tie the knot?

Normal probability density function - GSL equivalent in Haskell

Why are takeR, dropR and splitAtR missing from Data.Sequence?

How to convert a Rational into a “pretty” String?

Haskell do clause with multiple monad types

Best practice for handling data types from 3rd party libraries in Haskell?

How to “wrap” monadic return value

logical expression evaluator Haskell

How do I avoid writing this type of Haskell boilerplate code

Keep track of loop without a counter

Implementing map on a tree using fold

What is haskellng? What is the difference between 'haskellPackages' and 'haskellngPackages'?

Why is f <$> g <$> x equivalent to (f . g) <$> x although <$> is not right-associative?

issues with installing newer cabal version for haskell vim now

Haskell powerset function - How to avoid Couldn't match expected type `IO t0' with actual type `[[Integer]]'

First three items of a list in Haskell

Haskell return lazy string from file IO

Idiomatic list construction

Get each fibbonacci value in haskell

Haskell IO - read from standard input directly to list

Setting id and class with the haskell diagrams package

Fold over a heterogeneous, compile time, list

Tokenizer identifier in Haskell

Decremented value called in the recursion in Haskell

Running executable files using Haskell

Can't find defaultTimeLocale in Data.Time.Format

Recursion scheme in Haskell for repeatedly breaking datatypes into “head” and “tail” and yielding a structure of results

Applicative style understanding

How does Frege generalize number literals?

Mapping with IO actions in Haskell

Thread blocked indefinitely in an MVar operation

How can I express the type of 'takeWhile for vectors'?

Hook into GHC runtime system

Haskell - generate and use the same random list