Quand les structures en boucle rouges nécessitent-elles une interprétation?

Question

Dans quelles circonstances une construction en boucle nécessite-t-elle une évaluation par l'interpréteur en rouge? Quelles constructions en boucle ne le font pas?

Mise à jour (20/04/2015):

Voici un petit programme je l'ai écrit à la démo de la langue pour certains étudiants. Deux des fonctions 'list et' find ont des boucles foreach dans celles-ci. Mais les boucles foreach ne seront pas exécutées à moins qu'elles soient enveloppées dans un bloc do. Ce scénario en particulier est ce qui a provoqué la question initiale, puisque le corps des boucles foreach n'est pas spécifié indirectement.

Model.red

Red [ 
    Title: "Model" 
    Author: "Thomas Royko" 
    Version: 0.0.1 
] 

entry!: make object! [ 
    name: "" 
    quantity: 0 
    notes: "" 
    display: does [ 
     print ["-- " name] 
     print ["-- " quantity] 
     print ["-- " notes newline] 
    ] 
] 

enter: func [ 
    entries value 
    /local quantity notes 
] [ 
    qt: load ask "Enter quantity: " 
    nt: ask "Enter notes: " 
    append entries make entry! copy [ 
     name: value 
     quantity: qt 
     notes: nt 
    ] 
    print "" 
] 

find: func [ 
    entries value 
    /local found entry 
] [ 
    found: false 
    do [ 
     foreach entry entries [ 
      if entry/name = value [ 
       entry/display 
       found: true 
       break 
      ] 
     ] 
    ] 
    if not found [ 
     print ["** No entry with code" value newline] 
    ] 
] 

list: func [ 
    entries 
] [ 
    do [ 
     foreach entry entries [ 
      entry/display 
     ] 
    ] 
] 

finish: func [ 
    entries 
] [ 
    save %inventory.db entries 
    quit 
] 

Console.red

Red [ 
    Title: "Console" 
    Author: "Thomas Royko" 
    Version: 0.0.1 
] 

#include %Bindings.red 
#include %Model.red 

entries: either exists? %inventory.db [ 
    reduce load %inventory.db 
] [ 
    copy [] 
] 

rule: [ 
    (value: "") 
    1 [ 
     ["e" space copy value to end (enter entries value)] | 
     ["f" space copy value to end (find entries value)] | 
     ["l" to end (list entries)] | 
     ["q" to end (finish entries)] | 
     [(print ["** Code not recognized" newline])] 
    ] 
] 

forever [ 
    parse ask "Command: " rule 
] 

Answer 1

Il ne dépend pas de la construction de mise en boucle, mais la façon dont vous spécifiez le bloc de corps en boucle et (lorsque ça s'applique), le bloc conditionnel. Si ces blocs ne sont pas spécifiés littéralement, mais indirectement en utilisant des mots, alors ils seront interprétés, car le compilateur ne peut pas les déterminer statiquement. Par exemple:

n: 3 until [print n n = 0] 

est compilable, tandis que:

body: [print n n = 0] 
n: 3 until body 

est pas.