了解功能签名

Question

I was reading a paper and one of the most fundamental parts of it is the following function, written in Haskell:

fixP :: Eq a => (Parser a -> Parser a) -> Parser a
fixP h x = fixS f 
           where f s = h p x 
                       where p y = if x == y then s
                                             else fixP h y

My Haskell is rusty. As I understand it fixP takes 1 argument which is a function Parser a -> Parser a , where a is constrained to have equality defined. However the pattern matches 2 arguments, h and x . What is x referring to?

Additional type signatures involved:

type Parser a = State -> Set (a,State)

type State = String

type Set a = [a]

fixS :: Eq a => (Set a -> Set a) -> Set a

---

After reading and understanding the answer and for anyone interested; here's the same function written in javascript:

function fixP(h) {
    return function(x) {
        var f = function(s) {
            var p = function(y) {
                if(x == y) {
                    return s;
                } else {
                    return fixP(h)(y);
                }
            };
            return h(p)(x);
        };
        return fixS(f);
    };
}

Answer 1

Note that fixP h has type Parser a . Since Parser a is a synonym for State -> Set (a, State) , we see that fixP h is in fact a function:

(fixP h) :: State -> Set (a, State)

We can therefore apply this function to some argument x of type State . That looks like (fixP h) x . Since function application is left associative , (fixP h) x is the same as fixP hx .

In words: To define what fixP is, we define what it does to arguments, ie we define what fixP h is. Since fixP h is itself a function, we need to define it. We define it by specifying what it does to arguments, ie we define what (fixP h) x is. Left associativity of function application means the latter can be written fixP hx .

As to the question "what's x?": Its type is State , so it smells like some sort of parser state, which according to the type synonyms you gave is a string. Exactly what that string's role is, though, is not clear just from the types :)

Answer 2

Simple explanation: Parser a is a type like this:

type Parser a = (String -> a)

This code then

module Main where

type NT a = (Int -> a)

f :: (NT a -> NT a) -> NT a
f h x = undefined

g :: NT Double
g 0 = 0.0
g _ = 1.0

main = undefined

typechecks well.