Разбор «остальной» объекта эзона

Question

по какой-то причине я не могу оборачивать голову вокруг произвольных успешных партитур в Эзоне, не создавая обрывки всей системы и вызывая утечку пространства.

Вот мой вопрос:

newtype Foo = Foo 
    { getFoo :: [(String, Maybe String)] 
    } deriving (Show, Eq) 

instance ToJSON Foo where 
    toJSON (Foo xs) = object $ 
    map (\(k,mv) -> T.pack k .= mv) xs 

до сих пор, кодирующая Foo прекрасно и денди. Но я хочу сделать парсер, который отклоняет пару ключей, если они существуют. Прямо сейчас, у меня есть псевдо-отказ происходит, и именно поэтому я думаю, что я плохой результат:

import qualified Data.HashMap as HM 

-- the "duck-tape and chewing gum" approach 
instance FromJSON Foo where 
    parseJSON (Object o) = Foo <$> parseJSON (Object theRest) 
    where 
     theRest = foldr HM.delete o [ "foo" 
            , "bar" 
            ] 
    parseJSON _ = empty 

Эта версия является то, что заставило меня думать, что манипулируя внутренний объект был неправильным, поскольку синтаксический анализатор может получать «больше» данных в HashMap, вне парсера (из-за ленивого байта, который подается в него), но я явно не уверен в этом. Итак, я попробовал другой подход:

instance FromJSON Foo where 
    parseJSON (Object o) = 
    (Foo . filter (\(k,_) -> k `elem` toIgnore)) <$> 
     parseJSON (Object o) 
    where 
     toIgnore = ["foo", "bar"] 
    parseJSON _ = empty 

Но это также кажется причиной тупиковой/пространство утечки (не уверен точно, что диагностировать эту остановку исполнения). Каким будет рекомендованный способ принять все кроме несколько ключей объекта? Мне нужно сопоставить шаблон по структуре (Object o), потому что я вручную просматриваю o .: "foo" и o .: "bar" в другом компоненте для моего типа данных. В идеале я хотел бы просто удалить эти ключи из содержания и продолжить синтаксический анализ, потому что я уже учёл их (отсюда - «остальное»).

Есть ли надежда?

Answer 1

Для вашего PartialAppContact примера здесь является более приземленным подходом, который, кажется, работает:

{-# LANGUAGE OverloadedStrings, QuasiQuotes #-} 

import Data.Aeson 
import qualified Data.Text as T 
import qualified Data.HashMap.Strict as HM 
import Control.Monad 
import Text.Heredoc 

type RequiredField = String 
type OptionalField = String 

data PartialAppContact = PartialAppContact 
    { partialAppContactRequired :: [(RequiredField, String)] 
    , partialAppContactOptional :: [(OptionalField, Maybe String)] 
    } deriving (Show, Eq) 

instance FromJSON PartialAppContact where 
    parseJSON (Object o) = do 
    let required = [ "firstName", "lastName", "email", "phoneNumber" ] 
    reqPairs <- forM required $ \k -> do 
     v <- o .: k 
     s <- parseJSON v 
     return (T.unpack k, s) 
    nonReqPairs <- forM [ (k,v) | (k,v) <- HM.toList o, k `notElem` required ] $ \(k,v) -> do 
     s <- parseJSON v 
     return (T.unpack k, s) 
    return $ PartialAppContact reqPairs nonReqPairs 

test1 = Data.Aeson.eitherDecode "{\"firstName\":\"Athan'\"}" :: Either String PartialAppContact 

input = [str| 
| { "firstName": "a first name" 
| , "lastName": "a last name" 
| , "email": "asasd@asd.com" 
| , "phoneNumber": "123-123-123" 
| , "another field": "blah blah" } 
|] 

test2 = Data.Aeson.eitherDecode "{\"firstName\":\"Athan'\" }" :: Either String PartialAppContact 

test3 = Data.Aeson.eitherDecode input :: Either String PartialAppContact 

Обновления

Исходя из ваших комментариев, считает эту идею для написания экземпляра:

import Data.List (partition) 

instance FromJSON PartialAppContact where 
    parseJSON (Object o) = do 
    let required = [ "firstName", "lastName", "email", "phoneNumber" ] 
    let (group1, group2) = partition (\(k,_) -> k `elem` required) (HM.toList o) 
    reqFields <- forM group1 $ \(k,v) -> do s <- parseJSON v; return (T.unpack k, s) 
    otherFields <- forM group2 (\(k,v) -> (T.unpack k,) <$> parseJSON v) 
    return $ PartialAppContact reqFields otherFields 

Answer 2

Я нашел, что для выполнения работы требуется использование (.:?), чтобы исправить y реализация опционально, известно полей. Оттуда, вы можете свободно разложить HashMap и повторно parseJSON это подполь:

instance FromJSON Foo where 
    parseJSON (Object o) = do 
    mfoo <- o .:? "foo" 
    mbar <- o .:? "bar" 
    let foundFields = catMaybes [mfoo, mbar] 
    rest <- mapM (\(k,v) -> (T.unpack k,) <$> parseJSON v) 
       (toList theRest) 
    return $ Foo rest -- assuming you're done with `foundFields` 
    where 
     theRest = foldr HM.delete o ["foo", "bar"] 

Чтобы увидеть окончательные реализации обсуждаемого вопроса в комментариях, see this commit.