Question

这个问题是what happens when executing (read "[Red]") :: [Color] under ghci?的延续。从user5402's answer开始，我知道read "[Red]" :: [Color]的执行路径非常复杂，包括readsPrec和readsPrecList。根据@ user5402的评论，readsPrecList会调用readsPrec，因此readsPrec会将[(Red,"]")]返回readsPrecList，然后我们会得到最终结果{来自[Red]的{1}}。但是，我仍然无法理解链接的哪个功能对应于他的readsPrecList及其实现细节。

Answer 1

相关定义可在the Report中找到，如下所示：

read             :: (Read a) => String -> a
read s           =  case [x | (x,t) <- reads s, ("","") <- lex t] of
                         [x] -> x
                         []  -> error "Prelude.read: no parse"
                         _   -> error "Prelude.read: ambiguous parse"

reads            :: (Read a) => ReadS a
reads            =  readsPrec 0

instance  (Read a) => Read [a]  where
    readsPrec p      = readList

class  Read a  where
    readsPrec        :: Int -> ReadS a
    readList         :: ReadS [a]
    readList         = readParen False (\r -> [pr | ("[",s)  <- lex r,
                                                    pr       <- readl s])
                       where readl  s = [([],t)   | ("]",t)  <- lex s] ++
                                        [(x:xs,u) | (x,t)    <- reads s,
                                                    (xs,u)   <- readl' t]
                             readl' s = [([],t)   | ("]",t)  <- lex s] ++
                                        [(x:xs,v) | (",",t)  <- lex s,
                                                    (x,u)    <- reads t,
                                                    (xs,v)   <- readl' u]

readParen        :: Bool -> ReadS a -> ReadS a
readParen b g    =  if b then mandatory else optional
                    where optional r  = g r ++ mandatory r
                          mandatory r = [(x,u) | ("(",s) <- lex r,
                                                 (x,t)   <- optional s,
                                                 (")",u) <- lex t    ]

lex的实现太大而不能包含在这里 - 它使Haskell变得愚蠢。

下面的一个长期的等式推理追溯了完整的评价。我假设Read Color实例的实现是派生的实例。由于此处的兴趣是列表与非列表之间的关联，因此我忽略了在基本类型reads扩展和评估Color的详细信息。

reads "[Red]" :: [([Color], String)]
= { definition of reads }
readsPrec 0 "[Red]"
= { definition of readsPrec @[Color] }
readList "[Red]"
= { definition of readList @Color }
readParen False (\r -> [pr | ("[",s)  <- lex r, pr <- readl s]) "[Red]"
    where readl  s = [([],t)   | ("]",t)  <- lex s] ++
                     [(x:xs,u) | (x,t)    <- reads s,
                                 (xs,u)   <- readl' t]
          readl' s = [([],t)   | ("]",t)  <- lex s] ++
                     [(x:xs,v) | (",",t)  <- lex s,
                                 (x,u)    <- reads t, 
                                 (xs,v)   <- readl' u]
= { definition of readParen }
(\r -> [pr | ("[",s) <- lex r, pr <- readl s] ++ mandatory r) "[Red]"
    where readl  s = [([],t)   | ("]",t)  <- lex s] ++
                     [(x:xs,u) | (x,t)    <- reads s,
                                 (xs,u)   <- readl' t]
          readl' s = [([],t)   | ("]",t)  <- lex s] ++
                     [(x:xs,v) | (",",t)  <- lex s,
                                 (x,u)    <- reads t, 
                                 (xs,v)   <- readl' u]
          mandatory r = [(x,u) | ("(",s) <- lex r,
                                 (x,t)   <- optional s,
                                 (")",u) <- lex t]
= { beta reduction }
[pr | ("[",s) <- lex "[Red]", pr <- readl s] ++ mandatory "[Red]"
    where {- same as before -}
= { evaluation of `mandatory "[Red]"` and `(++)` }
[pr | ("[",s) <- lex "[Red]", pr <- readl s]
    where {- same as before -}
= { lex "[Red]" = [("[", "Red]")] }
[pr | pr <- readl "Red]"]
    where {- same as before -}
= { there's a name for this kind of reduction, but I don't know it }
readl "Red]"
    where {- same as before -}
= { definition of readl }
[([],t)   | ("]",t)  <- lex "Red]"] ++
[(x:xs,u) | (x,t)    <- reads "Red]",
            (xs,u)   <- readl' t]
where
          readl' s = [([],t)   | ("]",t)  <- lex s] ++
                     [(x:xs,v) | (",",t)  <- lex s,
                                 (x,u)    <- reads t, 
                                 (xs,v)   <- readl' u]
= { lex "Red]" = [("Red", "]")] plus evaluation of (++) }
[(x:xs,u) | (x,t)    <- reads "Red]",
            (xs,u)   <- readl' t]
where {- same as before -}
= { reads "Red]" = [(Red, "]")] }
[(Red:xs,u) | (xs,u) <- readl' "]"]
where {- same as before -}
= { definition of readl' }
[(Red:xs,u) | (xs,u) <- [([],t)   | ("]",t)  <- lex "]"] ++
                        [(x:xs,v) | (",",t)  <- lex "]",
                                    (x,u)    <- reads t, 
                                    (xs,v)   <- readl' u]]
where {- same as before -}
= { lex "]" = [("]", "")] }
[(Red:xs,u) | (xs,u) <- [([],"")] ++ []]
= { evaluation of (++) and the list comprehension }
[([Red],"")]

我们可以将此推导用作评估read的构建块，因为这是您的顶级问题。

read "[Red]" :: [Color]
= { definition of read }
case [x | (x,t) <- reads "[Red]", ("","") <- lex t] of
    [x] -> x
    []  -> error "Prelude.read: no parse"
    _   -> error "Prelude.read: ambiguous parse"
= { reads "[Red]" = [([Red], "")] }
case [[Red] | ("","") <- lex ""] of
    [x] -> x
    []  -> error "Prelude.read: no parse"
    _   -> error "Prelude.read: ambiguous parse"
= { lex "" = [("", "")] }
case [[Red]] of
    [x] -> x
    []  -> error "Prelude.read: no parse"
    _   -> error "Prelude.read: ambiguous parse"
= { again there's a name for case reduction but I don't know it }
[Red]

readsPrec和相对函数如何返回[Red]以读取“[Red]”:: [Color]

1 个答案: