- Haskell-Cafe - Haskell.org

Spotting unnecessary parentheses
by Mark Carroll 13 Aug '01

13 Aug '01

While I'm hesitantly trying to write Haskell, I'm over-using brackets so as to eliminate precedence problems from the list of things I did wrong this time. Is there any easy way of finding out which brackets are unnecessary? Nobody's written a redundancy-remover or anything? (-: I was just wondering how to painlessly come by some intuition on this score... -- Mark

1 0

Re: Singular Type Constructor
by Ashley Yakeley 12 Aug '01

12 Aug '01

At 2001-08-12 11:26, Levent Erkok wrote: >How about using overlapping instances? Add: > > instance Eq a where > _ == _ = True > >to your program: if there isn't a ``better'' instance, it'll use this one. >Such an instance declaration is inherently dangerous to have around, but >might help your particular situation. How do Hugs and GHC calculate "better" instances in this case? I make a distinction between "appears to overlap" and "actually overlaps": the first is what the compilers detect: I only switch off this checking if I have instances that "appear to" overlap but don't "actually" overlap e.g.: -- instance MyClass Bool instance (Num a) => MyClass a -- ...which don't "actually" overlap provided I don't have "instance Num Bool" anywhere. Patching GHC so that it detects instances that "actually" overlap instead of "appear to" overlap is left as an exercise for the reader... -- Ashley Yakeley, Seattle WA

1 0

Re: Singular Type Constructor
by Ashley Yakeley 12 Aug '01

12 Aug '01

At 2001-08-12 16:55, Hal Daume III wrote: >but supposing you wanted a sort of relaxed equality >wherein, if you chould check for equality on the second element, you >would, otherwise you would just check the first element. i would want >to say something like: > >instance (Eq a, Not (Eq b)) => Eq (MyPair a b) where > (MyPair a _) == (MyPair a' _) = a == a' > >But from what you're telling me there's no way to have both of these >instances, correct? There's no 'Not', so you can't have the second one. If you had a 'Not', it would allow some ugliness: -- data PQ = P | Q equalPQ = (MyPair 'a' P) == (MyPair 'a' Q) -- Note that equalPQ is True. But if someone else introduces an "instance Eq PQ" in another module, equalPQ could become False. I think this sort of thing is supposed to be prohibited: code that is correct cannot change its meaning due to modules it does not depend on. -- Ashley Yakeley, Seattle WA

1 0

Re: Singular Type Constructor
by Ashley Yakeley 12 Aug '01

12 Aug '01

At 2001-08-08 23:00, Hal Daume III wrote: >however, if you try something like: > >instance TypeName a where > typeName T = "??" > >it will complain because there must be one non-type variable in the >instance head. Try using "-fglasgow-exts -fallow-undecidable-instances". >moreover, even if this restriction is removed (anyone know what it's >there for?), there will be the problem of overlapping instances with, >say TypeName Char and TypeName a. Correct. And the instances really would overlap, it wouldn't just be GHC complaining that they _might_ overlap but not being able to figure out that they don't. >so i'm wondering if there is a way to specify something like: > >instance Not (TypeName a) => TypeName a where ... No. >that is, this type variable a matches with all a such that a is not an >instance of TypeName... If there were such a thing, it would be incoherent to say: "if a is not TypeName, then a is TypeName with this typeName". >there are other places where i would find such a thing >useful/interesting beyond this TypeName foo, but this seemed like a >good, simple way to explain it... Can you think of a use for it that isn't semantically incoherent? -- Ashley Yakeley, Seattle WA

3 2

Re: from micro-rant to macro-feature
by Malcolm Wallace 10 Aug '01

10 Aug '01

Gary Memovich writes: > Now if we only expanded the flexibility of 'newtype' declarations so > that we could include a conversion function to the underlying type, > and expand the type checking system to automatically add calls to such > a function when needed, and change the syntax so that the constructor > for 'newtype' wasn't limited to identifiers, and change the syntax > some more so that new 'prefix' declarations were available to adjust > the precedence levels of these new constructors, it would be a piece > of cake :-) As a point of interest, nhc98 extends very slightly the Haskell syntax for declaring infix and precedence to permit user-defined prefix operators. For instance: infixl 7 * infixl 6 + prefix negate 6 - The extended syntax is gendecl -> vars '::' [context '=>'] type | fixity [digit] ops | 'prefix' varid [digit] op | and the obvious semantics is that the unary operator is treated as if it were really the varid. Do feel free to play with it. (Note however that this kind of declaration does not change the pattern-matching language for constants - negative integer patterns are just fiddled by the compiler.) Regards, Malcolm

1 0

Re: micro-rant
by Florian Hars 10 Aug '01

10 Aug '01

On Thu, Aug 09, 2001 at 04:55:54PM +0000, Marcin 'Qrczak' Kowalczyk wrote: > Thu, 9 Aug 2001 09:27:40 +0200, Florian Hars <florian(a)hars.de> pisze: > > Yes, getting a sytax error if I write (x-1)*(-x-1) is a real stumbling block. > It's not a syntax error. Yes, I know. It had been suggested to turn it into one, to make the language more regular and easier to learn. Yours, Florian. (Moving the thread to a more appropriate list)

1 0

Re: free variable
by Jon Fairbairn 09 Aug '01

09 Aug '01

> Hi, Hi. This sort of question belongs on haskell-café. I've copied this reply there. > I still have confusing regarding the following case: > > elemNum2 :: Int -> [Int] -> Int > elemNum2 elem list = sum [ 1 | findElem <- list, elem == findElem ] > > the function I wrote finds the number of occurences of an element in a list. > If I change it to the following: > > elemNum2 elem list = sum [ 1 | elem <- list ] > > Now it simply gives the length of the list. OK I understand that "elem" in > the list comprehension defines a new variable on the fly. What I do not > understand is in the first case: > > "findElem <- list" findElem is a new variable, but "list" is not. > "elem==findElem" here for some reason "elem" is not a new variable. > > Why does the rule only apply for "<-" operation, but not "==" for example? > > Thanks <- and let ... = ... aren't operations, they're definitions. == is the usual comparison operator. A list comprehension includes both definitions and predicates -- expressions of type Bool, or if you prefer, "operations returning" Bool. Definitions are either "let <var> = <expr>", as in [a | let a = 1], which evaluates to [1], or <var> <- <expr> where expr:: [t] for some t. You can read <- as "drawn from" [a | a <- [1,2,3]] evaluates to [1,2,3], and if we add a predicate: [a | a <- [1,2,3], odd a] evaluates to [1,3] and [a | a <- [1,2,3], a == 1] evaluates to [1] Hope that helps Jón -- Jón Fairbairn Jon.Fairbairn(a)cl.cam.ac.uk 31 Chalmers Road jf(a)cl.cam.ac.uk Cambridge CB1 3SZ +44 1223 570179 (after 14:00 only, please!)

1 0

Re: Currying - Curry function
by Ashley Yakeley 08 Aug '01

08 Aug '01

At 2001-08-07 14:20, Mark Carroll wrote: >> Is there an exemple of such a function in the Haskell language ? > >Most certainly. For instance, we can define: > > f :: Integer -> Integer -> Integer > f x y = x + y > > g = f 1 That's not really currying, is it? This is currying: f :: (Integer,Integer) -> Integer f (x,y) = x + y g :: Integer -> Integer g y = f (1,y) -- g is f with the first argument curried with 1. h :: Integer -> Integer h x = f (x,1) -- h is f with the second argument curried with 1. And these are the functions for the first of two arguments: curry :: ((a,b) -> c) -> (a -> b -> c) curry f a b = f (a,b) uncurry :: (a -> b -> c) -> ((a,b) -> c) uncurry f (a,b) = f a b ... so that we can define g = curry f 1 -- Ashley Yakeley, Seattle WA

2 1

Currying - Curry function
by Normand Leclerc 08 Aug '01

08 Aug '01

Hi haskell-cafe, >From a non programmer : Does someone know the exact source, book, page no etc. where Haskell Curry intoduced and developed its concept of a curry function. Is there an exemple of such a function in the Haskell language ? Thanks, Normand mailto:leclercn@globetrotter.net

3 2

RE: Currying - Curry function
by Konst Sushenko 07 Aug '01

07 Aug '01

to check whether I myself understand currying correctly: currying is not partial application (as the example below seems to suggest), it is conversion of a function in to a form where partial application is possible. so we can say that g = curry f is a curried function. right? konst : -----Original Message----- : From: Ashley Yakeley [mailto:ashley@semantic.org] : Sent: Tuesday, August 07, 2001 3:46 PM : To: Mark Carroll; Haskell Cafe List : Subject: Re: Currying - Curry function : : : At 2001-08-07 14:20, Mark Carroll wrote: : : >> Is there an exemple of such a function in the Haskell language ? : > : >Most certainly. For instance, we can define: : > : > f :: Integer -> Integer -> Integer : > f x y = x + y : > : > g = f 1 : : That's not really currying, is it? This is currying: : : f :: (Integer,Integer) -> Integer : f (x,y) = x + y : : g :: Integer -> Integer : g y = f (1,y) : : -- g is f with the first argument curried with 1. : : h :: Integer -> Integer : h x = f (x,1) : : -- h is f with the second argument curried with 1. : : And these are the functions for the first of two arguments: : : curry :: ((a,b) -> c) -> (a -> b -> c) : curry f a b = f (a,b) : : uncurry :: (a -> b -> c) -> ((a,b) -> c) : uncurry f (a,b) = f a b : : ... so that we can define : g = curry f 1 : : : -- : Ashley Yakeley, Seattle WA : : : _______________________________________________ : Haskell-Cafe mailing list : Haskell-Cafe(a)haskell.org : http://www.haskell.org/mailman/listinfo/haskell-cafe :

1 0