Haskell调用依赖值的函数时会重新求值该值吗？附OpenGL场景代码

Short Answer #

Nope, Haskell won't re-evaluate voxel when you call function2 2.0 after function2 1.0—it'll reuse the already computed value.

Deep Dive #

Let's break down why this works the way it does, using your code as a reference:

First, look at how voxel is defined:

voxel :: MyType
voxel = f 2

This is a top-level binding (it lives outside any function), and it's a pure function call (f 2). Haskell's default behavior for top-level pure bindings is value sharing—once the value is computed once, it's cached and reused everywhere it's referenced.

Here's the play-by-play:

1. When you first call function2 1.0, it passes voxel to function1. At this point, voxel is just an unevaluated "thunk" (a placeholder for the expression f 2).
2. When function1 actually needs to use the concrete value of voxel (to build your MyOtherType graphics element), Haskell will run f 2 exactly once, store the resulting MyType value in memory, and replace the voxel thunk with this computed result.
3. The second time you call function2 2.0, voxel now points directly to that already computed MyType value. There's no reason to re-run f 2—Haskell just grabs the cached value and passes it to function1 again.

A key point here is that f is pure: its output depends only on its input (2), and it has no side effects. Since f 2 will always produce the same MyType value, sharing that result is completely safe and efficient. If f had side effects (like reading from a file or generating random numbers), this wouldn't hold—but your type signature tells us it's pure, so we're good.

Even if voxel were a local binding inside a function (instead of top-level), as long as it's not redefined per call, Haskell would still share it. But top-level bindings get this sharing behavior automatically in all standard Haskell compilers (like GHC), which is perfect for your OpenGL use case—you don't want to recompute the voxel data every time the user adjusts a value like y!

内容的提问来源于stack exchange，提问作者Stéphane Laurent