{-# LANGUAGE PatternGuards #-}

module System.Console.CmdArgs.Implicit.Reader(Reader(..), reader) where

import Data.Generics.Any
import qualified Data.Generics.Any.Prelude as A
import System.Console.CmdArgs.Explicit
import Data.Char
import Data.Int
import Data.Word
import Data.List
import Data.Maybe


data Reader = Reader
    {Reader -> [Char]
readerHelp :: String
    ,Reader -> Bool
readerBool :: Bool
    ,Reader -> Int
readerParts :: Int
    ,Reader -> Any -> Any
readerFixup :: Any -> Any -- If a list, then 'reverse', otherwise nothing, so we can build up using cons in O(n)
    ,Reader -> Any -> [Char] -> Either [Char] Any
readerRead :: Any -> String -> Either String Any
    }

-- reader has an actual value of type Any that can be inspected
-- reader_ has a value of type _|_ instead
readerRead_ :: Reader -> [Char] -> Either [Char] Any
readerRead_ Reader
r = Reader -> Any -> [Char] -> Either [Char] Any
readerRead Reader
r (Any -> [Char] -> Either [Char] Any)
-> Any -> [Char] -> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ [Char] -> Any
forall a. HasCallStack => [Char] -> a
error [Char]
"Invariant broken: reader/reader_"


reader :: Any -> Maybe Reader
reader :: Any -> Maybe Reader
reader Any
x | Any -> Bool
A.isList Any
x Bool -> Bool -> Bool
&& Bool -> Bool
not (Any -> Bool
A.isString Any
x) = do
    r <- Any -> Maybe Reader
reader_ (Any -> Maybe Reader) -> Any -> Maybe Reader
forall a b. (a -> b) -> a -> b
$ Any -> Any
A.fromList Any
x
    return r{readerRead = \Any
o [Char]
s -> (Any -> Any) -> Either [Char] Any -> Either [Char] Any
forall a b. (a -> b) -> Either [Char] a -> Either [Char] b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Any -> Any -> Any
forall a. Any -> Any -> Any
`A.cons` Any
o) (Either [Char] Any -> Either [Char] Any)
-> Either [Char] Any -> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ Reader -> [Char] -> Either [Char] Any
readerRead_ Reader
r [Char]
s, readerFixup = A.reverse}
reader Any
x | Any -> Bool
isAlgType Any
x, [[Char]
ctor] <- Any -> [[Char]]
ctors Any
x, [Any
child] <- Any -> [Any]
children Any
x = do
    -- newtype wrapper, just forward it
    r <- Any -> Maybe Reader
reader Any
child
    let down = [Any] -> Any
forall a. HasCallStack => [a] -> a
head ([Any] -> Any) -> (Any -> [Any]) -> Any -> Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Any -> [Any]
children
    let up Any
o Any
c = Any -> [Any] -> Any
recompose Any
o [Any
c]
    return r{readerFixup = \Any
x -> Any -> Any -> Any
up Any
x (Any -> Any) -> Any -> Any
forall a b. (a -> b) -> a -> b
$ Reader -> Any -> Any
readerFixup Reader
r (Any -> Any) -> Any -> Any
forall a b. (a -> b) -> a -> b
$ Any -> Any
down Any
x
            ,readerRead = \Any
x -> ([Char] -> Either [Char] Any)
-> (Any -> Either [Char] Any)
-> Either [Char] Any
-> Either [Char] Any
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either [Char] -> Either [Char] Any
forall a b. a -> Either a b
Left (Any -> Either [Char] Any
forall a b. b -> Either a b
Right (Any -> Either [Char] Any)
-> (Any -> Any) -> Any -> Either [Char] Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Any -> Any -> Any
up Any
x) (Either [Char] Any -> Either [Char] Any)
-> ([Char] -> Either [Char] Any) -> [Char] -> Either [Char] Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Reader -> Any -> [Char] -> Either [Char] Any
readerRead Reader
r (Any -> Any
down Any
x)
            }
reader Any
x = Any -> Maybe Reader
reader_ Any
x


reader_ :: Any -> Maybe Reader
reader_ :: Any -> Maybe Reader
reader_ Any
x | Any -> Bool
A.isString Any
x = Reader -> Maybe Reader
forall a. a -> Maybe a
Just (Reader -> Maybe Reader) -> Reader -> Maybe Reader
forall a b. (a -> b) -> a -> b
$ [Char]
-> Bool
-> Int
-> (Any -> Any)
-> (Any -> [Char] -> Either [Char] Any)
-> Reader
Reader [Char]
"ITEM" Bool
False Int
1 Any -> Any
forall a. a -> a
id ((Any -> [Char] -> Either [Char] Any) -> Reader)
-> (Any -> [Char] -> Either [Char] Any) -> Reader
forall a b. (a -> b) -> a -> b
$ ([Char] -> Either [Char] Any) -> Any -> [Char] -> Either [Char] Any
forall a b. a -> b -> a
const (([Char] -> Either [Char] Any)
 -> Any -> [Char] -> Either [Char] Any)
-> ([Char] -> Either [Char] Any)
-> Any
-> [Char]
-> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ Any -> Either [Char] Any
forall a b. b -> Either a b
Right (Any -> Either [Char] Any)
-> ([Char] -> Any) -> [Char] -> Either [Char] Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Any
forall a. Data a => a -> Any
Any


reader_ Any
x | Any -> [Char]
typeName Any
x [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"Bool" = Reader -> Maybe Reader
forall a. a -> Maybe a
Just (Reader -> Maybe Reader) -> Reader -> Maybe Reader
forall a b. (a -> b) -> a -> b
$ [Char]
-> Bool
-> Int
-> (Any -> Any)
-> (Any -> [Char] -> Either [Char] Any)
-> Reader
Reader [Char]
"BOOL" Bool
True Int
1 Any -> Any
forall a. a -> a
id ((Any -> [Char] -> Either [Char] Any) -> Reader)
-> (Any -> [Char] -> Either [Char] Any) -> Reader
forall a b. (a -> b) -> a -> b
$ ([Char] -> Either [Char] Any) -> Any -> [Char] -> Either [Char] Any
forall a b. a -> b -> a
const (([Char] -> Either [Char] Any)
 -> Any -> [Char] -> Either [Char] Any)
-> ([Char] -> Either [Char] Any)
-> Any
-> [Char]
-> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ \[Char]
s ->
    Either [Char] Any
-> (Bool -> Either [Char] Any) -> Maybe Bool -> Either [Char] Any
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Char] -> Either [Char] Any
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Any) -> [Char] -> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ [Char]
"Could not read as boolean, " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
s) (Any -> Either [Char] Any
forall a b. b -> Either a b
Right (Any -> Either [Char] Any)
-> (Bool -> Any) -> Bool -> Either [Char] Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Any
forall a. Data a => a -> Any
Any) (Maybe Bool -> Either [Char] Any)
-> Maybe Bool -> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ [Char] -> Maybe Bool
parseBool [Char]
s


reader_ Any
x | Reader
res:[Reader]
_ <- [Maybe Reader] -> [Reader]
forall a. [Maybe a] -> [a]
catMaybes
    [[Char] -> Integer -> Maybe Reader
forall {a}. (Data a, Read a) => [Char] -> a -> Maybe Reader
f [Char]
"INT" (Integer
0::Integer), [Char] -> Float -> Maybe Reader
forall {a}. (Data a, Read a) => [Char] -> a -> Maybe Reader
f [Char]
"NUM" (Float
0::Float), [Char] -> Double -> Maybe Reader
forall {a}. (Data a, Read a) => [Char] -> a -> Maybe Reader
f [Char]
"NUM" (Double
0::Double)
    ,[Char] -> Int -> Maybe Reader
forall {a}. (Data a, Read a) => [Char] -> a -> Maybe Reader
f [Char]
"INT" (Int
0::Int), [Char] -> Int8 -> Maybe Reader
forall {a}. (Data a, Read a) => [Char] -> a -> Maybe Reader
f [Char]
"INT" (Int8
0::Int8), [Char] -> Int16 -> Maybe Reader
forall {a}. (Data a, Read a) => [Char] -> a -> Maybe Reader
f [Char]
"INT" (Int16
0::Int16), [Char] -> Int32 -> Maybe Reader
forall {a}. (Data a, Read a) => [Char] -> a -> Maybe Reader
f [Char]
"INT" (Int32
0::Int32), [Char] -> Int64 -> Maybe Reader
forall {a}. (Data a, Read a) => [Char] -> a -> Maybe Reader
f [Char]
"INT" (Int64
0::Int64)
    ,[Char] -> Word -> Maybe Reader
forall {a}. (Data a, Read a) => [Char] -> a -> Maybe Reader
f [Char]
"NAT" (Word
0::Word), [Char] -> Word8 -> Maybe Reader
forall {a}. (Data a, Read a) => [Char] -> a -> Maybe Reader
f [Char]
"NAT" (Word8
0::Word8), [Char] -> Word16 -> Maybe Reader
forall {a}. (Data a, Read a) => [Char] -> a -> Maybe Reader
f [Char]
"NAT" (Word16
0::Word16), [Char] -> Word32 -> Maybe Reader
forall {a}. (Data a, Read a) => [Char] -> a -> Maybe Reader
f [Char]
"NAT" (Word32
0::Word32), [Char] -> Word64 -> Maybe Reader
forall {a}. (Data a, Read a) => [Char] -> a -> Maybe Reader
f [Char]
"NAT" (Word64
0::Word64)
    ] = Reader -> Maybe Reader
forall a. a -> Maybe a
Just Reader
res
    where
        ty :: TypeRep
ty = Any -> TypeRep
typeOf Any
x
        f :: [Char] -> a -> Maybe Reader
f [Char]
hlp a
t | Any -> TypeRep
typeOf (a -> Any
forall a. Data a => a -> Any
Any a
t) TypeRep -> TypeRep -> Bool
forall a. Eq a => a -> a -> Bool
/= TypeRep
ty = Maybe Reader
forall a. Maybe a
Nothing
                | Bool
otherwise = Reader -> Maybe Reader
forall a. a -> Maybe a
Just (Reader -> Maybe Reader) -> Reader -> Maybe Reader
forall a b. (a -> b) -> a -> b
$ [Char]
-> Bool
-> Int
-> (Any -> Any)
-> (Any -> [Char] -> Either [Char] Any)
-> Reader
Reader [Char]
hlp Bool
False Int
1 Any -> Any
forall a. a -> a
id ((Any -> [Char] -> Either [Char] Any) -> Reader)
-> (Any -> [Char] -> Either [Char] Any) -> Reader
forall a b. (a -> b) -> a -> b
$ ([Char] -> Either [Char] Any) -> Any -> [Char] -> Either [Char] Any
forall a b. a -> b -> a
const (([Char] -> Either [Char] Any)
 -> Any -> [Char] -> Either [Char] Any)
-> ([Char] -> Either [Char] Any)
-> Any
-> [Char]
-> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ \[Char]
s -> case ReadS a
forall a. Read a => ReadS a
reads [Char]
s of
            [(a
x,[Char]
"")] -> Any -> Either [Char] Any
forall a b. b -> Either a b
Right (Any -> Either [Char] Any) -> Any -> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ a -> Any
forall a. Data a => a -> Any
Any (a -> Any) -> a -> Any
forall a b. (a -> b) -> a -> b
$ a
x a -> a -> a
forall a. a -> a -> a
`asTypeOf` a
t
            [(a, [Char])]
_ -> [Char] -> Either [Char] Any
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Any) -> [Char] -> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ [Char]
"Could not read as type " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ TypeRep -> [Char]
forall a. Show a => a -> [Char]
show (Any -> TypeRep
typeOf (Any -> TypeRep) -> Any -> TypeRep
forall a b. (a -> b) -> a -> b
$ a -> Any
forall a. Data a => a -> Any
Any a
t) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
", " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
s


reader_ Any
x | Any -> Bool
A.isList Any
x = do
    r <- Any -> Maybe Reader
reader_ (Any -> Maybe Reader) -> Any -> Maybe Reader
forall a b. (a -> b) -> a -> b
$ Any -> Any
A.fromList Any
x
    return $ r{readerRead = const $ fmap (A.list_ x) . readerRead_ r}


reader_ Any
x | Any -> Bool
A.isMaybe Any
x = do
    r <- Any -> Maybe Reader
reader_ (Any -> Maybe Reader) -> Any -> Maybe Reader
forall a b. (a -> b) -> a -> b
$ Any -> Any
A.fromMaybe Any
x
    return $ r{readerRead = const $ fmap (A.just_ x) . readerRead_ r}


reader_ Any
x | Any -> Bool
isAlgType Any
x Bool -> Bool -> Bool
&& [([Char], Any)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [([Char], Any)]
xs Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 Bool -> Bool -> Bool
&& (([Char], Any) -> Bool) -> [([Char], Any)] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
(==) Int
0 (Int -> Bool) -> (([Char], Any) -> Int) -> ([Char], Any) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Any -> Int
arity (Any -> Int) -> (([Char], Any) -> Any) -> ([Char], Any) -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char], Any) -> Any
forall a b. (a, b) -> b
snd) [([Char], Any)]
xs
    = Reader -> Maybe Reader
forall a. a -> Maybe a
Just (Reader -> Maybe Reader) -> Reader -> Maybe Reader
forall a b. (a -> b) -> a -> b
$ [Char]
-> Bool
-> Int
-> (Any -> Any)
-> (Any -> [Char] -> Either [Char] Any)
-> Reader
Reader ((Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toUpper ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ Any -> [Char]
typeShell Any
x) (Any -> [Char]
typeName Any
x [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"Bool") Int
1 Any -> Any
forall a. a -> a
id ((Any -> [Char] -> Either [Char] Any) -> Reader)
-> (Any -> [Char] -> Either [Char] Any) -> Reader
forall a b. (a -> b) -> a -> b
$ ([Char] -> Either [Char] Any) -> Any -> [Char] -> Either [Char] Any
forall a b. a -> b -> a
const (([Char] -> Either [Char] Any)
 -> Any -> [Char] -> Either [Char] Any)
-> ([Char] -> Either [Char] Any)
-> Any
-> [Char]
-> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ [Char] -> Either [Char] Any
rd ([Char] -> Either [Char] Any)
-> ([Char] -> [Char]) -> [Char] -> Either [Char] Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower
    where
        xs :: [([Char], Any)]
xs = [((Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower [Char]
c, Any -> [Char] -> Any
compose0 Any
x [Char]
c) | [Char]
c <- Any -> [[Char]]
ctors Any
x]

        rd :: [Char] -> Either [Char] Any
rd [Char]
s | [([Char], Any)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [([Char], Any)]
ys = [Char] -> Either [Char] Any
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Any) -> [Char] -> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ [Char]
"Could not read " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
s [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
", expected one of: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
unwords ((([Char], Any) -> [Char]) -> [([Char], Any)] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ([Char], Any) -> [Char]
forall a b. (a, b) -> a
fst [([Char], Any)]
xs)
             | Just ([Char]
_,Any
x) <- (([Char], Any) -> Bool) -> [([Char], Any)] -> Maybe ([Char], Any)
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ([Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
(==) [Char]
s ([Char] -> Bool)
-> (([Char], Any) -> [Char]) -> ([Char], Any) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char], Any) -> [Char]
forall a b. (a, b) -> a
fst) [([Char], Any)]
ys = Any -> Either [Char] Any
forall a b. b -> Either a b
Right Any
x
             | [([Char], Any)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [([Char], Any)]
ys Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 = [Char] -> Either [Char] Any
forall a b. a -> Either a b
Left ([Char] -> Either [Char] Any) -> [Char] -> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ [Char]
"Ambiguous read for " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
s [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
", could be any of: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
unwords ((([Char], Any) -> [Char]) -> [([Char], Any)] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ([Char], Any) -> [Char]
forall a b. (a, b) -> a
fst [([Char], Any)]
ys)
             | Bool
otherwise = Any -> Either [Char] Any
forall a b. b -> Either a b
Right (Any -> Either [Char] Any) -> Any -> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ ([Char], Any) -> Any
forall a b. (a, b) -> b
snd (([Char], Any) -> Any) -> ([Char], Any) -> Any
forall a b. (a -> b) -> a -> b
$ [([Char], Any)] -> ([Char], Any)
forall a. HasCallStack => [a] -> a
head [([Char], Any)]
ys
            where ys :: [([Char], Any)]
ys = (([Char], Any) -> Bool) -> [([Char], Any)] -> [([Char], Any)]
forall a. (a -> Bool) -> [a] -> [a]
filter ([Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
isPrefixOf [Char]
s ([Char] -> Bool)
-> (([Char], Any) -> [Char]) -> ([Char], Any) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char], Any) -> [Char]
forall a b. (a, b) -> a
fst) [([Char], Any)]
xs


reader_ Any
x | Any -> Bool
isAlgType Any
x, [[Char]
c] <- Any -> [[Char]]
ctors Any
x, Any
x <- Any -> [Char] -> Any
compose0 Any
x [Char]
c = do
    let cs :: [Any]
cs = Any -> [Any]
children Any
x
    rs <- (Any -> Maybe Reader) -> [Any] -> Maybe [Reader]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Any -> Maybe Reader
reader_ [Any]
cs
    let n = [Int] -> Int
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Int] -> Int) -> [Int] -> Int
forall a b. (a -> b) -> a -> b
$ (Reader -> Int) -> [Reader] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map Reader -> Int
readerParts [Reader]
rs
    return $ Reader (uncommas $ map readerHelp rs) (map readerBool rs == [True]) n id $ const $ \[Char]
s ->
        let ss :: [[Char]]
ss = [Char] -> [[Char]]
commas [Char]
s in
        if Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 then (Any -> Any) -> Either [Char] Any -> Either [Char] Any
forall a b. (a -> b) -> Either [Char] a -> Either [Char] b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Any -> [Any] -> Any
recompose Any
x ([Any] -> Any) -> (Any -> [Any]) -> Any -> Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Any -> [Any]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return) (Either [Char] Any -> Either [Char] Any)
-> Either [Char] Any -> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ Reader -> [Char] -> Either [Char] Any
readerRead_ ([Reader] -> Reader
forall a. HasCallStack => [a] -> a
head ([Reader] -> Reader) -> [Reader] -> Reader
forall a b. (a -> b) -> a -> b
$ (Reader -> Bool) -> [Reader] -> [Reader]
forall a. (a -> Bool) -> [a] -> [a]
filter (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
(==) Int
1 (Int -> Bool) -> (Reader -> Int) -> Reader -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Reader -> Int
readerParts) [Reader]
rs) [Char]
s
        else if [[Char]] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Char]]
ss Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
n then [Char] -> Either [Char] Any
forall a b. a -> Either a b
Left [Char]
"Incorrect number of commas for fields"
        else ([Any] -> Any) -> Either [Char] [Any] -> Either [Char] Any
forall a b. (a -> b) -> Either [Char] a -> Either [Char] b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Any -> [Any] -> Any
recompose Any
x) (Either [Char] [Any] -> Either [Char] Any)
-> Either [Char] [Any] -> Either [Char] Any
forall a b. (a -> b) -> a -> b
$ [Either [Char] Any] -> Either [Char] [Any]
forall {a} {a}. [Either a a] -> Either a [a]
sequenceEither ([Either [Char] Any] -> Either [Char] [Any])
-> [Either [Char] Any] -> Either [Char] [Any]
forall a b. (a -> b) -> a -> b
$ (Reader -> [Char] -> Either [Char] Any)
-> [Reader] -> [[Char]] -> [Either [Char] Any]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Reader -> [Char] -> Either [Char] Any
readerRead_ [Reader]
rs ([[Char]] -> [Either [Char] Any])
-> [[Char]] -> [Either [Char] Any]
forall a b. (a -> b) -> a -> b
$ ([[Char]] -> [Char]) -> [[[Char]]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map [[Char]] -> [Char]
uncommas ([[[Char]]] -> [[Char]]) -> [[[Char]]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Int] -> [[Char]] -> [[[Char]]]
forall {a}. [Int] -> [a] -> [[a]]
takes ((Reader -> Int) -> [Reader] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map Reader -> Int
readerParts [Reader]
rs) [[Char]]
ss


reader_ Any
_ = Maybe Reader
forall a. Maybe a
Nothing


uncommas :: [[Char]] -> [Char]
uncommas = [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
","
commas :: [Char] -> [[Char]]
commas = [Char] -> [[Char]]
lines ([Char] -> [[Char]]) -> ([Char] -> [Char]) -> [Char] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map (\Char
x -> if Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
',' then Char
'\n' else Char
x)


takes :: [Int] -> [a] -> [[a]]
takes [] [a]
_ = []
takes (Int
i:[Int]
is) [a]
xs = [a]
a [a] -> [[a]] -> [[a]]
forall a. a -> [a] -> [a]
: [Int] -> [a] -> [[a]]
takes [Int]
is [a]
b
    where ([a]
a,[a]
b) = Int -> [a] -> ([a], [a])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
i [a]
xs

sequenceEither :: [Either a a] -> Either a [a]
sequenceEither = (Either a a -> Either a [a] -> Either a [a])
-> Either a [a] -> [Either a a] -> Either a [a]
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Either a a -> Either a [a] -> Either a [a]
forall {a} {a}. Either a a -> Either a [a] -> Either a [a]
f ([a] -> Either a [a]
forall a b. b -> Either a b
Right [])
    where f :: Either a a -> Either a [a] -> Either a [a]
f (Left a
x) Either a [a]
_ = a -> Either a [a]
forall a b. a -> Either a b
Left a
x
          f Either a a
_ (Left a
x) = a -> Either a [a]
forall a b. a -> Either a b
Left a
x
          f (Right a
x) (Right [a]
xs) = [a] -> Either a [a]
forall a b. b -> Either a b
Right (a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
xs)