- Haskell - Haskell.org

ANN: Konka doc
by Jan Skibinski 23 Aug '03

23 Aug '03

Hi All, You might be interested in Konka documentation, which is available either in HTML format: http://www.lun.pl/konka/doc/konka-doc.html or as a raw source -- from which either HTML or a View format can be generated in two seconds: http://www.lun.pl/konka/files/konka-doc.zip http://www.lun.pl/konka/files/konka-doc.tar.gz The preface to Konka doc explains how to generate the View format on the fly, so if you get tired of scrolling the big 360K HTML version (with images and tabularized 25 Remote API functions) download one of the above plus the Rebol/View interpreter from http://www.rebol.com This small 530 executable installs in seconds and deinstalls even easier - by erasing. It is worthy to have - even just for the sake of making and reading the Konka documentation. Konka is a portable software for local and remote generation, transformation, viewing and "snapshoting" of 3D scenes. Any language, which speaks TCP can interface to Konka via its set of well documented Remote API functions. The documentation has one chapter on Haskell and one on O'Haskell and Timber. Two simple simbot examples demonstrate how to use Konka API in GHCI. The overview of Haskell-Konka API is provided. Low level clients are presented for Haskell and O'Haskell. Regards, Jan _____________________________________________________________ Finally, a free email address your friends will remember! Become you(a)EmailAccount.com at http://www.emailaccount.com/

1 0

AW: container for different types, avoiding boiler plate
by Markus.Schnell＠infineon.com 22 Aug '03

22 Aug '03

> As you can see, functions ggender and gnumber are so trivial that > hardly need to be declared at all. You can just use fetch > directly. There is no need for Maybe. In fact, if you attempt to fetch > a type that you didn't put into the attrs, you get a _compile-time_ > error. Before I use your code, I have to understand it - this may take a while... :) But I'm not sure if it's suitable for what I'm doing, as the attributes get inserted at run time, and not all of them appear everywhere. So Maybe is quite natural here. Markus

2 1

ANNOUNCE: Alex version 2.0
by Simon Marlow 22 Aug '03

22 Aug '03

I am pleased to announce version 2.0 of Alex, the lexical analyser generator for Haskell. Based on Chris Dornan's original version of Alex, this new version contains some significant changes: - A revised syntax, more closely matching that of lex and Happy. - A rewritten back-end, producing smaller, faster, lexers. - A more flexible programmer interface, allowing simple tokenisers to be produced with very little code, and allowing monads to be threaded through the lexer. Read the release notes for the full story: http://www.haskell.org/alex/doc/html/about.html#RELNOTES This version has been tested on GHC: I have a development version of GHC using an Alex lexer, which beats the orignal hand-optimised lexer. Distributions can be obtained from Alex's new home: http://www.haskell.org/alex/ Alex is now distributed under a BSD-style license. Share and enjoy, Simon Marlow: simonmar(a)microsoft.com Chris Dornan: cdornan(a)arm.com Isaac Jones: ijones(a)syntaxpolice.org

3 3

Re: container for different types, avoiding boiler plate
by oleg＠pobox.com 22 Aug '03

22 Aug '03

You might also wish to look at the typed heaps, which have been discussed here on many occasions. Given the constant piece of code in the appendix (which does *not* depend on user types and can be put into a separate, constant module) you can write > data Gender = Masc | Fem | Neutr deriving (Show) > data Number = First | Second | Third deriving (Show) > > attrs = Cons Masc $ Cons Second $ Nil > > ggender attrs = (fetch undefined attrs) :: Gender > gnumber attrs = (fetch undefined attrs) :: Number As you can see, functions ggender and gnumber are so trivial that hardly need to be declared at all. You can just use fetch directly. There is no need for Maybe. In fact, if you attempt to fetch a type that you didn't put into the attrs, you get a _compile-time_ error. *Main> ggender attrs Masc *Main> gnumber attrs Second Updates are allowed as well: *Main> let attrs' = alter Neutr attrs in (ggender attrs', gnumber attrs') (Neutr,Second) Appendix: the constant part of the code. Flags used: -fglasgow-exts -fallow-undecidable-instances -fallow-overlapping-instances > data Nil t r = Nil > data Cons t r = Cons t r > > class PList ntype vtype cdrtype where > cdr:: ntype vtype cdrtype -> cdrtype > empty:: ntype vtype cdrtype -> Bool > value:: ntype vtype cdrtype -> vtype > > instance PList Nil vtype cdrtype where > empty = const True > > instance (PList n v r) => PList Cons v' (n v r) where > empty = const False > value (Cons v r) = v > cdr (Cons v r) = r > > class TypeSeq t s where > type_index:: t -> s -> Int > fetch:: t -> s -> t > alter:: t -> s -> s > > instance (PList Cons t r) => TypeSeq t (Cons t r) where > type_index _ _ = 0 > fetch _ (Cons v _) = v > alter newv (Cons v r) = Cons newv r > > instance (PList Cons t' r', TypeSeq t r') => TypeSeq t (Cons t' r') where > type_index v s = 1 + (type_index v $ cdr s) > fetch v s = fetch v $ cdr s > alter newv (Cons v' r') = Cons v' $ alter newv r'

1 0

Re: overlapping instances and functional dependencies
by oleg＠pobox.com 21 Aug '03

21 Aug '03

Wolfgang Jeltsch has observed: > I have this code: > class C a b c | a b -> c where > f :: a -> b -> c > > instance C a b c => C a (x,y,b) c where > f a (_,_,b) = f a b > > instance C a (a,c,b) c where > f _ (_,c,_) = c > ghci -fglasgow-exts -fallow-overlapping-instances compiles it without > complaint but hugs -98 +o says: > ERROR "ClassProblem.hs":7 - Instances are not consistent with > dependencies > *** This instance : C a (a,b,c) b > *** Conflicts with : C a (b,c,d) e > *** For class : C a b c > *** Under dependency : a b -> c > Can anyone tell me what the reason for this is and, maybe, how to avoid > these problems with Hugs? I believe it's helpful to think about this problem in terms of logical programming, and proceed in phases. Phase 1. The compiler sees the instances of a class C and compiles them into a database of instances. In Prolog terms, given the instances instance C a b c => C a (x,y,b) c instance C a (a,c,b) c the compiler asserts c(A,tuple(A,C,B),C,dict2). c(A,tuple(X,Y,B),C,dict1) :- c(A,B,C,_). In Haskell, lower-case type identifiers are variables and upper-case one are type constants. In Prolog, it's the other way around: lower-cased identifiers are constants and upper-cased are variables. I hope that won't cause too much confusion. I happen to have SWI-Prolog handy, in which I assert the above two facts. Phase 2. Suppose the compiler sees a type with a class constraint ``C Int (Int,Char,Bool) t'' The compiler can determine the appropriate instance by issuing a query: ?- bagof(Dict,c(int,tuple(int,char,bool),T,Dict),Dicts). Dict = _G158 T = char Dicts = [dict2] Yes In our case, only one instance matched, and we found the corresponding dictionary. If Dicts were a list of two or more dictionaries, we would have needed to choose the most specific, if any. Phase 1a. Before we get to Phase 2 however, we have to take care of one more problem. The class declaration specified a dependency: class C a b c | a b -> c which all members of that class must satisfy. The instances (which define the membership) must be consistent with the dependency "a b -> c". The consistency would be violated if there were two types "C a b c1" and "C a b c2" such that c1 /== c2. Thus we can check the consistency of the instances by searching for a counter-example: ?- c(A,B,C1,_), c(A,B,C2,_), \+ C1 == C2. A = _G151 B = tuple(_G151, _G153, tuple(_G151, _G158, _G302)) C1 = _G153 C2 = _G158 Yes Alas, in this case we found a counter-example: types C a (a,c,(a,c',d)) c C a (a,c,(a,c',d)) c' with c' /= c match some instance but contradict the functional dependency. Therefore, the compiler complaints.

3 2

RE: container for different types, avoiding boiler plate
by Hal Daume 21 Aug '03

21 Aug '03

Yes, this is essentially what DynamicMap is....The url i posted before was wrong...it should have been: www.isi.edu/~hdaume/haskell/DynamicMap.hs -- Hal Daume III | hdaume(a)isi.edu "Arrest this man, he talks in maths." | www.isi.edu/~hdaume > -----Original Message----- > From: Markus.Schnell(a)infineon.com > [mailto:Markus.Schnell@infineon.com] > Sent: Thursday, August 21, 2003 1:58 AM > To: haskell(a)haskell.org > Cc: Hal Daume; ddarius(a)hotpop.com > Subject: Re: container for different types, avoiding boiler plate > > > After taking a look at Data.Dynamic I came up with: > > > data Gender = Masc | Fem | Neutr deriving (Typeable, Show) > > data Number = First | Second | Third deriving (Typeable, Show) > > > > type Attrs = [Dynamic] > > > > attrs = [toDyn Masc, toDyn Second] > > > > gattr :: (Typeable a) => Attrs -> Maybe a > > gattr [] = Nothing > > gattr (x:xs) = case fromDynamic x of > > Nothing -> gattr xs > > Just x -> Just x > > > > type GetAttr a = Attrs -> Maybe a > > ggender = gattr :: GetAttr Gender > > gnumber = gattr :: GetAttr Number > > which already is much more readable. But I'm sure > problems are just around the corner ... > > Thank you. > Markus > >

1 0

RE: overlapping instances and functional dependencies
by Simon Peyton-Jones 21 Aug '03

21 Aug '03

| With overlapping instances, I'm allowed | | class OK x y | | instance Functor f => OK (f x) (f y) | | instance Functor f => OK x (f y) | | but I'm not allowed | | class Bad x y z | x y -> z | | instance Functor f => Bad (f x) (f y) Bool | | instance Functor f => Bad x (f y) Int | | I don't quite see why. Naively, I imagine that if the OK instances are | effectively prioritized, then Bad's rules for computing z from x and y | could be similarly prioritized. Can anyone explain why this naive | imagining is incorrect? I don't think anyone has really worked through the interaction of overlapping instances (already swampy) with functional dependencies. What you say makes sense, but it's not what GHC or Hugs implement. Maybe they should Simon

1 0

RE: overlapping instances and functional dependencies
by Simon Peyton-Jones 21 Aug '03

21 Aug '03

| class C a b c | a b -> c where | f :: a -> b -> c | | instance C a b c => C a (x,y,b) c where | f a (_,_,b) = f a b | | instance C a (a,c,b) c where | f _ (_,c,_) = c | ghci -fglasgow-exts -fallow-overlapping-instances compiles it without | complaint but hugs -98 +o says: | ERROR "ClassProblem.hs":7 - Instances are not consistent with dependencies | *** This instance : C a (a,b,c) b | *** Conflicts with : C a (b,c,d) e | *** For class : C a b c | *** Under dependency : a b -> c There are several things going on here. 1. The functional dependency (a b -> c), together with an instance declaration instance C <ta> <tb> <tc> means that if you have a constraint (C <sa> <sb> <sc>), and <sa> matches <ta> and <sb> matches <tb> then <sc> must look like <tc> Here "matches" means "is a substitution instance of". Mark Jones's original paper specified that the free variables of <tc> must be a subset of the free variable of <ta> and <tb> Reason: then the matching of <sa> and <sb> generates a substitution that covers all the free variables of <tc>, and then "<sc> must look like <tc>" means exactly that "<sc> must be the same as <tc> instantiated by the matches of <ta>/<sa> and <tb>/<sb>". However, it seems that neither Hugs nor GHC make this test, which is very naughty of them 2. Having omitted this test, Hugs is complaining that a constraint C Int (Int,Bool,Bool) <sc> would match both instance declarations, so it's not sure which <tc> to make <sc> equal to. I could check why GHC does not complain, but it may be that the answer is the same in both cases (namely the unbound 'c'). 3. None of this has to do with overlapping instances per se. I'm working with Martin Sulzmann on some ideas for loosening the restriction (1) above, but it's all a bit vacuous in your example. What is the fundep is buying you? It doesn't convey any information to say that "<sc> must look like c", if c is completely unbound! Simon

1 0

Re: container for different types, avoiding boiler plate
by Markus.Schnell＠infineon.com 21 Aug '03

21 Aug '03

After taking a look at Data.Dynamic I came up with: > data Gender = Masc | Fem | Neutr deriving (Typeable, Show) > data Number = First | Second | Third deriving (Typeable, Show) > > type Attrs = [Dynamic] > > attrs = [toDyn Masc, toDyn Second] > > gattr :: (Typeable a) => Attrs -> Maybe a > gattr [] = Nothing > gattr (x:xs) = case fromDynamic x of > Nothing -> gattr xs > Just x -> Just x > > type GetAttr a = Attrs -> Maybe a > ggender = gattr :: GetAttr Gender > gnumber = gattr :: GetAttr Number which already is much more readable. But I'm sure problems are just around the corner ... Thank you. Markus

1 0

RE: more unsafePerformIO questions (is it safe to use with ReadMode Handles)?
by Simon Marlow 20 Aug '03

20 Aug '03

> >If the databases *do* change over time, then there are two > >possibilities: > > > > 1. the contents change due to external factors only > > 2. the contents change because this program doing the writing > > > >in (1), you can still pretend the interface is pure, by > imagining that > >all the changes happened earlier. This works as long as you > only read > >the external data once. > > Isn't there the possibility of inlining causing a read to > happen twice even if it only appears to happen once? In theory that would be a valid transformation, but in practice no compiler would duplicate arbitrary computations. GHC certainly doesn't. Cheers, Simon

5 5