Does Racket Have a Continue Function

Beau­tiful Racket / tuto­rials



Into the rapids: more basic

• 1 intro
• 2 spec­i­fi­ca­tion and setup
• 3 the syntax colorer
• 4 better line errors
• 5 vari­ables and input
• 6 expres­sions
• 7 condi­tionals
• 8 subrou­tines and loops
• 9 recap
• 10 source listing



No self-respecting BASIC tuto­rial would be complete without two indis­pens­able control-flow tools—subrou­tines made with gosub and return, and loops made with for and next.



To make these, we're going to use a new tool: contin­u­a­tions. Contin­u­a­tions have a repu­ta­tion for being weird and compli­cated. They're not. But it'll be easier to see why if we first under­stand why our other options won't work.



gosub is short for "go to subrou­tine". It's meant to compen­sate for the less-than-stellar support for named func­tions in BASIC. gosub starts out like goto, in that it takes a number or numer­ical expres­sion as an argu­ment. When the program arrives at a gosub, it jumps to the line indi­cated.



The differ­ence is that when the program encoun­ters a return state­ment, it jumps back to the most recent gosub and continues normally. So it's like a round-trip version of goto, making it easier to move through the program in a non-linear fashion:



#lang basic-demo-2
10 gosub 50
20 gosub 70
30 print "third"
40 end
50 print "first"
60 return
70 print "second"
80 return

#lang basic-demo-2 10 gosub 50 20 gosub 70 30 print "third" 40 end 50 print "first" 60 return 70 print "second" 80 return



first
second
third



By combining vari­able assign­ment with gosub, we can approx­i­mate the behavior of calling a func­tion:



#lang basic-demo-2
10 x = 11 : gosub 30 : gosub 30 : gosub 30
20 end
30 print x : x = x + 1
40 return

#lang basic-demo-2 10 x = 11 : gosub 30 : gosub 30 : gosub 30 20 end 30 print x : x = x + 1 40 return



11
12
13



We don't actu­ally pass argu­ments to a gosub, nor does return provide a value. They're just control-flow state­ments. The sharing of values happens via global BASIC vari­ables. Like any state­ment, gosub can appear among other state­ments in a line (including other gosub state­ments).



A gosub can also be invoked within a condi­tional:



#lang basic-demo-2
10 x = 2 : y = 4
20 if x < y then gosub 40
30 end
40 print "less"
50 return

#lang basic-demo-2 10 x = 2 : y = 4 20 if x < y then gosub 40 30 end 40 print "less" 50 return



less



It's possible to make loops with if and goto:



#lang basic-demo-2
10 if x < 4 then print x else 30
20 x = x + 1 : goto 10
30 end

#lang basic-demo-2 10 if x < 4 then print x else 30 20 x = x + 1 : goto 10 30 end



0
1
2
3



But often, writing the loop with for and next is simpler:



#lang basic-demo-2
10 for x = 0 to 3
20 print x
30 next x

#lang basic-demo-2 10 for x = 0 to 3 20 print x 30 next x



0
1
2
3



for defines the starting and ending values of a loop vari­able. The program proceeds until it reaches a next refer­encing the same loop vari­able. Then it incre­ments the loop vari­able, returns to the top of the loop, and keeps going. When the loop vari­able exceeds the ending value, the loop ends and the program continues.



The state­ments between the for and next have no special status (e.g., they're not recog­nized as a "block"). Control can leave the loop and come back:



#lang basic-demo-2
10 for x = 0 to 3
20 gosub 50
30 next x
40 end
50 print x
60 return

#lang basic-demo-2 10 for x = 0 to 3 20 gosub 50 30 next x 40 end 50 print x 60 return



0
1
2
3



By default, the loop vari­able is incre­mented by 1 on each pass. This can be adjusted with an optional step value at the top of the loop:



#lang basic-demo-2
10 for x = 0 to 3 step .5
20 print x
30 next x

#lang basic-demo-2 10 for x = 0 to 3 step .5 20 print x 30 next x



0
0.5
1
1.5
2
2.5
3



The key feature shared by subrou­tines and loops is that they both jump back to an earlier point in the program. return jumps back to a corre­sponding gosub; next to a corre­sponding for.



"OK, then we can model them as vari­ants of goto." Good idea, but there's more to the story. goto gets its desti­na­tion from an explicit value passed as an argu­ment. return and next, by contrast, have to infer their desti­na­tions. Also, recall that a gosub can appear in the middle of a line, or even multiple times in a line. That means we might have to return to the middle of a line. But goto can only send us to the begin­ning.



For instance, in this program, gosub is called twice, so the return first sends us back to line 10, and then to line 20:



#lang basic-demo-2
10 x = 10 : gosub 40
20 x = 20 : gosub 40
30 end
40 print x
50 return

#lang basic-demo-2 10 x = 10 : gosub 40 20 x = 20 : gosub 40 30 end 40 print x 50 return



10
20



In this case, the same return state­ment sends us to two different desti­na­tions.



With next, the pres­ence of the loop vari­able as an argu­ment provides a clue where to go.  +In real BASIC, the loop vari­able can be omitted from next. We're not going to imple­ment that version, though the differ­ence is just a little extra house­keeping. In prin­ciple, at compile time, we could sift through the lines of the program to find the corre­sponding for state­ment, and stash it inside the next:



#lang basic-demo-2
10 for x = 0 to 3
20 print x
30 next x rem we could make this mean `goto 10`

#lang basic-demo-2 10 for x = 0 to 3 20 print x 30 next x rem we could make this mean ` goto 10 `



The problem is that a loop vari­able can be used any number of times, so matching next state­ments to for state­ments might get compli­cated:



#lang basic-demo-2
10 for x = 0 to 3 : print x : next x
20 for x = 4 to 6
30 print x
40 next x
50 for x = 7 to 9
60 print x
70 next x

#lang basic-demo-2 10 for x = 0 to 3 : print x : next x 20 for x = 4 to 6 30 print x 40 next x 50 for x = 7 to 9 60 print x 70 next x



But wait—there's more. A next state­ment doesn't just jump back to the for. It acts as a condi­tional: it incre­ments the loop vari­able, checks whether it exceeds the maximum allowed value, and if so, allows the loop to exit.



So next needs to know not only the line number of the corre­sponding for, but also the end value of its loop. We won't neces­sarily be able to deter­mine this end value until the program is running:



#lang basic-demo-2
10 for x = 1 to 3
20 for y = 1 to x
30 print x ; y
40 next y : next x

#lang basic-demo-2 10 for x = 1 to 3 20 for y = 1 to x 30 print x ; y 40 next y : next x



11
21
22
31
32
33



Here, the y loop runs three times, and next y tests for a different maximum value each time.



We're back in the same situ­a­tion that we were with return, where the behavior of the next state­ment neces­sarily depends on context only avail­able at run time. So we can't rely on figuring out every­thing at compile time. Instead, we'd like to capture certain run-time context when we reach a gosub or for, and save it so that it's avail­able when we encounter the corre­sponding return or next.



That's exactly what contin­u­a­tions are for.



A contin­u­a­tion in a Racket program is a special kind of func­tion that serves a similar purpose as a line number in BASIC: it marks a refer­ence point within the program that we can return to later. Of course, a Racket program is struc­tured around expres­sions, not lines. So a contin­u­a­tion can be captured at the posi­tion of any expres­sion.



For example, if we have a program with four expres­sion posi­tions:  +Namely: a func­tion, two strings, and the result of applying the func­tion to the strings.



(string-append "foo" "bar")



We can capture the contin­u­a­tion at the "foo" posi­tion by wrap­ping it in let/cc:



(string-append (let/cc this-cc
                 "foo") "bar")



Here, let/cc captures the current contin­u­a­tion (hence cc) and assigns it to this-cc (or what­ever name we choose).  +There are other func­tions that also capture contin­u­a­tions, but let/cc will suffice for every­thing we need to do.



let/cc other­wise works like ordi­nary let: after capturing the contin­u­a­tion, it eval­u­ates the expres­sions within and returns the last as its result. So both these programs eval­uate to "foobar".



If we want to save the contin­u­a­tion for later use, we can stash it inside another vari­able:



(define my-cc #f)
(string-append (let/cc this-cc
                 (set! my-cc this-cc)
                 "foo") "bar")
(procedure? my-cc) ; #t
(continuation? my-cc) ; #t



OK, we've captured a contin­u­a­tion. What can we do with it? The contin­u­a­tion is a func­tion that takes one argu­ment. When we call the contin­u­a­tion, it returns us to the posi­tion in the program where the contin­u­a­tion was captured (that is, the posi­tion of the let/cc). The argu­ment to the contin­u­a­tion is used as the new value at that posi­tion (that is, it "replaces" the let/cc). If the contin­u­a­tion leaves us in the middle of a larger expres­sion, the surrounding expres­sion is re-eval­u­ated. So if we call my-cc with "zam" as the argu­ment:



(define my-cc #f)
(string-append (let/cc this-cc
                 (set! my-cc this-cc)
                 "foo") "bar")
(my-cc "zam")



We cause string-append to be eval­u­ated a second time with "zam" instead of "foo" as the first argu­ment:



"foobar"
"zambar"



If we capture a contin­u­a­tion at the string-append instead, every­thing works the same way, but now we can use the contin­u­a­tion to change the func­tion applied to the argu­ments, rather than one of the argu­ments:



(define my-cc #f)
((let/cc this-cc
   (set! my-cc this-cc)
   string-append) "foo" "bar")
(my-cc (λ strs (apply string-append
                      (reverse (map string-upcase strs)))))



"foobar"
"BARFOO"



If this still seems weird, we can think of the contin­u­a­tion as a way of converting an ordi­nary expres­sion into a func­tion of an argu­ment x, where x goes in the posi­tion marked by let/cc. Below, the func­tion cc-ish roughly approx­i­mates how let/cc works:



(define my-cc #f)
(string-append (let/cc this-cc
                 (set! my-cc this-cc)
                 "foo") "bar") ; "foobar"
(my-cc "zam") ; "zambar"

(define (cc-ish [x "foo"]) (string-append x "bar"))
(cc-ish) ; "foobar"
(cc-ish "zam") ; "zambar"



Having drawn a parallel between contin­u­a­tions and BASIC line numbers, we should be careful not to press the analogy too far. Contin­u­a­tions have a couple impor­tant differ­ences from line numbers:

• 

  Line numbers are hard-coded into a BASIC program, so it's a refer­ence system that exists at compile time. By contrast, contin­u­a­tions can only be captured at run time. In prac­tice, this means that we can't use a contin­u­a­tion until we've actu­ally eval­u­ated the corre­sponding let/cc during the program run.

• 

  In turn, this implies that we can only use contin­u­a­tions to jump back­ward to points in the program already visited. Whereas in BASIC, we can use line numbers to jump to previ­ously visited lines, or lines not yet visited. So contin­u­a­tions are inher­ently more limited than goto with line numbers.



Still, though they're not a tool of first resort, contin­u­a­tions are useful in situ­a­tions that require unusual kinds of control flow. For example, we used excep­tions to imple­ment our program-end signal for the end state­ment, and the change-line signal for goto. Under the hood, excep­tions are imple­mented with contin­u­a­tions. This works because an excep­tion is a way of jumping back through the calling chain.



Like­wise, our return and next state­ments need to jump back to a previ­ously visited point in a BASIC program. This time, we can't use excep­tions. Unlike end and goto, the places we want to revisit are not in the calling chain. But we can imple­ment these state­ments directly with contin­u­a­tions.



To our list of reserved-terms, we add six new ones: gosub, return, for, to, step, and next. These rules follow the state­ment syntax described above:

basic/lexer.rkt



#lang br
(require brag/support)

(define-lex-abbrev digits (:+ (char-set "0123456789")))

(define-lex-abbrev reserved-terms (:or "print" "goto" "end" "+" ":" ";" "let" "=" "input" "-" "*" "/" "^" "mod" "(" ")" "if" "then" "else" "<" ">" "<>" "and" "or" "not" "gosub" "return" "for" "to" "step" "next"))

(define basic-lexer
  (lexer-srcloc
   ["\n" (token 'NEWLINE lexeme)]
   [whitespace (token lexeme #:skip? #t)]
   [(from/stop-before "rem" "\n") (token 'REM lexeme)]
   [reserved-terms (token lexeme lexeme)]
   [(:seq alphabetic (:* (:or alphabetic numeric "$")))
    (token 'ID (string->symbol lexeme))]
   [digits (token 'INTEGER (string->number lexeme))]
   [(:or (:seq (:? digits) "." digits)
         (:seq digits "."))
    (token 'DECIMAL (string->number lexeme))]
   [(:or (from/to "\"" "\"") (from/to "'" "'"))
    (token 'STRING
           (substring lexeme
                      1 (sub1 (string-length lexeme))))]))

(provide basic-lexer)



Other­wise, our lexer remains the same.



We add four new rules to cover our new state­ments: b-gosub, b-return, b-for, and b-next. We also add them to the right side of the b-statement rule:

basic/parser.rkt



#lang brag
b-program : [b-line] (/NEWLINE [b-line])*
b-line : b-line-num [b-statement] (/":" [b-statement])* [b-rem]
@b-line-num : INTEGER
b-rem : REM
@b-statement : b-end | b-print | b-goto
             | b-let | b-input | b-if
             | b-gosub | b-return | b-for | b-next
b-end : /"end"
b-print : /"print" [b-printable] (/";" [b-printable])*
@b-printable : STRING | b-expr
b-goto : /"goto" b-expr
b-let : [/"let"] b-id /"=" (STRING | b-expr)
b-if : /"if" b-expr /"then" (b-statement | b-expr)
                   [/"else" (b-statement | b-expr)]
b-input : /"input" b-id
@b-id : ID
b-gosub : /"gosub" b-expr
b-return : /"return"
b-for : /"for" b-id /"=" b-expr /"to" b-expr [/"step" b-expr]
b-next : /"next" b-id
b-expr : b-or-expr
b-or-expr : [b-or-expr "or"] b-and-expr
b-and-expr : [b-and-expr "and"] b-not-expr
b-not-expr : ["not"] b-comp-expr
b-comp-expr : [b-comp-expr ("="|"<"|">"|"<>")] b-sum
b-sum : [b-sum ("+"|"-")] b-product
b-product : [b-product ("*"|"/"|"mod")] b-neg
b-neg : ["-"] b-expt
b-expt : [b-expt ("^")] b-value
@b-value : b-number | b-id | /"(" b-expr /")"
@b-number : INTEGER | DECIMAL

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

#lang brag b-program : [b-line] (/NEWLINE [b-line])* b-line : b-line-num [b-statement] (/":" [b-statement])* [b-rem] @b-line-num : INTEGER b-rem : REM @b-statement : b-end | b-print | b-goto | b-let | b-input | b-if | b-gosub | b-return | b-for | b-next b-end : /"end" b-print : /"print" [b-printable] (/";" [b-printable])* @b-printable : STRING | b-expr b-goto : /"goto" b-expr b-let : [/"let"] b-id /"=" (STRING | b-expr) b-if : /"if" b-expr /"then" (b-statement | b-expr) [/"else" (b-statement | b-expr)] b-input : /"input" b-id @b-id : ID b-gosub : /"gosub" b-expr b-return : /"return" b-for : /"for" b-id /"=" b-expr /"to" b-expr [/"step" b-expr] b-next : /"next" b-id b-expr : b-or-expr b-or-expr : [b-or-expr "or"] b-and-expr b-and-expr : [b-and-expr "and"] b-not-expr b-not-expr : ["not"] b-comp-expr b-comp-expr : [b-comp-expr ("="|"<"|">"|"<>")] b-sum b-sum : [b-sum ("+"|"-")] b-product b-product : [b-product ("*"|"/"|"mod")] b-neg b-neg : ["-"] b-expt b-expt : [b-expt ("^")] b-value @b-value : b-number | b-id | /"(" b-expr /")" @b-number : INTEGER | DECIMAL



We'll build our expander func­tions for b-gosub and b-return into our existing "go.rkt" module. Every time we reach a b-gosub, we save a contin­u­a­tion onto a stack. When we reach a b-return, we get the most recent contin­u­a­tion off the stack and invoke it. So the imple­men­ta­tion looks like this:

basic/go.rkt



#lang br
(require "struct.rkt" "line.rkt")
(provide b-end b-goto b-gosub b-return)

(define (b-end) (raise (end-program-signal)))

(define (b-goto num-expr)
  (raise (change-line-signal num-expr)))

(define return-ccs empty)

(define (b-gosub num-expr)
  (let/cc here-cc
    (push! return-ccs here-cc)
    (b-goto num-expr)))

(define (b-return)
  (when (empty? return-ccs)
    (raise-line-error "return without gosub"))
  (define top-cc (pop! return-ccs))
  (top-cc (void)))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21



We make a new stack called return-ccs. Within b-gosub, we use let/cc to capture the contin­u­a­tion as here-cc and push! it onto the stack. We then pass our b-gosub argu­ment to b-goto, which will send us where we need to go.



Then, in b-return, we unwind the process. If the return-ccs stack is empty, it means our program reached a b-return that didn't have a corre­sponding b-gosub, so we use raise-line-error (which, presciently, we made in better line errors) to signal the problem.



Other­wise, we pop! the topmost contin­u­a­tion from the stack, and invoke it with a (void) argu­ment. The effect is to jump back to the b-gosub where the contin­u­a­tion was captured, and replace the let/cc expres­sion with (void). This is equiv­a­lent to a state­ment that does nothing. The program will continue normally from that point.



We can quickly test that our gosub and return are working with our earlier test program:



#lang basic
10 gosub 50
20 gosub 70
30 print "third"
40 end
50 print "first"
60 return
70 print "second"
80 return

#lang basic 10 gosub 50 20 gosub 70 30 print "third" 40 end 50 print "first" 60 return 70 print "second" 80 return



first
second
third



We can also check that our return error works correctly:



#lang basic
10 gosub 50
20 return
50 print "hello"
60 return

#lang basic 10 gosub 50 20 return 50 print "hello" 60 return



hello
error in line 20: return without gosub

hello error in line 20: return without gosub



When we pick the right tool for the job, the rest is easy.



Earlier, we noticed that for and next have to coop­erate at a distance:

• 

  for marks the top of the loop, sets the initial value of the loop vari­able, its maximum value, and option­ally a step value (which defaults to 1).

• 

  next incre­ments the vari­able by the step value and checks if the new value is less than or equal to the maximum value estab­lished by for. If it is, we return to the top of the loop with the new value. Other­wise, the loop ends and the program continues after the next.



Let's start by framing out an initial version of the b-for macro. We use two cases. In the first case, if we don't get a step value, we stick the default value of 1 on the end and call b-for again:



(define-macro-cases b-for
  [(_ LOOP-ID START END) #'(b-for LOOP-ID START END 1)]
  [(_ LOOP-ID START END STEP) #'(b-let LOOP-ID START)])

( define-macro-cases b-for [( _ LOOP-ID START END ) #' ( b-for LOOP-ID START END 1 )] [( _ LOOP-ID START END STEP ) #' ( b-let LOOP-ID START )])



That brings every­thing to the second case. We know at least that we have to assign a starting value to the LOOP-ID. So let's call b-let with LOOP-ID and the START value.



Now what? We know from imple­menting gosub and return that we can use a contin­u­a­tion to jump back­ward. Unsur­pris­ingly, that's how we travel from next back to for.



We also learned that we can use a contin­u­a­tion to fill in a new value at the posi­tion where the contin­u­a­tion is captured. Among other things, next restarts the loop with a new value assigned to our loop vari­able. So it might not be a bad idea to capture a contin­u­a­tion around the assign­ment value:



(define-macro-cases b-for
  [(_ LOOP-ID START END) #'(b-for LOOP-ID START END 1)]
  [(_ LOOP-ID START END STEP) #'(b-let LOOP-ID (let/cc loop-cc
                                                 START))])

( define-macro-cases b-for [( _ LOOP-ID START END ) #' ( b-for LOOP-ID START END 1 )] [( _ LOOP-ID START END STEP ) #' ( b-let LOOP-ID ( let/cc loop-cc START ))])



We're not saving loop-cc anywhere yet. But what's going to happen if we call (loop-cc 42)? We'd be jumping into the middle of a b-let expres­sion with a new value, which will cause the b-let to be eval­u­ated again, thereby assigning 42 to the LOOP-ID. Invoking the contin­u­a­tion will also move us back to the top of loop. So calling loop-cc with a new value is equiv­a­lent to restarting the loop with that value.



Now that we have a means of trav­eling back to the top of the loop with a new value, the path forward reveals itself:

1. 

   With gosub and return, we kept a stack of contin­u­a­tions in the order we found them. This time, we make a hash table that stores the contin­u­a­tion asso­ci­ated with each for loop. We use the LOOP-ID as the key. For the value, we store a lambda func­tion that handles the loop house­keeping, including the contin­u­a­tion.

2. 

   When we reach a next, we'll use its argu­ment to get the corre­sponding func­tion out of the hash table, and run it.



The gimmick here is that although for and next appear to be coop­er­ating, under the hood, b-for will be doing all the heavy lifting, by setting up a func­tion that can be called by b-next.



Let's frame out that much:



(define next-funcs (make-hasheq))

(define-macro-cases b-for
  [(_ LOOP-ID START END) #'(b-for LOOP-ID START END 1)]
  [(_ LOOP-ID START END STEP)
   #'(b-let LOOP-ID
            (let/cc loop-cc
              (hash-set! next-funcs
                         'LOOP-ID
                         (λ () ···))
              START))])

(define-macro (b-next LOOP-ID)
  #'(begin
      (unless (hash-has-key? next-funcs 'LOOP-ID)
        (raise-line-error
         (format "`next ~a` without for" 'LOOP-ID)))
      (define func (hash-ref next-funcs 'LOOP-ID))
      (func)))



Our next-funcs hash table needs to be mutable but it will use symbols as keys, so our fastest option is make-hasheq. Within the let/cc, we use hash-set! to store an (as yet empty) lambda with the key 'LOOP-ID.



On the other side, in b-next, we use raise-line-error to signal an error if our next-funcs hash table has no corre­sponding key. Other­wise, we fetch the func­tion and execute it.



Now we just need to fill in the lambda. The finished "go.rkt" looks like this:

basic/go.rkt



#lang br
(require "struct.rkt" "line.rkt" "misc.rkt")
(provide b-end b-goto b-gosub b-return b-for b-next)

(define (b-end) (raise (end-program-signal)))

(define (b-goto num-expr)
  (raise (change-line-signal num-expr)))

(define return-ccs empty)

(define (b-gosub num-expr)
  (let/cc this-cc
    (push! return-ccs this-cc)
    (b-goto num-expr)))

(define (b-return)
  (when (empty? return-ccs)
    (raise-line-error "return without gosub"))
  (define top-cc (pop! return-ccs))
  (top-cc (void)))

(define next-funcs (make-hasheq))

(define-macro-cases b-for
  [(_ LOOP-ID START END) #'(b-for LOOP-ID START END 1)]
  [(_ LOOP-ID START END STEP)
   #'(b-let LOOP-ID
            (let/cc loop-cc
              (hash-set! next-funcs
                         'LOOP-ID
                         (λ ()
                           (define next-val
                             (+ LOOP-ID STEP))
                           (if (next-val
                                . in-closed-interval? .
                                START END)
                               (loop-cc next-val)
                               (hash-remove! next-funcs
                                             'LOOP-ID))))
              START))])

(define (in-closed-interval? x start end)
  ((if (< start end) <= >=) start x end))

(define-macro (b-next LOOP-ID)
  #'(begin
      (unless (hash-has-key? next-funcs 'LOOP-ID)
        (raise-line-error
         (format "`next ~a` without for" 'LOOP-ID)))
      (define func (hash-ref next-funcs 'LOOP-ID))
      (func)))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52



Inside the lambda, we're imple­menting the steps we already set out. We incre­ment the value of LOOP-ID by the STEP value, store it in next-val, and check if it's between the START and END values. If so, we continue the loop with next-val—meaning, we call our contin­u­a­tion loop-cc with next-val as the argu­ment. If not, the loop is done, so we delete its entry from the next-funcs hash table.



By the way, in-closed-interval is a helper func­tion that checks whether a value is between two other values. We need to take a little care because the end value is not neces­sarily greater than the start value (for instance, when the step value is nega­tive).



With those changes, our #lang basic should be able to handle loops that go up or down, with or without a step value. For good measure, let's throw in gosub and return too:



#lang basic
10 for h = 1 to 2
20 for t = 2 to 4 step 2
30 for d = 9 to 8 step -1
40 gosub 60
50 next d : next t : next h : print "done" : end
60 print h ; t ; d
70 return

#lang basic 10 for h = 1 to 2 20 for t = 2 to 4 step 2 30 for d = 9 to 8 step -1 40 gosub 60 50 next d : next t : next h : print "done" : end 60 print h ; t ; d 70 return



129
128
149
148
229
228
249
248
done

129 128 149 148 229 228 249 248 done



Let's also try a program with a missing for state­ment:



#lang basic
10 for x = 1 to 3
20 print x
30 next x
40 next x

#lang basic 10 for x = 1 to 3 20 print x 30 next x 40 next x



1
2
3
error in line 40: `next x` without for

1 2 3 error in line 40: `next x` without for

• 1 intro
• 2 spec­i­fi­ca­tion and setup
• 3 the syntax colorer
• 4 better line errors
• 5 vari­ables and input
• 6 expres­sions
• 7 condi­tionals
• 8 subrou­tines and loops
• 9 recap
• 10 source listing

sherercaph1941.blogspot.com

Source: https://beautifulracket.com/basic-2/subroutines-and-loops.html

Share this post