CODEWITHSUNDEEP
haskell
RandomB
RandomB

Reputation: 3737

Read of types sum

When I want to read string to type A I write read str::A. Consider, I want to have generic function which can read string to different types, so I want to write something like read str::A|||B|||C or something similar. The only thing I could think of is:

{-# LANGUAGE TypeOperators #-}
infixr 9 |||
data a ||| b = A a|B b deriving Show
-- OR THIS:
-- data a ||| b = N | A a (a ||| b) | B b (a ||| b) deriving (Data, Show)

instance (Read a, Read b) => Read (a ||| b) where
  readPrec = parens $ do
    a <- (A <$> readPrec) <|> (B <$> readPrec)
    -- OR:
    -- a <- (flip A N <$> readPrec) <|> (flip B N <$> readPrec)
    return a

And if I want to read something:

> read "'a'"::Int|||Char|||String
B (A 'a')

But what to do with such weird type? I want to fold it to Int or to Char or to String... Or to something another but "atomic" (scalar/simple). Final goal is to read strings like "1,'a'" to list-like [D 1, D 'a']. And main constraint here is that structure is flexible, so string can be "1, 'a'" or "'a', 1" or "\"xxx\", 1, 2, 'a'". I know how to read something separated with delimiter, but this something should be passed as type, not as sum of types like C Char|I Int|S String|etc. Is it possible? Or no way to accomplish it without sum of types?

Upvotes: 1

Views: 247

Answers (1)

Davislor
Davislor

Reputation: 15134

There’s no way to do this in general using read, because the same input string might parse correctly to more than one of the valid types. You could, however, do this with a function like Text.Read.readMaybe, which returns Nothing on ambiguous input. You might also return a tuple or list of the valid interpretations, or have a rule for which order to attempt to parse the types in, such as: attempt to parse each type in the order they were declared.

Here’s some example code, as proof of concept:

import Data.Maybe (catMaybes, fromJust, isJust, isNothing)
import qualified Text.Read

data AnyOf3 a b c = FirstOf3 a | SecondOf3 b | ThirdOf3 c

instance (Show a, Show b, Show c) => Show (AnyOf3 a b c) where
  show (FirstOf3 x) = show x -- Can infer the type from the pattern guard.
  show (SecondOf3 x) = show x
  show (ThirdOf3 x) = show x

main :: IO ()
main =
 (putStrLn . unwords . map show . catMaybes . map readDBS)
   ["True", "2", "\"foo\"", "bar"] >>
 (putStrLn . unwords . map show . readIID) "100"

readMaybe' :: (Read a, Read b, Read c) => String -> Maybe (AnyOf3 a b c)
-- Based on the function from Text.Read
readMaybe' x | isJust a && isNothing b && isNothing c =
  (Just . FirstOf3 . fromJust) a -- Can infer the type of a from this.
             | isNothing a && isJust b && isNothing c =
  (Just . SecondOf3 . fromJust) b -- Can infer the type of b from this.
             | isNothing a && isNothing b && isJust c =
  (Just . ThirdOf3 . fromJust) c -- Can infer the type of c from this.
             | otherwise                              = Nothing
  where a = Text.Read.readMaybe x
        b = Text.Read.readMaybe x
        c = Text.Read.readMaybe x

readDBS :: String -> Maybe (AnyOf3 Double Bool String)
readDBS = readMaybe'

readToList :: (Read a, Read b, Read c) => String -> [AnyOf3 a b c]
readToList x = repack FirstOf3 x ++ repack SecondOf3 x ++ repack ThirdOf3 x
  where repack constructor y | isJust z  = [(constructor . fromJust) z]
                             | otherwise = []
          where z = Text.Read.readMaybe y

readIID :: String -> [AnyOf3 Int Integer Double]
readIID = readToList

The first output line echoes every input that parsed successfully, that is, the Boolean constant, the number and the quoted string, but not bar. The second output line echoes every possible interpretation of the input, that is, 100 as an Int, an Integer and a Double.

For something more complicated, you want to write a parser. Haskell has some very good libraries to build them out of combinators. You might look at one such as Parsec. But it’s still helpful to understand what goes on under the hood.

Upvotes: 2

Related Questions