recursive function return using block not working

Question

[solved]

I have something similar with these four functions: base, init, func and some. The func is recursive and calls itself: in the "stop case" it would call some and return its value, then it should return control back to "init", wherefrom it is invoked; the latter being once called from base.

base
  -> init
       -> func
            -> init
                 -> func
                      -> some
                    |
           _________+
          |
          v
          ; should continue from here (in `func`)

[not anymore]

Instead, after the first call to some, the control is yielded directly to base, skipping what I would expect to be the intermediate (init,func) pair call(s).

I actually tried several simpler cases using block, return and recursion (e.g., "mutual tail-recursive factorial"), and all worked well. I mention that func uses a test helper function that catch a throw (but I tried even an example with (catch 'test (throw 'test 0)), and it was ok); just so whatever could my real program have something causing the issue.

This is elisp: each defun commences with block, and all functions use return, as in the following.

[I switched from using "defun/block" to "defun*"]

(defmacro 4+ (number)
  "Add 4 to NUMBER, where NUMBER is a number."
  (list 'setq number (list '1+ (list '1+ (list '1+ (list '1+ number))))))

(defmacro 4- (number)
  "Subtract 4 from NUMBER, where NUMBER is a number."
  (list 'setq number (list '1- (list '1- (list '1- (list '1- number))))))

(defun mesg (s &optional o)
  "Use ATAB to tabulate message S at 4-multiple column; next/prev tab if O=1/0."
  (when (null o) (setq o 0))
  (case o (0 (4- atab)) (1 nil))
  (message (concat "%" (format "%d" (+ atab (length s))) "s") s)
  (case o (0 nil) (1 (4+ atab))))

(defun* base ()
  (let (pack)
    (setq atab 0)
    (mesg "base->" 1)
    (setq pack (init))
    (mesg "<-base")))

(defun* init ()
  (mesg "init->" 1)
  (return-from init (progn (setq temp (func)) (mesg "<-init") temp)))

(defun* func (&optional pack)
  (mesg "func->" 1)
  (when (not (null pack)) (return-from func (progn (mesg "<+func") pack)))
  (when (< 0 (mod (random) 2)); stop case
    (return-from func (progn (setq temp (some)) (mesg "<-func") temp)))
  (setq pack (init))
  (case (mod (random) 2)
    (0 (return-from func (progn (mesg "<0func") pack)))
    (1 (return-from func (progn (setq temp (func pack)) (mesg "<1func") temp))) ; use tail-recursion instead of `while'
    (t (error "foo bar"))))

(defun* some ()
  (mesg "some->" 1)
  (return-from some (progn (mesg "<-some") (list 2 3 4))))

(base)

The pack variable is my value-list as data structure. I also use func to reiterate itself (in tail-recursive call) with a special accumulating-parameter so that I avoid "imperative" while.

So instead of what I would expect (each > is paired by <)

base->
    init->
        func->
            init->
                func->
                    some->
                    <-some
                <-func
            <-init
            func-> ; tail-recursion
            <+func
        <1func
    <-init
<-base

my program behaves as follows.

base
  -> init
       -> func
            -> init
                 -> func
                      -> some
                           |
 __________________________+
|
v
; control yielded here (to `base`)

[not anymore]

Why is the control yielded too soon back to the start of the program, and not continue in the first call to func, after return from the second call via init?

Appreciate any help,

Sebastian

@Stefan: in other words, have there been some previously encountered functions/parts/questions known of [e]lisp that could possibly have the least interaction with block/return technique? (i.e., the function string-match ...?). I have the code in a public repository, but to the end purpose i'm at only 20%, and it has to do with parsing LaTeX code lines). — sjb
– sjb, Commented Dec 17, 2012 at 17:58

Diego Sevilla · Accepted Answer · 2012-12-17 20:49:14Z

1

Looking at your code, it is not clear to me what's the extent of the block in func. If the block includes the whole func definition, then yes, the control reaches func when returning, but the block is skipped completely, hence the function completely, and comes back all the way up where it was called (eventually base). May be that the case?

If that's so, you have to put the code that you want to execute after a return after the block.

EDIT: Looking again at your code, I think you're not using the return as it should be used. For instance in init you have

(block nil
 ...

 (return (func ...)))

This return "cancels" the block, and takes the same effect as not having the block at all, unless some function called in "..." does have a return without a block. So the return here cancels the possible return points of func.

edited Dec 17, 2012 at 20:49

answered Dec 17, 2012 at 20:40

Diego Sevilla

29.1k4 gold badges62 silver badges91 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

sjb Over a year ago

I mean that block wraps all other code, including any [unconditioned] return and conditioned return "points", and so cancels the rest, but not that block represents the value returned by the defun, a present one, not phantom.

sjb Over a year ago

What exactly you mean? All return points from inside the same defun/block exclude one another in what way?

sjb Over a year ago

I reread your answer. You are right, but the case is that block extent wraps all function body, that is, it is the "only function" as far as elisp interpreter is concerned.

sjb · Accepted Answer · 2012-12-20 13:58:48Z

0

Thanks both for your answer: inserting into my program those messages I tried as with the code I added for explanations revealed there are no defun* problems with elisp, but some things I mistook in design.

answered Dec 20, 2012 at 13:58

sjb

557 bronze badges

Collectives™ on Stack Overflow

recursive function return using block not working

2 Answers 2

3 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related