This is also how Prolog terms are represented on the heap in the Warren Abstract Machine (WAM). For instance, taking the example of the article, if we have an expression such as the Prolog term +(*(a,b), c), written using operator notation as:

    expr(E) :-
            E = a*b + c.

Then we get a flattened representation on the global stack of the virtual machine. In Scryer Prolog, we can inspect the WAM instructions with:

    ?- wam_instructions(expr/1, Is),
       maplist(portray_clause, Is).

yielding:

    put_structure(*,2,x(3)).
    set_constant(a).
    set_constant(b).
    put_structure(+,2,x(2)).
    set_value(x(3)).
    set_constant(c).
    execute(=,2).

Note how both compound terms are linearized, and appear on the heap as: functor, followed by arguments, each occupying exactly one memory cell of the WAM. The arguments can point to other memory cells. The heap is an array of such cells, all of the same concrete (as opposed to abstract, i.e., WAM-level) type. For example, Scryer Prolog uses 8 bytes for each cell, making cell access and modification very efficient on 64-bit architectures.