October 2003 - Haskell-Cafe

RE: Using existential types
by oleg＠pobox.com 14 Oct '03

14 Oct '03

Tim Docker wrote: > I wish to define a flexible report, consisting of a set of columns. > The contents of each column can be defined by mapping a function to a > row descriptor, generating a value, and then converting each value > to a string. I also wish to present an aggregate value at the bottom > of the column defined by another function. > It seems that existential types are required to get this sort of > thing to work. Is there another way? It seems there is. Here's your code: > data ColDesc rowv = forall a. ColDesc (rowv -> a) ([a] -> a) (a -> > String) > calculate :: [rowv] -> ColDesc rowv -> ([String],String) > calculate rs (ColDesc valf sumf fmtf) = let vals = map valf rs in (map > fmtf vals, (fmtf.sumf) vals) Here's the new code: > data ColDesc rowv = ColDesc (rowv -> String) ([rowv] -> String) > calculate :: [rowv] -> ColDesc rowv -> ([String],String) > calculate rs (ColDesc fmtf sumf) = (map fmtf rs, sumf rs) > rows = ["I","wish","to","define","a","report"] > mapp g f = g . (map f) > cols = [ > ColDesc (id.id) $ id.(\_ -> ""), > ColDesc (show.length) $ show.(mapp sum length), > let valf = (\s -> length s * length s) in ColDesc (show.valf) $ show.(mapp maximum valf) > ] > values = [ calculate rows col | col <- cols ] It was derived with a simple transformation: composing (rowv -> a) with (a->String) to eliminate the existential type a. It seems there is a pattern here. When we write data Foo a b = forall ex. Foo <something1> <something2> <something3> with ex unconstrained, then one of <something> must be a function F(a,b) -> ex and another something is a function ex -> G(a,b). Here F(a,b) is some expression that includes ground types, a, b -- but not ex. Indeed, otherwise we have no way to convert something into ex and to get anything out. The third something is perhaps a transformer ex -> H(a,b) -> ex. It seems therefore we are guaranteed that there is always a composition of <something>s that does not include ex. Therefore, instead of carrying original <something>, we can carry the compositions, and get rid of the existential quantification. It seems that (g.f) :: i -> o is equivalent to stating exists c. f:: (i->c) ^ g::(c->o) or, in the Haskell type language data P i o = forall c. P (i->c) (c->o) P f g I also have a nagging feeling that this approach relates to Skolemization. Indeed, Mike Gunter's transformation from > data Stat i o = -- aggregate function taking i's on input and producing o > forall s. Stat > s -- init > (s -> i -> s) -- update > (s -> o) -- result to > data Stat i o = Stat { update :: i -> Stat i o > , result :: o } looks awfully like a Skolemization, with 'Stat i o' being the Skolem function.

4 8

putStr
by Jose Morais 13 Oct '03

13 Oct '03

Hi, What I needed was actualy something more like f3 :: Int -> String f3 x = show x ++ f4 x f4 :: Int -> IO String f4 x = do putStr ("initial value is " ++ show x) return (show x) but this gives the error Type checking ERROR "teste.hs":11 - Type error in application *** Expression : show x ++ f4 x *** Term : f4 x *** Type : IO String *** Does not match : [a] Can you help me? Thank you

2 1

Re: AW: Using existential types
by Graham Klyne 13 Oct '03

13 Oct '03

At 11:25 10/10/03 +0200, Markus.Schnell(a)infineon.com wrote: >Hi Graham, > > > Instead, I replace the class instances by a single algebraic > > data type, > > whose members are functions corresponding to OO-style class methods. > >could you give an example? The code in a previous message of mine [1] was an example of sorts, though complicated by some other issues. Look for type 'DatatypeVal'. [1] http://haskell.org/pipermail/haskell-cafe/2003-October/005231.html A simpler example might be: Consider a class of values called shape, for which the following operations are defined: draw :: Shape -> Canvas -> Canvas flip :: Shape -> Shape move :: Shape -> Displacement -> Shape etc. One can imagine defining a Haskell type class with these methods, but then you get the type mixing problem noted previously. What I have found can work in situations like this is to define a type, thus: data Shape = Shape { draw :: Canvas -> Canvas , flip :: Shape , move :: Displacement -> Shape etc } then one would also need methods to create different kinds of shape, e.g.: makeSquare :: Point -> Displacement -> Shape makeCircle :: Point -> Length -> Shape etc. (Assuming appropriate type definitions for Point, Displacement, Length, etc.) #g ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

1 0

RE: Using existential types
by Tim Docker 13 Oct '03

13 Oct '03

oleg wrote: > Sorry I didn't know of that requirement. The desired sharing > can easily be introduced: That's always a risk with posting a toy example - which bits are important can be hard to tell. You are right of course about being able to introduce the sharing. FWIW, after the suggestions that I've had (thanks!), my "existential-free" example is as below. Tim type ColumnFn rowv = [rowv] -> ([String],String) column :: (rowv->a) -> ([a]->a) -> (a->String) -> ColumnFn column valf sumf fmtf rows = (map fmtf vals, (fmtf.sumf) vals) where vals = map valf rows calculate :: [ColumnFn rowv] -> [rowv] -> ([String],String) calculate cfs rows = [ cf rows | cf <- cfs ] ---- rows = ["I","wish","to","define","a","report"] cols = [ column id (\_ -> "") id, column length sum show, column (\s -> length s * length s) maximum show ] :r values = [ calculate rows col | col <- cols ]

1 0

Re: global variable
by Jose Morais 13 Oct '03

13 Oct '03

Sorry the newbie question and the insistence, but how exactly do I use map or fold applied to the infinite list to get successive integers at each time? Thank you

4 3

global variable
by Jose Morais 12 Oct '03

12 Oct '03

Hello, I need a function called, say, newItem, that when first called returns 1, the next time it is called it would return 2, then 3 and so on. How can I achieve this? Thank you

3 2

tuple sections?
by John Meacham 10 Oct '03

10 Oct '03

I vaugly remember using tuple sections at some point, but perhaps I was dreaming because they don't seem to actually exist. I mean something like (,3) meaning \x -> (x,3) (4,,,3) meaning \x y -> (4,x,y,3) were these supported at one point? if they don't exist, is there some reason why not? they seem like an obvious generalization of sections for binary operators like inc = (1 +) John -- --------------------------------------------------------------------------- John Meacham - California Institute of Technology, Alum. - john(a)foo.net ---------------------------------------------------------------------------

2 1

RE: Using existential types
by Tim Docker 10 Oct '03

10 Oct '03

Thanks for the comments. I think your solution misses one point in my original example... I wrote: > data ColDesc rowv = forall a. > ColDesc (rowv -> a) ([a] -> a) (a -> String) > > calculate :: [rowv] -> ColDesc rowv -> ([String],String) > calculate rs (ColDesc valf sumf fmtf) = > let vals = map valf rs in > (map fmtf vals, (fmtf.sumf) vals) This code only does the (rowv -> a) evaluation once, whereas olegs version: > calculate :: [rowv] -> ColDesc rowv -> ([String],String) > calculate rs (ColDesc fmtf sumf) = (map fmtf rs, sumf rs) does the evaluation (rowv -> a) for each element twice, I think. In a real system, as opposed to my toy example, this computation is expensive, and I don't want to do it more that necessary. Tim

2 1

compiling GHC with MS .Net 2003
by Andreas.Schroeder＠gillardon.de 10 Oct '03

10 Oct '03

Hi all, is it possible to compile ghc with the MS .Net 2003 c compiler? I assume some problems, since the compiling of ghc uses autoconf/configure/make Any idea IF it is possible? Regards, Andreas Schroeder

1 0

AW: Using existential types
by Markus.Schnell＠infineon.com 10 Oct '03

10 Oct '03

Hi Graham, > Instead, I replace the class instances by a single algebraic > data type, > whose members are functions corresponding to OO-style class methods. could you give an example? Thanks, Markus

1 0