Editing page: Outdated egg! - The CHICKEN Scheme wiki

You can edit this page using wiki syntax for markup.

Article contents:

== Outdated egg!

This is an egg for CHICKEN 3, the unsupported old release.  You're almost certainly looking for [[/eggref/4/tagged-begin|the CHICKEN 4 version of this egg]], if it exists.

If it does not exist, there may be equivalent functionality provided by another egg; have a look at the [[https://wiki.call-cc.org/chicken-projects/egg-index-4.html|egg index]]. Otherwise, please consider porting this egg to the current version of CHICKEN.

[[tags: egg]]

== Introduction

A form of {{begin}} that resembles the Common Lisp {{tagbody}} construct.

== Examples

Example 1 ({{tagged-begin}} returns {{(void)}})

<enscript highlight="scheme">
(use tagged-begin)

(let ([i 0])
   (tagged-begin
    loop (set! i (+ i 1))
         (if (< i 41) (go loop)))
   i)
 => 41
</enscript>

Example 2 ({{tagged-begin}} returns {{42}})

<enscript highlight="scheme">
(use tagged-begin)

(let ([i 0])
   (tagged-begin
    loop (set! i (+ i 1))
         (if (< i 42) (go loop))
         (return i)))
 => 42
</enscript>

Example 3 ({{tagged-begin}} returns {{43}})

<enscript highlight="scheme">
(use tagged-begin)

(let ([i 0])
   (tagged-begin
    loop (set! i (+ i 1))
         (go b)
    a    (if (< i 43) (go loop))
         (return i)
    b    (go a)))
 => 43
</enscript>

Example 4 ([[http://www.emacswiki.org/cgi-bin/wiki.pl?StateMachine]])

<enscript highlight="scheme">
(use tagged-begin)

(begin
  (define (display/nl v)
    (display v) 
    (newline))

(let ((a 0))
   (tagged-begin
     start
      (set! a 0)
     part-1
      (set! a (+ a 1))
      (display/nl a)
      (cond
        ((>= a  9)  (go end))
        ((even? a)  (go part-1))
        (else       (go part-2)))
     part-2
      (set! a (+ a 1))
      (go part-1)
     end
      (display/nl "We're done printing the odd numbers between 0 and 10"))))
</enscript>

This has the following output:

1
 3
 5
 7
 9
 We're done printing the odd numbers between 0 and 10

Example 5 ( Knuth: "The Art of Computer Programming", vol1, p.176): Inplace inversion of a permutation represented as a vector.

<enscript highlight="scheme">
(use tagged-begin)

(begin

(define permutation (vector 'dummy 6 2 1 5 4 3))      ; (Knuth counts from 1 not 0 :-) )
  (define n           (- (vector-length permutation) 1))
  (define (X i)       (vector-ref permutation i))
  (define (X! i j)    (vector-set! permutation i j))

(let ([m 0] [i 0] [j 0])
    (tagged-begin 
     I1   ; Initialize
          (set! m n)
          (set! j -1)
     I2   ; Next element
          (set! i (X m))
          (if (< i 0) (go I5))
     I3   ; Invert one
          (X! m j)
          (set! j (- m))
          (set! m i)
          (set! i (X m))
     I4   ; End of cycle?
          (if (> i 0) (go I3))
          (set! i j)
     I5   ; Store final value
          (X! m (- i))
     I6   ; Loop on m
          (set! m (- m 1))
          (if (> m 0) (go I2))))

permutation)
=> #(dummy 3 2 6 5 4 1)
</enscript>

Example 6 (The CommonLisp Hyper Spec examples of {{tagbody}})

<enscript highlight="scheme">
(use tagged-begin)

(begin
  (define val 'foo)
  (tagged-begin
    (set! val 1)
       (go a)
   c   (set! val (+ val 4))
       (go b)
       (set! val (+ val 32))
   a   (set! val (+ val 2))
       (go c)
       (set! val (+ val 64))
   b   (set! val (+ val 8)))

(define (f1 flag)
    (let ((n 1))
      (tagged-begin 
       (set! n (f2 flag (lambda () (go out))))
       out
       (return n))))

(define (f2 flag escape)
    (if flag (escape) 2))

(list val (f1 #f) (f1 #t)))
 => (15 2 1)
</enscript>

Example 7: Demonstrates lexical scoping of tagged-begins, and that an inner tagged-begin can use an outer tag.

<enscript highlight="scheme">
(use tagged-begin)

(tagged-begin
 a (tagged-begin
      (go b))
 b (return 'hello-world))
 => 'hello-world
</enscript>

Example 8: Demonstrates that tags are lexically shadowed.

<enscript highlight="scheme">
(use tagged-begin)

(tagged-begin
 a (tagged-begin
        (go b)
        (return 'wrong)
      b (go c))
 b (return 'wrong)
 c (return 'correct))
 => 'correct
</enscript>

Expansion example:

<enscript highlight="scheme">
(use tagged-begin)

(pp (macroexpand
  '(tagged-begin
       (set! val 1)
       (go a)
 c     (set! val (+ val  4))
       (go b)
       (set! val (+ val 32))
 a     (set! val (+ val  2))
       (go c)
       (set! val (+ val 64))
 b     (set! val (+ val  8)))))
</enscript>

This has the following output:
<enscript highlight="scheme">
((call/cc
   (lambda (go)
     (let ((return (lambda (v) (go (lambda () v)))))
       (letrec ((g14 (lambda () (set! val 1) (go a) (c)))
                (c (lambda ()
                     (set! val (+ val 4))
                     (go b)
                     (set! val (+ val 32))
                     (a)))
                (a (lambda ()
                     (set! val (+ val 2))
                     (go c)
                     (set! val (+ val 64))
                     (b)))
                (b (lambda () (set! val (+ val 8)) (return (void)))))
         (g14))))))
</enscript>

== Authors

Jens Axel <nowiki>S&oslash;gaard</nowiki>, low-level macro implementation by [[felix winkelmann|Felix Winkelmann]].

== License

Copyright (c) 2005, Jens Axel <nowiki>S&oslash;gaard</nowiki>
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
conditions are met:

* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 
* Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

== Documentation

This is a little macro that resembles the Common Lisp [[http://www-2.cs.cmu.edu/Groups/AI/html/hyperspec/HyperSpec/Body/speope_tagbody.html#tagbody|tagbody]] construct.
See also "Applications of Continuations" of Daniel P. Friedman.

=== Motivation

Many algorithms is specified in an imperative manner
in the literature (see Example 5 from Knuth). For a no-brain- 
conversion to Scheme tagged-begin is convenient.

=== Syntax
  
<macro> (tagged-begin (''tag'' | ''expression'')* )</macro>

where {{tag}} is a symbol and duplicate tags are not allowed.

=== Semantics

The form evaluates the expressions in a lexical environment
that provides functions {{go}} and {{return}} both of one argument to transfer control.

The expressions in {{tagged-begin}} are evaluated sequentially. 
If no expressions are left {{(void)}} is returned.

If an expression evaluates {{(go ''tag'')}} then control is transfered
to the expression following tag. The tags have lexical scope. 
The dynamic extent of tag is indefinite.  An {{(go ''tag'')}} is allowed 
to transfer control to an outer tagbody. The call {{(go ''tag'')}} has the
proper tail recursive property, even in a situation where the call
syntactically is not in tail position.

If {{(return ''expression'')}} is evaluted, the value of {{expression}} is
the value of the entire tagged-begin form.

== Version History

* 1.1: {{tagged-begin.scm}} needed srfi-1
* 1.0

Description of your changes:

I would like to authenticate

Spam control

What do you get when you subtract 4 from 8?