Question

The design of GHC is based on something called STG, which stands for “spineless, tagless G-machine”.

Now G-machine is apparently short for “graph reduction machine”, which defines how laziness is implemented. Unevaluated thunks are stored as an expression tree, and executing the program involves reducing these down to normal form. (A tree is an acyclic graph, but Haskell’s pervasive recursion means that Haskell expressions form general graphs, hence graph-reduction and not tree-reduction.)

What is less clear are the terms “spineless” and “tagless”.

1. I think that “spineless” refers to the fact that function applications do not have a “spine” of function application nodes. Instead, you have an object that names the function called and points to all of its arguments. Is that correct?

2. I thought that “tagless” referred to constructor nodes not being “tagged” with a constructor ID, and instead case-expressions are resolved using a jump instruction. But now I’m not sure that’s correct. Instead, it seems to refer to the fact that nodes aren’t tagged with their evaluation state. Can anyone clarify which (if any) of these interpretations is correct?

Answer 1

GHC wiki contains an introductory article about STG written by Max Bolingbroke:

The STG machine is an essential part of GHC, the world’s leading
Haskell compiler. It defines how the Haskell evaluation model should
be efficiently implemented on standard hardware. Despite this key
role, it is generally poorly understood amongst GHC users. This
document aims to provide an overview of the STG machine in its modern,
eval/apply-based, pointer-tagged incarnation by a series of simple
examples showing how Haskell source code is compiled.