Hello everyone! first post here. I'm working through YAHT and Real World Haskell sort of in parallel. I have a somewhat related question. Assume we have a binary operator which is not a higher order function. The "greater than" relation for example: Prelude List> :t (>) (>) :: forall a. (Ord a) => a -> a -> Bool Type classes and variables make sense - I assume since we have quantifiers, the type classes must be essentially predicates, and the type variables are bound to them as expected. Also I assume whenever we see (a -> b) this means roughly f:(<domain> -> <codomain>) a -> a -> Bool could therefore mean either: "a function whose domain is an 'a' and whose codomain is a function from a to bool"; or "a function which takes a function from type 'a' to 'a' and returns a bool. According to YAHT: "NOTE The parentheses are not necessary; in function types, if you have a -> b -> y it is assume that b -> y is grouped. If you want the other way, with a -> b grouped, you need to put parentheses around them." I'm confused by this. A function which takes multiple arguments should be equivalent to a predicate bound to some n-tuple. Or in this case of a binary infix operator, equivalent to a prefix operator which takes a tuple. But, (a, a) is not equivalent to (a -> a), and (a -> Bool) just doesn't make sense as a range. It should be something like: (>) :: forall a. (Ord a) => (a, a) -> Bool Someone on freenode told me that if you had: foo :: a -> b bar :: b -> c baz :: c -> d and: bork = (baz . bar . foo) then: bork :: a -> d Which, if correct means Haskell should always chain types for first-order functions. And since (>) is transitive, it should satisfy ∀x∀y∀z(((x,y) ∈ R & (y,z) ∈ R) -> (x,z) ∈ R) and omit the case for (y,z). How it is possible to express a function which takes multiple arguments (or any first-order function at all) with more than one arrow/map symbol? How does this even make sense? It gets even worse with more complicated examples: Prelude List> :t foldl foldl :: forall a b. (a -> b -> a) -> a -> [b] -> a Prelude List> :t (>>=) (>>=) :: forall (m :: * -> *) a b. (Monad m) => m a -> (a -> m b) -> m b How do the non-existent associativity rules make complex function types seemingly without enough parentheses have unique meaning? Nearly every example in every tutorial on types I can find has this unexplained phenomenon, or I'm really not reading carefully.