do - make - made

Чтобы “не тянуть кота за хвост” решил акцентировать все три “специфических интерпретатора“ в связке, как продолжение предыдущим run - exec - eval. Кстати, в rebol-подобных языках “do” больше в центре внимания, чем, например, тот же “eval“. Без списков зависимостей, посчитав, что это некоторая специальная задача и я её буду продолжать в фоновом режиме.

# (do 'flg|cnt ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any
(de _Do (Exe)
   (let (X (cdr Exe)  Y (eval (++ X)))
      (cond
         ((nil? Y) Y)
         ((cnt? Y)
            (let N (int Y)
               (if (or (sign? Y) (=0 N))
                  $Nil
                  (loop
                     (let R (loop1 X)
                        (? (=0 (& R 1)) R)
                        (? (=0 (dec 'N)) (& R -2)) ) ) ) ) )
         (T (loop2 X)) ) ) )  # Non-NIL 'flg'

https://picolisp-manual.tiddlyhost.com/#do

# (make .. [(made 'lst ..)] .. [(link 'any ..)] ..) -> any
(de _Make (Exe)
   (let
      (Make (val $Make)
         Yoke (val $Yoke)
         R (link (push $Nil NIL)) )
      (set $Make (set $Yoke R))
      (exec (cdr Exe))
      (set $At2
         (if (pair (val R))
            (ofs (val $Make) -1)
            $Nil ) )
      (set $Make Make  $Yoke Yoke)
      (pop R) ) )

https://picolisp-manual.tiddlyhost.com/#make

# (made ['lst1 ['lst2]]) -> lst
(de _Made (Exe)
   (let X (cdr Exe)
      (unless (val $Make)
         (makeErr Exe) )
      (when (pair X)
         (if (atom (set (val $Yoke) (eval (++ X))))
            (set $Make (val $Yoke))
            (let Y (eval (car X))
               (when (atom Y)
                  (setq Y (val (val $Yoke)))
                  (while (pair (cdr Y))
                     (setq Y @) ) )
               (set $Make (ofs Y 1)) ) ) )
      (val (val $Yoke)) ) )

https://picolisp-manual.tiddlyhost.com/#made

Можно обратить внимание, что made и make “почти рекурсивны” или “частично рекурсивные“ … короче, призрак рекурсии в системе, похоже, сопровождает нас повсеместно. Согласитесь, что любопытно, как это выражается на “классических“ циклах и функциях “условных переходов”.