This is exactly what I did, but it doesn't give me a systematic way to evaluate the expressions.
In other words, I don't really know why it works or what else to try in different circumstances.
The problem arises when I have curried multi-argument functions.

People complain about pointer notation in type declarations in C. Well, this is pointer notation++.
And it is worse if I can't find resources to learn it.

Eventually, I would like to be able to grok famous beasts like this one.
foldl :: (a -> b -> a) -> a -> [b] -> a
foldl f a bs =
   foldr (\b g x -> g (f x b)) id bs a
But I need a consistent approach.


Cheers,


Dimitri


Em 20/08/14 04:10, John Wiegley escreveu:
Dimitri DeFigueiredo <defigueiredo@ucdavis.edu> writes:


      

        
Here's a simple exercise from Stephanie Weirich's class [1] that I am having
a hard time with.


      

      

      

        
consider


      

      

      

        
doTwice :: (a -> a) -> a -> a
doTwice f x = f (f x)


      

      

      

        
what does this do?


      

      

      

        
ex1 :: (a -> a) -> a -> a
ex1 = doTwice doTwice


      

      
Another way to write doTwice is:

    doTwice :: (a -> a) -> (a -> a)
    doTwice f = \x -> f (f x)

This is equivalent.  If you stare it for a while, it should answer the rest of
your questions.

John
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://www.haskell.org/mailman/listinfo/beginners