| I was recently presented with the problem of writing a function like so | | seqInt__ :: forall a . a -> Int# -> Int# | seqInt__ x y = x `seq` y | | which seems fine, except 'seq' of type forall a b . a -> b -> b cannot | be applied to an unboxed value. Actually it works fine. Did you try it? Seq is special because its second type argument can be instantiated to an unboxed type. I see that is not documented in the user manual; it should be. GHC has a kinding system that looks quite similar to the one you described for jhc. Here's teh comment from compiler/Type.lhs ? / \ / \ ?? (#) / \ * # where * [LiftedTypeKind] means boxed type # [UnliftedTypeKind] means unboxed type (#) [UbxTupleKind] means unboxed tuple ?? [ArgTypeKind] is the lub of *,# ? [OpenTypeKind] means any type at all | Also, is there a way to do something similar but for 'lazy' rather than | 'seq'? I want something of type | | type World__ = State# RealWorld | | {-# NOINLINE newWorld__ #-} | newWorld__ :: a -> World__ | newWorld__ x = realWord# -- ??? | | except that I need newWorld__ to be lazy in its first argument. I need | to convince the opimizer that the World__ newWorld__ is returning | depends on the argument passed to newWorld__. I don't understand what you meant here. The definition of newWorld__ that you give is, of course, lazy in x. Simon