On Wed, Mar 2, 2011 at 10:09 PM, Karthick Gururaj <karthick.gururaj@gmail.com> wrote:

Hello,

I'm learning Haskell from the extremely well written (and well
illustrated as well!) tutorial - http://learnyouahaskell.com/chapters.
I have couple of questions from my readings so far.

In "typeclasses - 101"
(http://learnyouahaskell.com/types-and-typeclasses#typeclasses-101),
there is a paragraph that reads:
Enum members are sequentially ordered types - they can be enumerated.
The main advantage of the Enum typeclass is that we can use its types
in list ranges. They also have defined successors and predecesors,
which you can get with the succ and pred functions. Types in this
class: (), Bool, Char, Ordering, Int, Integer, Float and Double.

What is the "()" type? Does it refer to a tuple? How can tuple be
ordered, let alone be enum'd?

Any set can be put into an order. That's the well-ordering principle. Basically, the most natural order for pairs is the lexicographical order. There are instances of the form:

instance (Ord a, Ord b) => Ord (a,b)

in GHC.Enum (if you're using GHC). You can also create Enum instances for pairs, but at least one of the "sides" must be bounded. Otherwise, the enumeration will have an uncomputable order-type (something like the order type of the rationals). Check out http://en.wikipedia.org/wiki/Order_type if you're interested in what all that "order type" stuff means.

I wrote an instance for this very purpose the other day:

-- An intuitive way to think about this is in terms of tables. Given datatypes

-- @

-- data X = A | B | C | D deriving ('Bounded', 'Enum', 'Eq', 'Ord', 'Show')

-- data Y = E | F | G deriving ('Bounded', 'Enum', 'Eq', 'Ord', 'Show')

-- @

-- we can form the table

-- @

-- (A, E) (A, F) (A, G)

-- (B, E) (B, F) (B, G)

-- (C, E) (C, F) (C, G)

-- (D, E) (D, F) (D, G)

-- @

-- in a natural lexicographical order. We simply require that there be a finite

-- number of columns, and allow an unbounded number of rows (in so far as the

-- lazy evaluation mechanism allows them). In even more practical terms, we require

-- a finite number of columns because we use that number to perform arithmetic.

instance ( Bounded b

, Enum a

, Enum b

) => Enum (a, b) where

toEnum k = let n = 1 + fromEnum (maxBound :: b) -- Enums are 0 indexed, but we want to

a = toEnum ((k `div` n)) -- divide by the number of elements in a row to find the row and

b = toEnum ((k `mod` n)) -- get the remainder to find the column.

in (a,b)

fromEnum (a, b) = let n = 1 + fromEnum (maxBound :: b)

i = fromEnum a

j = fromEnum b

in (i*n + j)

-- | This instance of 'Enum' is defined in terms of the previous instance. We

-- use the natural equivalence of the types @(a,b,c)@ and @(a,(b,c))@ and use

-- the previous definition. Again, notice that all elements but the first must

-- be bounded.

instance ( Bounded b

, Bounded c

, Enum a

, Enum b

, Enum c

) => Enum (a, b, c) where

fromEnum (a, b, c) = fromEnum (a, (b,c))

toEnum k = let (a, (b, c)) = toEnum k

in (a, b, c)

So tuples are in "Ord" type class atleast. What is the ordering logic?

Lexicographical. Dictionary order.

Another question, on the curried functions - specifically for infix
functions. Suppose I need a function that takes an argument and adds
five to it. I can do:
Prelude> let addFive = (+) 5
Prelude> addFive 4
9

The paragraph: "Infix functions can also be partially applied by using
sections. To section an infix function, simply surround it with
parentheses and only supply a parameter on one side. That creates a
function that takes one parameter and then applies it to the side
that's missing an operand": describes a different syntax. I tried that
as well:

Prelude> let addFive' = (+5)
Prelude> addFive' 3
8

Ok. Works. But on a non-commutative operation like division, we get:
Prelude> let x = (/) 20.0
Prelude> x 10
2.0
Prelude> let y = (/20.0)
Prelude> y 10
0.5

So a curried infix operator fixes the first argument and a "sectioned
infix" operator fixes the second argument?

I guess, except you can section infix operators the other way:

> let twentyover = (20 /)

> twentyover 5

4.0