- Haskell-Cafe - Haskell.org

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

Missing functions in GHC's RTS?
by Ashley Yakeley 03 Aug '01

03 Aug '01

At 2001-08-03 00:41, I wrote (on the Haskell Cafe list): >When I make a function generator with "foreign export dynamic", GHC spits >out stub files which it apparently then needs for the link. What are >these for? OK, so I don't know what they are, but the link needs the _stub.o file. Unfortunately, the stub file includes these symbols: rts_getWord8 rts_getWord16 rts_getInt16 rts_getInt64 ...which do not appear to be in any library and indeed are not declared in RtsAPI.h, although corresponding rts_mk* functions are. This looks like a bug in GHC. $ ghc -v Glasgow Haskell Compiler, Version 5.00, for Haskell 98, compiled by GHC version 5.00 Using package config file: /usr/lib/ghc-5.00/package.conf Hsc static flags: -static -fignore-interface-pragmas -fomit-interface-pragmas -fdo-lambda-eta-expansion -flet-no-escape $ uname -a Linux server 2.2.19pre17 #1 Tue Mar 13 22:37:59 EST 2001 i686 unknown -- Ashley Yakeley, Seattle WA

2 1

"foreign export dynamic" in GHC
by Ashley Yakeley 03 Aug '01

03 Aug '01

When I make a function generator with "foreign export dynamic", GHC spits out stub files which it apparently then needs for the link. What are these for? For instance: -- foreign export dynamic mkCallback :: (Int -> IO Int) -> IO Addr foreign import registerCallback :: Addr -> IO () exportCallback :: (Int -> IO Int) -> IO () exportCallback f = do fx <- mkCallback f registerCallback fx -- And then I expect the C side of things to look like this: -- typedef HsInt (*mkCallback_FunPtr) (HsInt arg1); void registerCallback (HsAddr f) { mkCallback_FunPtr callBack = reinterpret_cast<mkCallback_FunPtr>(f); ... // actually call the callback HsInt arg = 3; HsInt result = (*callBack)(arg); ... } -- Is this correct? When I compile the Haskell Test.hs I get these strange stub files, "Test_stub.h", "Test_stub.c" and "Test_stub.o". The _stub.h one looks like this: -- #include "HsFFI.h" extern HsInt Test_dvD(HsStablePtr a0, HsAddr a_, HsInt a1); -- ...while the _stub.c looks like this: -- #include "Stg.h" #include "HsStd.h" #include "HsLang.h" #include "RtsAPI.h" extern HaskellObj Test_zdfmkCallback_closure; HsInt Test_dvD(HsStablePtr a0, HsAddr a_, HsInt a1) { SchedulerStatus rc; HaskellObj ret; rc=rts_evalIO(rts_apply(rts_apply((StgClosure*)&Test_zdfmkCallback_closure, rts_mkStablePtr(a0)),rts_mkInt(a1)),&ret); rts_checkSchedStatus("Test_dvD",rc); return(rts_getInt(ret)); } -- What are the stubs for? The GHC manual, sec. 8.4.1 says this: # An FFI implementation is encouraged to generate the C # typedef corresponding to a foreign export dynamic # declaration, but isn't required to do so. It doesn't say anything about funny little stub functions. And curiously, it doesn't say exactly how GHC's FFI implementation responds to that non-requirement encouragement. There were no typedefs in the stub files. -- Ashley Yakeley, Seattle WA

1 0

Another query (-:
by Mark Carroll 02 Aug '01

02 Aug '01

I've made a bizarre little program that I don't understand the behaviour of. It's: data BoolList = End | Node Bool BoolList instance Show BoolList where show (Node False rest) = "F " ++ show rest show (Node True rest) = "T " ++ show rest show End = "<>" grow list = (Node False rest) where (Node _ rest) = add list add End = (Node True End) add (Node truth rest) = (Node truth (add rest)) The show is fine; it's the add that's confusing me. Where we have, grow list = (Node False rest) where (Node _ rest) = add list I don't really understand what's going on with this binding and matching using "where", so I'm not seeing how the True and False values are managing to propagate up to being results of grow as they do, e.g.: > grow End F <> > grow (grow End) F T <> I have Hudak, Peterson, Fasel's gentle introduction to Haskell 98, and Thompson's "Craft of Functional Programming" book - maybe I just missed something in them? Is it easy to explain what's going on with this "where" behaviour so that I could figure out what "grow"'s results are without evaluating examples? -- Mark

2 2