Tomasz Zielonka wrote:

I guess you could also do something like deepSeq with Data.Generics.

Ralf Hinze posted just such an implementation to one of the mailing lists a couple of years back: http://www.mail-archive.com/glasgow-haskell-users@haskell.org/msg03810.html The end of the message seems to be cut off in the archive, so here's a reconstructed version.

module Force where import Generics

class Force a where force :: a -> ()

force{|Unit|} a = a `seq` ()

force{|b :+: c|} a = case a of Inl b -> force b Inr c -> force c

force{|b :*: c|} a = case a of b :*: c -> force b `seq` force c

instance Force Char where force a = a `seq` () instance Force Int where force a = a `seq` ()

eval :: (Force a) => a -> a eval a = force a `seq` a

And here's a slight variation in which force has the type a -> a, eliminating the need for the helper function eval. I'm not sure which version is better.

module Force' where import Generics

class Force a where force :: a -> a

force{|Unit|} a = a

force{|b :+: c|} a = case a of Inl b -> force b `seq` a Inr c -> force c `seq` a

force{|b :*: c|} a = case a of b :*: c -> force b `seq` force c `seq` a

instance Force Char where force a = a instance Force Int where force a = a

I haven't tested either of these. -- Ben

Marcin 'Qrczak' Kowalczyk wrote:

The version with () does less redundant forcing, although the compiler could perhaps optimize them statically.

I did some tests with both versions in GHC on a large binary tree and they appear to have the same performance (even without -O), so I guess GHC does do this. There's another problem with the a->a version, which is that it's never tail recursive, though perhaps GHC's optimizer can fix that as well. I imagine the a->() version is more likely to compile to good code, but it bothered me that it had such a strange type. But a->a isn't the right type either. In fact I think the right type is (a -> exists b. b). This gets us the best of both worlds in efficiency and conciseness/elegance: instance (Force a, Force b) => Force (a,b) where force (x,y) = force x `seq` force y instance Force Int where force x = x Too bad no Haskell implementation supports it. -- Ben

Dean Herington wrote:

...

deepSeq :: DeepSeq a => a -> b -> b

I should point out that deepSeq with this type is the composition of two simpler operations: deepSeq = seq . eval where eval :: DeepSeq a => a -> a eval ties a demand for a value to a demand for all its subvalues, while seq ties a demand for a value to a demand for another value of an unrelated type. Of course you can define eval x = x `deepSeq` x instead, so it's largely a matter of taste.

...

instance DeepSeq (IO a) where deepSeq = seq

This is an interesting instance (which is not to say I think it's wrong). It means the original poster's code won't work. He wanted to write foo <- eval makeFoo `catch` \e -> defaultFoo but makeFoo has a monadic type, so eval makeFoo === makeFoo. -- Ben

At 4:05 PM +0000 12/8/04, Ben Rudiak-Gould wrote:

Dean Herington wrote:

...

...

deepSeq :: DeepSeq a => a -> b -> b

I should point out that deepSeq with this type is the composition of two simpler operations:

deepSeq = seq . eval where eval :: DeepSeq a => a -> a

eval ties a demand for a value to a demand for all its subvalues, while seq ties a demand for a value to a demand for another value of an unrelated type.

Of course you can define eval x = x `deepSeq` x instead, so it's largely a matter of taste.

...

...

instance DeepSeq (IO a) where deepSeq = seq

This is an interesting instance (which is not to say I think it's wrong). It means the original poster's code won't work. He wanted to write

foo <- eval makeFoo `catch` \e -> defaultFoo

but makeFoo has a monadic type, so eval makeFoo === makeFoo.

-- Ben

Michael's exact intent was not clear to me, but he could consider the following. -- Dean import Prelude hiding (catch) import DeepSeq import Control.Exception (catch, evaluate) deepForce :: DeepSeq a => a -> a deepForce x = x `deepSeq` x deepForceIO :: DeepSeq a => a -> IO a deepForceIO = evaluate . deepForce makeFooGood, makeFooBad, defaultFoo :: Int makeFooGood = 1 makeFooBad = error "bad makeFoo" defaultFoo = 0 try f = (deepForceIO f `catch` \e -> return defaultFoo) >>= print main = try makeFooGood >> try makeFooBad