RE: bang patterns give fundamentally new capabilities?
| | 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.
|
| it is getting type 'Absent' assigned to it by the demand analysis, I
| want it to be lazy (and not strict)
Ah I think I understand now. You want a lazy primop
discard# :: a - ()
Now you can write
newWorld x = discard x `seq` realWorld#
The code generator treats (discard# x) as (), and
(case (discard# x) of () - e) as e.
It should be a primop so that this behaviour is not exposed too early. An
alternative would be to do the transformation in the core-to-STG step, but that
might be too early. Still easier would be to write
discard x = ()
{-# NOINLINE[0] discard #-}
to prevent it getting inlined until the final stages of the optmisier. The
trouble is that I have no idea of what it means to expose discard too early
is in your case.
Not hard to implement if you feel like doing so.
Simon
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users
Re: bang patterns give fundamentally new capabilities?
On 12/3/06, John Meacham [EMAIL PROTECTED] wrote:
On Sat, Dec 02, 2006 at 11:02:28PM +, Simon Peyton-Jones wrote:
[snip]
| 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.
it is getting type 'Absent' assigned to it by the demand analysis, I
want it to be lazy (and not strict)
3 newWorld__ :: a - World__ {- Arity: 1 HasNoCafRefs Strictness: A -}
Well, yeah, that's because it *is* absent. If you want to convince the
demand analyzer that it isn't, then use x somewhere on the right-hand
side of the definition of newWorld__. Maybe I could be more helpful if
I knew what you were really trying to do here? (My best guess is that
you're trying to implement your own IO monad, which really shouldn't
be possible AFAIK unless there's something seriously wrong with GHC
that I don't know about. Unless you use The Function That Shall Not Be
Named.)
Cheers,
Kirsten
--
Kirsten Chevalier* [EMAIL PROTECTED] *Often in error, never in doubt
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users
Re: bang patterns give fundamentally new capabilities?
On Sat, Dec 02, 2006 at 11:02:28PM +, Simon Peyton-Jones wrote:
| 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.
I was getting this problem,
http://hackage.haskell.org/trac/ghc/ticket/1031
I assumed it was because I was passing an unboxed value to seq because
when I switched them all to bang patterns, it started to work. but I
guess it was a different issue alltogether.
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
yup. certainly not an accident. :)
incidentally, (tangent)
the more I think about it after writing my other mail, my rule ((#),?,!)
seems to be not very useful, the only reason it makes a difference is
because of the existence of 'seq' which lets me tell the difference
between _|_ and \_ - _|_. replacing it wich ((#),?,#-) where #- is
the kind of unboxed functions. with no rule of the form (#-,?,?) means
that it is statically guarenteed things that take unboxed tuples are
always fully applied to their arguments. i.e. exactly what we want for
join points or other functions we wish to ensure become loops. Seems
much more useful than functions of kind '!'. (end tangent)
| 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.
it is getting type 'Absent' assigned to it by the demand analysis, I
want it to be lazy (and not strict)
3 newWorld__ :: a - World__ {- Arity: 1 HasNoCafRefs Strictness: A -}
John
--
John Meacham - ⑆repetae.net⑆john⑈
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users
RE: bang patterns give fundamentally new capabilities?
| 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
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users
Re: bang patterns give fundamentally new capabilities?
On Thu, Nov 30, 2006 at 08:13:13PM -0800, John Meacham wrote: 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. I could not think of a way to actually get the behavior How about something like this: seqInt__ :: forall a . a - Int# - Int# seqInt__ x y = case x `seq` (I# y) of (I# y') - y' The question is: will GHC optimize out the unneccesary boxing and unboxing? Looking at the output from ghc -O2 -ddump-simpl makes me think the answer is yes. Best regards Tomasz ___ Glasgow-haskell-users mailing list Glasgow-haskell-users@haskell.org http://www.haskell.org/mailman/listinfo/glasgow-haskell-users
