Как использовать парсеры от Aeson с IO

Ну, я не знаю, хорошая ли это идея, и жонглирование дополнительным слоем IO, безусловно, будет чертовски неприятно для более крупных разработок, но следующие проверки типов:

{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE OverloadedStrings #-}
import Control.Applicative
import Data.Aeson
import System.Random

data Example = Example { a :: Int, b :: Int } deriving (Eq, Ord, Read, Show)

instance FromJSON (IO Example) where
    parseJSON = withObject "Example" $ \v -> liftA2 Example
        <$> ((pure <$> (v .: "a")) <|> pure (randomRIO (3, 4)))
        <*> ((pure <$> (v .: "b")) <|> pure (randomRIO (5, 6)))

В каждой из последних двух строк первое pure равно Int -> IO Int, а второе — IO Int -> Parser (IO Int). В ГКИ:

> sequence (decode "{}") :: IO (Maybe Example)
Just (Example {a = 4, b = 6})

Я не знаю хорошей стратегии, чтобы добраться туда, где вы хотите быть, поскольку монада ParseJSON не является преобразователем или основана на IO. Что вам проще сделать, так это декодировать в один тип, а затем перевести во второй, как это было сделано в предыдущем вопросе 'Укажите значение по умолчанию для полей, недоступных в json с помощью aeson'.

Поскольку большие структуры могут быть громоздкими для воспроизведения, вы можете сделать структуру параметризованной и создать ее экземпляр с помощью IO Int или Int. Например, допустим, вам нужно поле a из проводника, а b как случайное из монады IO:

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveTraversable #-}

import Data.Aeson
import System.Random
import Data.ByteString.Lazy (ByteString)

data Example' a =
        Example { a :: Int
                , b :: a
                } deriving (Show,Functor,Foldable,Traversable)

type Partial = Example' (IO Int)

type Example = Example' Int

instance FromJSON Partial where
    parseJSON (Object o) =
        Example <$> o .: "a"
                <*> pure (randomRIO (1,10))

loadExample :: Partial -> IO Example
loadExample = mapM id

parseExample :: ByteString -> IO (Maybe Example)
parseExample = maybe (pure Nothing) (fmap Just . loadExample) . decode

Обратите внимание, как loadExample использует наш экземпляр traverse для выполнения операций ввода-вывода внутри структуры. Вот пример использования:

Main> parseExample "{ \"a\" : 1111 }"
Just (Example {a = 1111, b = 5})

Дополнительно

Если у вас есть более одного типа поля, для которого вы хотите действие ввода-вывода, вы можете либо

1. Сделайте один тип данных для всех. Вместо b типа IO Int вы можете сделать его IO MyComplexRecord. Это простое решение.

2. Более сложное и забавное решение — использовать параметр типа более высокого типа.

Для варианта 2 учтите:

 data Example' f = Example { a :: Int
                           , b :: f Int
                           , c :: f String }

Затем вы можете использовать Proxy и Control.Monad.Identity вместо таких значений, как IO Int и Int, использовавшихся ранее. Вам нужно будет написать свой собственный обход, так как вы не можете получить Traverse для этого класса (именно это дает нам mapM, использованное выше). Мы могли бы создать класс обхода с типом (* -> *) -> *, используя несколько расширений (среди них RankNTypes), но если это не делается часто, и мы не получаем какую-то поддержку вывода или TH, я не думаю, что это стоит того.

Вот еще одно решение, оно требует немного больше ручного труда, но подход довольно прост - сгенерировать случайный IO Example использовать его для генерации случайного "парсера". Декодирование в JSON выполняется обычной функцией decode.

{-# LANGUAGE OverloadedStrings #-}
module Test where

import Data.Aeson
import Data.Aeson.Types
import System.Random

data Example = Example {_a :: Int, _b :: Int} deriving (Show, Ord, Eq)

getExample :: IO (Value -> Maybe Example)
getExample = do
 ex <- randomRIO (Example 1 1, Example 10 100)
 let ex' = withObject "Example" $ \o ->
             do a <- o .:? "a" .!= _a ex
                b <- o .:? "b" .!= _b ex
                return $ Example a b
 return (parseMaybe ex')

instance Random Example where
    randomRIO (low,hi) = Example <$> randomRIO (_a low,_a hi)
                                 <*> randomRIO (_b low,_b hi)
...

main :: IO ()
main = do
    getExample' <- getExample
    let example = getExample' =<< decode "{\"a\": 20}"
    print example

Я не уверен, но я считаю, что это более подробная реализация решения @DanielWagner.