Why am I getting a #<undef> is not a function error? - scheme

Question

This is my code and I am slightly confused why I am receiving this error. My code is just to find the roots for a quadratic equation.
(define (roots a b c)
(define det
(- (* b b) (* 4 a c))
)
(if (> det 0) (
(display (/ (+ (* b -1) (sqrt det)) (* 2 a)))
(display (/ (- (* b -1) (sqrt det)) (* 2 a)))
)
)
(if (= det 0) (
(display (/ (* b -1) (* 2 a)))
(display (/ (* b -1) (* 2 a)))
)
)
(if (< det 0) (
(display "complex roots")
(display (/ (+ (* b -1) sqrt(* det -1)) (* 2 a)))
(display (/ (- (* b -1) sqrt(* det -1)) (* 2 a)))
)
)
)
(roots -2 4 5)
(roots -2 4 -5)

Answer 1

I believe you meant to add a begin in the body of your one armed if's. The display procedure has a void return value, and the extra parentheses will try to apply the value as a procedure. You can reproduce the error by running ((display 5)). Using begin will allow you to instead evaluate the expressions in sequence.
This code will display the values without any exceptions:
(define (roots a b c)
(define det
(- (* b b) (* 4 a c))
)
(if (> det 0) (begin
(display (/ (+ (* b -1) (sqrt det)) (* 2 a)))
(display (/ (- (* b -1) (sqrt det)) (* 2 a)))
)
)
(if (= det 0) (begin
(display (/ (* b -1) (* 2 a)))
(display (/ (* b -1) (* 2 a)))
)
)
(if (< det 0) (begin
(display "complex roots")
(display (/ (+ (* b -1) sqrt(* det -1)) (* 2 a)))
(display (/ (- (* b -1) sqrt(* det -1)) (* 2 a)))
)
)
)

Answer 2

The parentheses in Scheme are very special. They mean apply:
(define (test arg) arg)
((test +) 4 5) ; ==> 9
The same in JavaScript:
const plus = (a, b) => a+b; // Needed since + is not a function in JS
const test = arg => arg
test(plus)(4,5) // ==> 9
In your code you have:
((display (/ (+ (* b -1) (sqrt det)) (* 2 a)))
(display (/ (- (* b -1) (sqrt det)) (* 2 a))))
Unfortunately the expression in operator position return #<undef>. Actually accoring to the spec it can return anything because its undefined in the specification. Ib your particular implementation though it's not a function so it's like:
((test 'symbol) 4 5); ==> Error: symbol is not a function
As you saw earlier having a call to test did work earlier so expressions in operator position is perfectly valid code and almost impossible to reason about at compile time, but in runtime it will become obvious it's not possible to continue when apply gets a non function.
Now there are macros that use parentheses for something else than application and these you just have to know or read the documentation for. An example is cond
(cond ((= 3 5) #t)
(else #f))
; ==> #f
If you've never seen cond before it's easy to assume ((= 3 5) #t) is an expression and of course by looking at it it shouldn't work since (= 3 5) would not evaluate to a function object but a boolean. However each term in cond evaluates it's car then each element in the rest of the term in order if it happened to be a true value.
To do more expressions in order and return the value of the last expression one uses begin:
(begin 1 2 3)
; ==> 3
Here evaluating 1 and 2 is clearly dead code since it doesn't do anything. Thus its inherit that using begin implies a side effect where the return value is of not importance, but the side effect is. I don't think your function really needs side effects:
(define (roots a b c)
(define det
(- (* b b) (* 4 a c)))
(cond ((> det 0)
(list (/ (+ (* b -1) (sqrt det)) (* 2 a))
(/ (- (* b -1) (sqrt det)) (* 2 a))))
((= det 0)
(list (/ (* b -1) (* 2 a))))
((< det 0)
(list (/ (+ (* b -1) (make-rectangular 0 (sqrt (* det -1)))) (* 2 a))
(/ (- (* b -1) (make-rectangular 0 (sqrt (* det -1)))) (* 2 a))))))
(roots -1 4 -4) ; ==> (2 -2)
(roots 1 0 -4) ; ==> (2)
(roots 4 0 4) ; ==> (0+1i 0-1i)