- Haskell-Cafe - Haskell.org

RE: Enum class
by Arjun Guha 09 Jan '05

09 Jan '05

Well, you already have succ:: (Enum a) => a -> a defined for all data of the Enum class. You also need Bounded so that you can check maxBound. This (untested) code should do it: > next:: (Enum a, Bounded a) => a -> a > next v = if (toEnum v) == (toEnum (maxBound)) > then minBound > else succ v -- Arjun Guha <guhaarju(a)grinnell.edu>

1 0

Re: Typed Lambda-Expressions withOUT GADTs
by oleg＠pobox.com 09 Jan '05

09 Jan '05

Ashley Yakeley wrote on the first day of 2005: > This compiled with today's CVS GHC 6.3. I don't think you can do this > without GADTs. It seems we can do without GADT -- roughly with the same syntax (actually, the syntax of expressions is identical -- types differ and we have to write `signatures' -- i.e., instance declarations). Tested with GHC 6.2.1. I especially liked the example test3 = (runExpression s) (runExpression k) (runExpression k) below. Its inferred type is -- :t test3: -- test3 :: forall r. r -> r so, SKK must be the identity (if it terminates, that is) {-# OPTIONS -fglasgow-exts #-} {-# OPTIONS -fallow-undecidable-instances #-} module Expression where -- data Sym env r where -- FirstSym :: Sym (r,xx) r -- NextSym :: Sym env r -> Sym (a,env) r class SymT t env r data FirstSym = FirstSym deriving Show data NextSym t = NextSym t deriving Show instance SymT FirstSym (r,xx) r instance SymT t env r => SymT (NextSym t) (a,env) r class SymT t env r => RunSym t env r | t env -> r where runSym :: t -> env -> r -- runSym FirstSym (r,xx) = r; instance RunSym FirstSym (r,xx) r where runSym _ (r,xx) = r instance RunSym var env r => RunSym (NextSym var) (a,env) r where runSym (NextSym var) (a,env) = runSym var env -- the code literally -- data OpenExpression env r where -- Lambda :: OpenExpression (a,env) r -> OpenExpression env (a -> r); -- Symbol :: Sym env r -> OpenExpression env r; -- Constant :: r -> OpenExpression env r; -- Application :: OpenExpression env (a -> r) -> OpenExpression env a -> -- OpenExpression env r -- Frankly speaking, the class OpenExpression below isn't necessary -- We could have gotten by with just RunOpenExpression -- However, the class OpenExpression makes it easy to formulate -- the constraint for well-formed expressions. -- We can use that constraint elsewhere. class OpenExpression t env r data Lambda a t = Lambda t deriving Show data Symbol t = Symbol t deriving Show data Constant r = Constant r deriving Show data Application a t1 t2 = Application t1 t2 deriving Show instance OpenExpression t (a,env) r => OpenExpression (Lambda a t) env (a->r) instance SymT t env r => OpenExpression (Symbol t) env r instance OpenExpression (Constant r) env r instance (OpenExpression t1 env (a->r), OpenExpression t2 env a) => OpenExpression (Application a t1 t2) env r class OpenExpression t env a => RunOpenExpression t env a | t env -> a --class RunOpenExpression t env a | t env -> a where runOpenExpression :: t -> env -> a instance RunOpenExpression (Constant r) env r where runOpenExpression (Constant r) _ = r instance (RunOpenExpression t1 env (b->a), RunOpenExpression t2 env b) => RunOpenExpression (Application b t1 t2) env a where runOpenExpression (Application t1 t2) env = (runOpenExpression t1 env) (runOpenExpression t2 env) instance RunSym var env r => RunOpenExpression (Symbol var) env r where runOpenExpression (Symbol var) env = runSym var env instance RunOpenExpression t (a,env) r => RunOpenExpression (Lambda a t) env (a->r) where runOpenExpression (Lambda exp) env = \a -> runOpenExpression exp (a,env) newtype Expression t r = MkExpression (forall env. RunOpenExpression t env r => t) runExpression (MkExpression e) = runOpenExpression e () sym0 = Symbol FirstSym sym1 = Symbol (NextSym FirstSym) sym2 = Symbol (NextSym (NextSym FirstSym)) -- k = \x.\y -> x = \.\.1 k = MkExpression (Lambda (Lambda sym1)) -- s :: Expression ((a -> b -> c) -> (a -> b) -> a -> c); -- -- s = \x.\y.\z -> x z (y z) = \.\.\.2 0 (1 0) s = MkExpression (Lambda (Lambda (Lambda (Application (Application sym2 sym0) (Application sym1 sym0))))) test1 = (runExpression k) sym0 sym2 test2 = (runExpression k) sym2 sym0 test3 = (runExpression s) (runExpression k) (runExpression k) -- Note: That can only be the identity! -- :t test3: -- test3 :: forall r. r -> r test3' = test3 "It's the identity!!! Look at the type!!!"

10 20

Two fun things with GADTs
by Ashley Yakeley 08 Jan '05

08 Jan '05

1. Reifying class instances Easy to do, and useful sometimes: data MyMonad m where MkMyMonad :: (Monad m) => MyMonad m myReturn :: MyMonad m -> a -> m a myReturn MkMyMonad = return myBind :: MyMonad m -> m a -> (a -> m b) -> m b myBind MkMyMonad = (>>=) Note this may not yet be available in GHC CVS, see bug #1097046. 2. Casting among a limited set of types data Witness a where BoolWitness :: Witness Bool IntWitness :: Witness Int ListWitness :: Witness a -> Witness [a] data ComposeT p q a = MkComposeT {unComposeT p (q a)} witnessCast :: Witness a -> Witness b -> p a -> Maybe (p b) witnessCast BoolWitness BoolWitness pa = Just pa; witnessCast IntWitness IntWitness pa = Just pa; witnessCast (ListWitness wa) (ListWitness wb) pla = fmap unComposeT (witnessCast wa wb (MkComposeT pla)) witnessCast _ _ _ = Nothing; class Castable a where witness :: Witness a instance Castable Bool where witness = BoolWitness instance Castable Int where witness = IntWitness instance (Castable a) => Castable [a] where witness = ListWitness witness cast :: (Castable a,Castable b) => p a -> Maybe (p b) cast = witnessCast witness witness castOne :: (Castable a,Castable b) => a -> Maybe b castOne a = fmap runIdentity (cast (Identity a)) -- Ashley Yakeley, Seattle WA

1 0

The Implementation of Functional Programming Languages
by Simon Peyton-Jones 08 Jan '05

08 Jan '05

I'm happy to announce that my out-of-print 1987 book, The Implementation of Functional Programming Languages is now available online at http://research.microsoft.com/%7Esimonpj/papers/slpj-book-1987/index.htm Very many thanks to Marnie Montgomery, who did all the work. Happy reading Simon

2 1

RE: [Haskell-cafe] Unicode: Hugs vs GHC (again) was: Re: Some random newbie questions
by Simon Marlow 08 Jan '05

08 Jan '05

On 07 January 2005 13:01, Dimitry Golubovsky wrote: > Lennart Augustsson wrote: >> Simon Marlow wrote: >> >>> Here's a summary of the state of Unicode support in GHC and other >>> compilers. There are several aspects: >>> >>> - Can the Char type hold the full range of Unicode characters? >>> This has been true in GHC for some time, and is now true in Hugs. >>> I don't think it's true in nhc98 (please correct me if I'm >>> wrong). > > I remember, it was in GHC. But any attempt to output Unicode > characters using standard I/O functions always ended up outputting > only low 8 bits. Has anything changed since then? No, that's still the case (I mentioned it in a separate point in that message). >>> - Do the character class functions (isUpper, isAlpha etc.) work >>> correctly on the full range of Unicode characters? This is true >>> in Hugs. It's true with GHC on some systems (basically we were >>> lazy and used the underlying C library's support here, which is >>> patchy). > > Which basically means that one with older or underconfigured system > where they do not have permissions/technical possibilities to > configure locales in the C library properly is out of luck... True. Anyone care to take Hugs' implementation of the character class functions and put it in GHC? > The reason I asked this question was: I am trying to understand, where > is internationalization of Haskell compilers on their developers' list > of priorities, and also how high is demand from users to have at least > basic internationalization. We're keen to have it. The more people that complain about the lack of it, the faster it'll get done, probably :-) Cheers, Simon

2 1

Preventing space leaks without seq (was: Re: [Haskell-cafe] Some random newbie questions)
by Henk-Jan van Tuyl 07 Jan '05

07 Jan '05

L.S., Olaf <O.Chitil(a)kent.ac.uk> wrote: > I'm constantly surprised hearing from so many people about their space > problems. I cannot remember having space problems with my programs. I > don't know what everybody else is doing wrong I do disagree with > people recommending strictness annotations (seq etc). In contrast, I make > my programs as lazy as possible. Can you give some rules and/or examples how you do this? Henk-Jan van Tuyl -- Using Opera's revolutionary e-mail client: https://secure.bmtmicro.com/opera/buy-opera.html?AID=789433

1 0

Implementing computations with timeout
by Einar Karttunen 07 Jan '05

07 Jan '05

Hello What is the best way of doing an computation with a timeout? A naive implementation using two threads is easy to create - but what is the preferred solution? withTimeout :: forall a. Int -> IO a -> IO (Maybe a) withTimeout time fun = do mv <- newEmptyMVar tid <- forkIO (fun >>= tryPutMVar mv . Just >> return ()) forkIO (threadDelay time >> killThread tid >> tryPutMVar mv Nothing >> return ()) takeMVar mv btw How would I do the same with the new STM abstraction? - Einar Karttunen

4 10

RE: [Haskell-cafe] Hugs vs GHC (again) was: Re: Some randomnewbiequestions
by Simon Marlow 07 Jan '05

07 Jan '05

On 07 January 2005 12:30, Malcolm Wallace wrote: > "Simon Marlow" <simonmar(a)microsoft.com> writes: > >> Here's a summary of the state of Unicode support in GHC and other >> compilers. There are several aspects: >> >> - Can the Char type hold the full range of Unicode characters? >> This has been true in GHC for some time, and is now true in Hugs. >> I don't think it's true in nhc98 (please correct me if I'm wrong). > > You're wrong :-). nhc98 has always had 32-bit characters internally. I checked the nhc98 sources, and it seems that maxBound::Char is '\255'. >> - Can you use (some encoding of) Unicode for your Haskell source >> files? I don't think this is true in any Haskell compiler right >> now. > > Many years ago, hbc claimed to be the only compiler with support for > this. What encoding(s) did hbc allow in source files? The docs only mention unicode characters inside character & string literals. Cheers, Simon

3 3

RE: [Haskell-cafe] Some random newbie questions
by Simon Peyton-Jones 07 Jan '05

07 Jan '05

| * As far as I can determine, there is no way to check pattern matches for | exhaustiveness. Coming from OCaml, this feels like losing a significant | safety net! How do people program so as not to be getting dynamic match | failures all the time? GHC has -fwarn-incomplete-patterns and -fwarn-overlapped-patterns. But the code implementing these checks is old and crufty, and the warnings are sometimes a bit wrong -- at least when guards and numeric literals are involved. I think they are accurate when you are just using "ordinary" pattern matching. Cleaning up this bit of GHC is a long-standing to-do item, if anyone feels motivated to undertake it. It's a well-defined task, with plenty of well-written papers explaining how to do it -- but it's tricker than it seems at first! Simon

3 2

RE: [Haskell-cafe] The implementation of Functional
by Simon Peyton-Jones 07 Jan '05

07 Jan '05

The online-readable copy is all ready to go. I'm just awaiting a final "ok" from Marnie and I'll announce it. For a paper copy we'll await John's Cafepress efforts. Much thanks to both Marnie and John. Simon | -----Original Message----- | From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of | robert dockins | Sent: 06 January 2005 19:22 | To: haskell-cafe | Subject: [Haskell-cafe] The implementation of Functional | | | The following discussion occurred last September. Is there any kind of | update on any version of this book? | | ----------------------------------------- | | John Meacham writes: | > > >I am looking for the book "The implementation of Functional | > > >Programming languages" by S. L. Peyton Jones. | | > > This book is out of print and currently there is no electronic version | > > of it. The Haskell bookstore folk are working on reconstructing it and | > > making it available for print-on-demand, | > > http://www.cafepress.com/haskell_books/, but it's not clear when | > > exactly it will be available. | > > | > > Your other option is to try to find a used copy, but they are pretty | > > expensive. | > | > I am working on getting that book available in the haskell bookstore. I | > searched quite a while before I found a used printed copy at a | > reasonable price and my search was part of my motivation for creating | > the bookstore. | > | > It is a bit trickier than the other books on the site because I only | > have a scanned in copy of the print version to work with, rather than | > LaTeX source. but I should have time this week to get it online. | > John | | My wife (mainly) and I, with Simon's permission, have been working on | getting a web-enabled version of this available for quite some time. It | hovers on the brink of completion, and should be there Real Soon Now as | well. This will include a web enabled table of contents and next and back | buttons. | | If I'd known how much time she would put in, I'd have never asked her for "a | small favor"....... | | Dave Barton | EDAptive Computing | | _______________________________________________ | Haskell-Cafe mailing list | Haskell-Cafe(a)haskell.org | http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0