November 2006 - Haskell-Cafe

Very Small Program
by Bernie Pope 02 Nov '06

02 Nov '06

On 02/11/2006, at 9:56 PM, ajb(a)spamcop.net wrote: > G'day all. > > Quoting Bernie Pope <bjpop(a)csse.unimelb.edu.au>: > >> This is a weird example of a pattern binding, and it is surprising >> (to me) that the syntax is valid. > > Maybe. But you wouldn't balk at this: > > numzeroes xs = sum [ 1 | 0 <- xs ] > > ...even if you wouldn't naturally express it that way. Patterns like > this are useful in places other than lets. I'd find it more > surprising > if lets were treated as a special case. > >> In this case you are defining the function which is bound to the >> variable called "+". > > Though thanks to n+k patterns, this is well-understood to be a > confusing and controversial case. > >> One would normally expect to see at least one variable inside the >> pattern on the >> left-hand-side of a pattern binding (otherwise what point would there >> be to the >> definition?). > > If the pattern is demanded (as it may well be in a list comprehension > generator, do block generator or a lambda), then it can be very > useful. > The programmer is asking for an error/empty list/monad "fail" if the > conformality check fails. I agree with what you say. When I said "pattern binding", I was using the terminology of the Haskell Report, which means only declarations of the form "pat = exp". Generator statements and lambdas are a different story, as you rightly point out. Nonetheless, I still believe that it is surprising for "pattern bindings" that this syntax is allowed, since there doesn't seem to be any purpose to them. (A cursory glance at the Report suggests that this kind of pattern binding is allowed). Then again, since the bindings are benign, maybe one could argue that it is better to have one less rule in the language definition? Then again, such a declaration could be the sign of a buggy program, and it might be better to give a compile time error. Cheers, Bernie.

1 0

Very Small Program
by Jason Dagit 02 Nov '06

02 Nov '06

Hello, I just found it (in ghci and hugs) that this is a valid haskell program: let 0 = 1 in 0 This program evaluates to 0 (to my surprise). I expected something similar to how this works: let { 1 + 1 = 3; 3 + 1 = 7 } in 1 + 1 + 1 Where you get 7. So, if the 0 is not used as an identifier (ie, defining a function or name of a value), then why doesn't this count as a parse error? And, why didn't I get to locally redefine it? Thanks, Jason

5 4

Fwd: [Haskell-cafe] Class
by Slavomir Kaslev 02 Nov '06

02 Nov '06

---------- Forwarded message ---------- From: Slavomir Kaslev <slavomir.kaslev(a)gmail.com> Date: Nov 2, 2006 10:47 AM Subject: Re: [Haskell-cafe] Class To: Daniel Fischer <daniel.is.fischer(a)web.de> On 11/2/06, Daniel Fischer <daniel.is.fischer(a)web.de> wrote: > Am Donnerstag, 2. November 2006 00:06 schrieb Slavomir Kaslev: > > Hello. > > > > I am new to Haskell and I am going through "Haskell: The craft of > > functional programming". I am trying to grasp haskell's classes and > > instances, so here is slightly modified code from the book: > > > > class Show a => Visible a where > > toString :: a -> String > > toString = show > > size :: a -> Int > > size = length . show > > > > instance Visible a => Visible [a] where > > toString = concat . map toString > > size = foldl (+) 0 . map size > > > > vSort :: (Visible a, Ord a) => [a] -> String > > vSort = toString . List.sort > ^^^^^^^ > my ghc complained that List.sort is not in scope, did you import Data.List as > List? Yes, I did imported Data.List. My mistake for forgetting to add it in the post. > > > > s = vSort [1..3] > > > > Unfortunetly in ghc it gives the following type error: > > Ambiguous type variable `a' in the constraints: > > `Visible a' arising from use of `vSort' at d:/tmp.hs:83:4-8 > > `Enum a' arising from the arithmetic sequence `1 .. 3' at > > d:/tmp.hs:83:10-15 > > `Num a' arising from the literal `3' at d:/tmp.hs:83:14 > > `Ord a' arising from use of `vSort' at d:/tmp.hs:83:4-8 > > Probable fix: add a type signature that fixes these type variable(s) > > Failed, modules loaded: none. > > > > As you can see, Visible is nothing more than an adapter to the Show > > class. How I got thing so far, [1..3] :: (Num a, Enum a) => [a], has a > > Show instance so does class Num (which 'subclasses' Show). Therefore, > > I can't see any reason why toString function can't call show from > > those instances. > > First problem: class Visible has no instances yet, so even if you disambiguate > the type by writing e.g. > s = vSort [1 :: Int .. 3], you'll get an error message: > Visible.hs:20:4: > No instance for (Visible Int) > arising from use of `vSort' at Visible.hs:20:4-8 > Probable fix: add an instance declaration for (Visible Int) > In the definition of `s': s = vSort ([1 :: Int .. 3]) Visible 'subclasses' Show. Doesn't this mean that Visible should be defined for all types with Show instances? I don't want to write Visible Int, if ghc has already defined a Show Int instance. > > And the second problem: > The typechecker has no means of determining which type 1 should have. > By virtue of the fact that numeric literals are overloaded in Haskell, it has > type Num a => a. The use of enumFromTo adds the Enum a constraint and vSort > adds Ord and Visible, however there may be many types satisfying these > constraints and ghc says it's up to you to select one. > And even if there is only one instance of Visible declared, ghc (nor, as far > as I know, any other Haskell implementation) won't select that because there > might, somewhere in a long-forgotten directory, lie a module dormant in which > another instance satisfying all constraints is declared. > To sum up: instance selection is left to the user, the compiler does only type > _inference_. Often that determines which instance fits, but sometimes you > have to give an expression type signature to tell the compiler what to > choose. I agree with second problem you pointed out. Thanks for mentioning it. -- Slavomir Kaslev -- Slavomir Kaslev

2 1

Class
by Slavomir Kaslev 02 Nov '06

02 Nov '06

Hello. I am new to Haskell and I am going through "Haskell: The craft of functional programming". I am trying to grasp haskell's classes and instances, so here is slightly modified code from the book: class Show a => Visible a where toString :: a -> String toString = show size :: a -> Int size = length . show instance Visible a => Visible [a] where toString = concat . map toString size = foldl (+) 0 . map size vSort :: (Visible a, Ord a) => [a] -> String vSort = toString . List.sort s = vSort [1..3] Unfortunetly in ghc it gives the following type error: Ambiguous type variable `a' in the constraints: `Visible a' arising from use of `vSort' at d:/tmp.hs:83:4-8 `Enum a' arising from the arithmetic sequence `1 .. 3' at d:/tmp.hs:83:10-15 `Num a' arising from the literal `3' at d:/tmp.hs:83:14 `Ord a' arising from use of `vSort' at d:/tmp.hs:83:4-8 Probable fix: add a type signature that fixes these type variable(s) Failed, modules loaded: none. As you can see, Visible is nothing more than an adapter to the Show class. How I got thing so far, [1..3] :: (Num a, Enum a) => [a], has a Show instance so does class Num (which 'subclasses' Show). Therefore, I can't see any reason why toString function can't call show from those instances. Can someone please enlighten my (still) C++ thinking head? -- Slavomir Kaslev

3 3

Basic Binary IO
by Nuno Pinto 02 Nov '06

02 Nov '06

Hi all! Today i was reading System.IO and didn't manage to understand how it works just by reading it. I looked the internet for some help on this, but only "advanced" information is available. Can anyone show me how to use openBinaryFile ? Just an example, like opening file "somefile" and separating it into something that can be edited in the code (like 8 bit words) then go to word nr12 and edit the last bit? Thanks! NP _________________________________________________________________ Search from any Web page with powerful protection. Get the FREE Windows Live Toolbar Today! http://www.toolbar.live.com

3 2

Re: [Haskell-cafe] What is the best way to preserve the order of a list (RESOLVED)
by John Ky 01 Nov '06

01 Nov '06

Thanks Stefan, -John On 11/1/06, Stefan Holdermans <stefan(a)cs.uu.nl> wrote: > > John, > > > My question is, how do I preserve the ordering of entities in my > > list and still be able to assign the proper order values to each > > entity? Is there an efficient way to do this? How else might I > > improve my orderByPriority algorithm. > > Straightforwardly, you could do it like this: > > import List (sortBy) > > type Priority = Int > type Order = Int > > order :: [Priority] -> [(Priority, Order)] > order = unlabel . sortOnLab . assignOrder . sortOnPrio . label > where > label = zip [0 ..] > unlabel = map snd > sortOnLab = sortBy (\(l, _) (m, _) -> compare l m) > sortOnPrio = sortBy (\(_, p) (_, q) -> compare p q) > assignOrder = \xs -> zipWith (\(l, p) o -> (l, (p, o))) xs [0 ..] > > For instance: > > > order [5, 2, 3, 7] > [(5,2),(2,0),(3,1),(7,3)] > > HTH, > > Stefan >

1 0

Post mesg
by Farida Mishra 01 Nov '06

01 Nov '06

Hi i would like to post mesg this list --------------------------------- Everyone is raving about the all-new Yahoo! Mail.

2 1

there's a monster in my Haskell!
by Andrew Pimlott 01 Nov '06

01 Nov '06

To boost the popularity of Scheme, Felleisen has argued for renaming "lambda" to "something cool, such as Funster".[1] Likewise, Haskell intimidates newcomers with the arcane term "monad". Peyton Jones's hopeful campaign to replace it with "warm fuzzy thing"[2] has so far produced few results. Inspired by Felleisen, and in the spirit of Halloween, I offer a new alternative: Meet "monsters", your computational companions in the land of lazy functional programming. To illustrate this proposal, I present here a gentle introduction to monsters. Monsters come in great variety, each type having its own special powers. But, as noted by Elmo[3], they are alike in an essential way. All monsters are capable of devouring values: devour :: Monster m => a -> m a The result of "devour x" is simply a monster that has ingested the value "x". Most monsters have a weakness and can be slain, liberating some ingested values or producing some other result. The instrument of demise varies, as do the possible outcomes, so this function is particular to a monster. If SomeMonster always yields a single value upon its demise, we would have slay :: SomeMonster a -> a The compassionate (and fastidious) programmer defers the gruesome (and messy) slaying while making use of the monster's special powers. But how to get at the monster's values short of that macabre act? Fortunately, monsters gladly contribute their values towards the creation of more monsters: (>>=) :: Monster m => m a -> (a -> m b) -> m b (>>=) should be read as the monster on the left expelling values through its rows of teeth and over its tongue at the function on the right. (Its pronunciation is a sort of bestial hissing that is difficult to describe; when you say it correctly, the terminal may become slightly moist.) Monsters range from the tame to the tumultuous, but we cannot let them run entirely amok. All therefore must obey the "monster laws". For instance, the regurgitation law states that immediately after devouring a value, a monster expels the same value: devour x >>= k === k x We have still seen none of the promised special powers. For that, we must look at a particular monster. The Either monster is defined as data Either a b = Trick a | Treat b This monster devours Treats, but if it doesn't get a Treat, it can play a Trick: playTrick :: t -> Trick t a playTrick t = Trick t This monster is commonly used as follows: takeFood :: Food -> Either Mischief Food takeFood Apple = playTrick eggHouse takeFood Raisins = playTrick tpTree takeFood CandyCorn = devour CandyCorn The divine among monsters is the mysterious and awesome IO. Its powers are vast, perhaps limitless, and beginners are taught that it cannot be slain. Like poisoned candy and release dates, this is of course a myth. The pure of spirit may, after meditation at the altar of referential transparency, cast the spell :: IO a -> a (When you are prepared to call this function, its name will be revealed.) The ST monster can be slain without esoteric ritual: slay :: (forall s. ST s a) -> a Yet philosophers whisper that there is something otherworldly about it, a kinship with IO. Eavesdropping on their debates, I hear the words "phantom type", but that gives me the chills so I leave them. [1] http://permalink.gmane.org/gmane.comp.lang.lightweight/3427 [2] http://research.microsoft.com/~simonpj/papers/haskell-retrospective/ [3] http://muppet.wikia.com/wiki/We%27re_All_Monsters

6 5

What is the best way to preserve the order of a list
by John Ky 01 Nov '06

01 Nov '06

Hi, I have a list of entities. Each entity has a priority field and an order field. The priority field contain the input values to my algorithm, the order fields contain the output value of my algorithm. My algorithm needs to assign 1 to the order field of the entity with the lowest priority value, 2 to the order field of the entity with the next lowest priority value, .... and so on. I've written a function orderByPriority that does that. However, it also does something else that is undesireable. It reorders the list. My question is, how do I preserve the ordering of entities in my list and still be able to assign the proper order values to each entity? Is there an efficient way to do this? How else might I improve my orderByPriority algorithm. Thanks -John > import Data.List > data Entity = Entity { > entityId :: Int, > priority :: Float, > order :: Int > } > initEntity = Entity { > entityId = 0, > priority = 0.0, > order = 0 > } > myList = [ > initEntity { entityId = 1, priority = 8.7 }, > initEntity { entityId = 2, priority = 5.4 }, > initEntity { entityId = 3, priority = 2.9 }, > initEntity { entityId = 4, priority = 5.4 }, > initEntity { entityId = 5, priority = 1.3 }, > initEntity { entityId = 6, priority = 3.5 }, > initEntity { entityId = 7, priority = 9.5 } > ] > comparePriority entity1 entity2 = > compare (priority entity1) (priority entity2) > orderByPriority :: [Entity] -> [Entity] > orderByPriority entities = assignOrder orderList 1 > where > orderList = sortBy comparePriority entities > assignOrder [] _ = [] > assignOrder (entity:entities) count = > (entity { order = count }):(assignOrder entities (count + 1)) > instance Show Entity where > show entity = "{" ++ > "entityId:" ++ (show $ entityId entity) ++ "," ++ > "priority:" ++ (show $ priority entity) ++ "," ++ > "order: " ++ (show $ order entity) ++ > "}"

4 4

class Defaults
by Bulat Ziganshin 01 Nov '06

01 Nov '06

Hello haskell-cafe, just one more nice snippet of code: class Defaults a where defaultValue :: a instance Defaults Bool where defaultValue = False instance Defaults [a] where defaultValue = [] instance Defaults (a->a) where defaultValue = id instance Num a => Defaults a where defaultValue = 0 class TestDefaultValue a where isDefaultValue :: a -> Bool instance TestDefaultValue Bool where isDefaultValue = not instance TestDefaultValue [a] where isDefaultValue = null instance Num a => TestDefaultValue a where isDefaultValue = (==0) -- This function is useful for defining default values, -- such as (directory ||| ".") or (memsize ||| 10*mb) a ||| b | isDefaultValue a = b | otherwise = a -- Useful for short-cutting boolean expressions, like this: -- putStr$ (need_separator &&& "\n\n") ++ (need_attention &&& map toUpper) str a &&& b | isDefaultValue a = defaultValue | otherwise = b -- |Apply function to value only if it is not empty unlessNull f xs = xs &&& f xs -- |Recursive list processing until list end, -- for example 'recursive (splitAt n)' splits list -- into the chuunks of n elements recursive :: ([a]->(b,[a])) -> [a] -> [b] recursive f list = list &&& (x:recursive f xs) where (x,xs) = f list -- |Split list into parts whose size defined by calling len_f -- at the yet unprocessed parts of list splitByLen :: ([a]->Int) -> [a] -> [[a]] splitByLen len_f = recursive (\xs -> splitAt (len_f xs) xs) -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

1 0