[Haskell-cafe] HasCallStack - runtime costs?

Eric Seidel eric at seidel.io
Mon Mar 7 18:19:17 UTC 2016

On Mon, Mar 7, 2016, at 09:21, Johannes Waldmann wrote:
> Eric wrote earlier:
> > If you import a function with a HasCallStack constraint
> > there's no way to disable the overhead ...
> > For non-recursive functions like head and tail,
> > the overhead is probably not large enough to be noticeable.
> Now I'm confused: should this mean that head and tail
> are "functions with a HasCallStack constraint"?
> If I ask ghci for their type, it just says head :: [a] -> a
> and that's also what's in the source
> https://downloads.haskell.org/~ghc/8.0.1-rc2/docs/html/libraries/base-
> but the Callstack explanation in the user manual
> does show a different version of head
> https://downloads.haskell.org/~ghc/8.0.1-rc2/docs/html/users_guide/glasgow_exts.html#hascallstack
> I am not particularly concerned about head and tail here
> but generally about how to find out whether my code
> is taking a performance penalty.
> I think the documentation (user manual Section 9.31)
> is rather brief about the semantics. It speaks about
> solving "HasCallStack" constraints - but they could also
> be propagated? There is secondary documentation like
> https://ghc.haskell.org/trac/ghc/wiki/ExplicitCallStack
> but it does not tell what is actually implemented,
> or I don't see it.

I'm sorry for the confusion, to be clear a function only gets a
call-stack if it has a HasCallStack constraint in its type. I used head
as an example of a function that you might want to give a call-stack,
but base *does not* do this at the moment.

GHC will infer HasCallStack constraints for functions as it would infer
class constraints, but I have a mostly-done patch to disable this
inference for top-level functions, it should make it in to the final 8.0
release. I'll try to expand the documentation as well, perhaps some more
examples would help?


More information about the Haskell-Cafe mailing list