How does the function embeded in runParse of RWH get parameter with type ParseState?

Question

After reading LYAH's Chapter 08 and SO questions (1, 2) about Real World Haskell's Parse definition:

newtype Parse a = Parse {
runParse :: ParseState -> Either String (a, ParseState) }

For me, now I think it is a key understanding how runParse is evaluated when runParse is viewed as a function.

(1) ghci> :t runParse will get

runParse :: Parse a -> ParseState -> Either String (a, ParseState)

(2) For trying runParse, similar to RWH's The identity Parser , I used the following example:

ghci> runParse (Parse (\s -> Right (1,s))) (ParseState (L8.pack "") 0)

I got the result:

Right (1,ParseState {string = "", offset = 0})

I can guess that the above evaluation is that (Parse (\s -> Right (1,s))) and (ParseState (L8.pack "") 0) first are parameters of runParse and anonymous function (\s -> Right (1, s)) uses (ParseState (L8.pack "") 0) as its parameter . But this guess makes me confused:

Why (ParseState (L8.pack "") 0) is used as (\s -> Right (1, s)) 's parameter during evaluating? How does the whole runParse eval finish?

Also, I can write an alternative function for a simple definition, such as in LYAH:

newtype CharList = CharList {getCharList :: [Char]}

For this, CharList and getCharList can be defined as:

newtype CharList = CharList [Char]

getCharList :: CharList -> [Char]
getCharList cl = case cl of
    CharList x -> x

So, in the first definition for CharList, it is sure that there exists a pattern match. If I can implement a explicit function with pattern match like this for the previous runParse I will understand it. But I don't know how to do it?

runParse simple retrieves a value from a record. runParse (Parse (\s -> Right (1,s))) is exactly equal to \s -> Right (1,s). After that, it is just regular function application. — user2407038
– user2407038, Commented Nov 2, 2014 at 4:45
@user2407038 thanks! Why these exists such a equation relations? where I can get a relative reference? — abelard2008
– abelard2008, Commented Nov 2, 2014 at 4:51

abelard2008 · Accepted Answer · 2014-11-02 12:36:35Z

1

After several hours, I think I can answer this myself.

Because runParse is a function with two parameters:

runParse :: Parse a -> ParseState -> Either String (a, ParseState)

After reviewing Partial Function Application principal RWH descriped : In Haskell, all functions take only one argument. I know that

ghci> runParse (Parse (\s -> Right (1,s))) (ParseState (L8.pack "") 0)

and :

ghci> let y = runParse (Parse (\s -> Right (1,s)))
ghci> y (ParseState (L8.pack "") 0)

are the same, and in ghci this evaluation must be divided into two steps:

(1) evaluating the function runParse with a parameter Parse a, which returns a function with a parameter with type ParseState, if Parse a is (Parse (\s -> Right (1,s))) , according to the simplest example in LYAH:

ghci> newtype CharList = CharList {getCharList :: [Char]}
ghci> getCharList (CharList "ab")
"ab"

so the result of executing

runParse (Parse (\s -> Right (1,s))) is (\s -> Right (1,s)), and it is verified from the fact: the type of ghci> :t runParse (Parse (\s -> Right (1,s))) is

runParse (Parse (\s -> Right (1,s))) :: Num a => ParseState -> Either String (a, ParseState)

(2) after difficult step (1) for me, I get a function called y in this case, which needs a parameter with a type ParseState, y (ParseState (L8.pack "") 0) will get a predicated result: Right (1,ParseState {string = "", offset = 0})

I need keep it in mind that , for a function with more than one parameters, either you give all parameters one time or you give one parameter one time, the function's evaluation flow always includes the same amount as the number of parameters of steps and every step evaluates a function with one parameter.

answered Nov 2, 2014 at 12:36

abelard2008

2,0841 gold badge21 silver badges37 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

daniel gratzer Over a year ago

A few thoughts: runParse is defined just as you thought: runParse (Parse f) = f so runParser (Parse p) a = p a which means in you example the entire thing ends in Right (1, ... the state ...) which is indeed what we see

Collectives™ on Stack Overflow

How does the function embeded in runParse of RWH get parameter with type ParseState?

1 Answer 1

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related