Detecting balanced Parentheses in Advanced Student Language

Today I revisited this exercise from the Coursera Scala course that I did some time ago using the Advanced Student Language:

	;; The first three lines of this file were inserted by DrRacket. They record metadata
	;; about the language level of this file in a form that our tools can easily process.
	#reader(lib "htdp-advanced-reader.ss" "lang")((modname balance) (read-case-sensitive #t) (teachpacks ()) (htdp-settings #(#t constructor repeating-decimal #t #t none #f ())))
	(check-expect
	(balanced-parentheses? "") true)
	(check-expect
	(balanced-parentheses? "()") true)
	(check-expect
	(balanced-parentheses? "(moko)") true)
	(check-expect
	(balanced-parentheses?
	"(if (zero? x) max (/ 1 x))")
	true)
	(check-expect
	(balanced-parentheses?
	"I told him (that it’s not (yet) done). (But he wasn’t listening)")
	true)
	(check-expect
	(balanced-parentheses? ")") false)
	(check-expect
	(balanced-parentheses? "())( )") false)
	(check-expect
	(balanced-parentheses? "())(") false)
	(check-expect
	(balanced-parentheses? ":-)") false)
	(define (balanced-parentheses? str)
	(letrec
	([f
	(lambda (char-list elements-in-stack)
	(cond ((empty? char-list)
	(= elements-in-stack 0))
	((char=? (car char-list) #\()
	(f (cdr char-list) (+ elements-in-stack 1)))
	((and (char=? (car char-list) #\))
	(= elements-in-stack 0))
	false)
	((char=? (car char-list) #\))
	(f (cdr char-list) (- elements-in-stack 1)))
	(else
	(f (cdr char-list) elements-in-stack))))])
	(f (string->list str) 0)))

view raw balanced-parentheses.rkt hosted with ❤ by GitHub

I refactored it to define the helper function f inside balanced-parentheses?.

Since it is not allowed to have nested function definitions in Advanced Student Language (it's in Racket), I defined the function using letrec and a lambda.

I had forgotten how many parentheses a cond needs in Advanced Student Language. In that sense Clojure is far more convenient.