Assigning the result of an expression to a variable

Question

Working with DrScheme (language-- Pretty Big). Trying to pass the result of an expression to a variable that can later be used in another expression. Here is a simplified version of the problem:

Definitions window:

(define (tot a b c) (+ a b c))

(define (tot2) (+ (tot a b c) 1))

Interpreter window

> (tot 5 6 7)

18

> (tot2)

.   . reference to undefined identifier: a

The result I want, of course, is 19. It would be easy to have DrScheme do all the algebra at once, but I need to have it solve the first expression, then solve the second expression based on the result of the first.

Answer 1

Is this what you are looking for?

(define (tot a b c) (+ a b c))
(define (tot2 a b c) (+ (tot a b c) 1))

Then

(tot2 5 6 7)

should result in 19.

---

If you want tot2 assigned to the integer value rather than to a function,

(define (tot a b c) (+ a b c))
(define tot2 (+ (tot 5 6 7) 1))

assigns the result of the expression (+ (tot 5 6 7) 1) to the name tot2

Answer 2

You're imagining a "persistence" that isn't there, though it's probably plausible, given prior experience with math.

That is: if I'm solving a math problem, and I say that x equals 5, well then x should stay equal to five for the remainder of the problem; until I erase the board, for instance.

So, can you write a programming language like this? Yes! In fact, I could write a small macro in DrScheme for you that produced exactly the behavior you appear to be looking for: it would set up a global table of variables so that every variable binding caused an update to this single table of variables.

BUT! All of the programmers I surveyed (one) (okay, it was me) agreed that this would be a very bad idea.

To see why, imagine that I have a large program that contains several variables called 'a'. Then, any time someone in part A of the program calls a function with a variable named 'a', then part B of the program will suddenly change its behavior. This will make it nearly impossible to reason about the behavior of larger programs.

More generally, this is the problem with "state" and "mutation".

For this reason, you cannot refer to variables other than the ones that are "in scope". That is, those variables whose binding form (in this case a 'define') encloses the reference.

Answer 3

Scheme is lexically scoped: so a, b, and c will only exist for the dynamic extent of tot.

The dynamic extent of a procedure call is the period between when the call is initiated and when it returns (via gnu).

Answer 4

Based on your comments on John's answer, I think what you want is just to assign the result of each function call to a variable (either one variable for each or stick them all in a list) and then add those results together.

Answer 5

After reading through everyone's comments, I realized that I was confusing two issues: having the interpreter evaluate an expression with variables, and actually supplying values for those variables. Because of this confusion, the questions I asked did not make sense. Here's a simplified version of the solution. As you can see, it is embarrassingly simple-- I just used "read" to have the user enter the values.

(define a (read))
(define b (read))
(define c (read))
(define d (read))
(define ee (read))
(define f (read))
(define tot (+ a b c))
(define tot2 (+ d ee f))
(define grandtotal (+ tot tot2))
(display grandtotal)

I used this approach with the actual program and now have a nice little application that totals my hours worked for the week. Thanks everyone for your patient assistance.