Now let’s say you need to add the values up, for instance, all the x-values. You can do it really easily with a neat function that’s included in Scheme. It’s called fold.

The documentation on fold allows you to to chain a procedure such that once run, it will do it again with the return value of the previous run as the next iteration’s input. That sounds confusing but this example demonstrates it quite well.

(define (sum-x-values lst)
  (fold (lambda (p b) (+ (car p) b)) 0 lst)
)

What does this do? The p is the value from the list you’re working with. So in this case it would be a cons pair of x-y values. The b value is the return value from the previous run. The car will pull the x-value from the object, and if you wanted y-values, you can do car on p. Then it’s summed up and returned until it’s done. The 0 is the initial value the first sum is added to – so that’s pretty important.

This is a great way to compact down an annoying series of iterators and recursions.

And a thanks to Sam for pointing this method out.

scheme: can’t find a readable default for option –band.
searched for file all.com in these directories:
/usr/lib/mit-scheme

Inconsistency detected.

I tried nearly ever combination of symbolic linking from the Applications directory into usr/lib and I even created the infamous usr/local/lib despite its original non-existence.

One source suggested I set the path attribute in my profile. Since I had been copying willy-nilly the symbolic links to just about every location in /bin, /usr/bin/ and usr/lib, nothing made sense. I eliminated those references to start clean and simply updated my .profile with the following:

export MITSCHEME_LIBRARY_PATH=/Applications/mit-scheme.app/Contents/Resources

That will allow the Scheme executable to find the library when it runs. But how can you have it get recognized in the terminal? You actually do need a copy of the Scheme binary in there, or at least a symbolic link. So, just cd into the /usr/bin directory and then make the symlink.

sudo ln -s /Applications/mit-scheme.app/Contents/Resources/mit-scheme scheme

If you try entering scheme into the terminal now, you’ll either get nothing (e.g. it’s not a proper bash command) or there’s inconsistency detected. What you’ll have to do is exit completely from the terminal. The paths have to update and restarting the terminal is the easy way to do it. After the restart though, you’ll see that scheme should work just fine now when called from the terminal on OSX.

Just run (clear), as it is a procedure, you need the parenthesis.

This works in MIT Scheme. If you see a ;Unspecified return value, don’t worry about it. It simply means that the (clear) procedure returns nothing.

I wrote a little procedure called get-nearest+ that given a value, it will attempt to find the next largest value in that array. For example, given 24 and array of 10, 9, 35, 2, 29, 44, this procedure will return 29, because 29 comes right after 24.

I needed this logic in Scheme, but it’s easy enough to translate into C-based language too.

(define (get-nearest+ value lst)
  (define ordered-lst (sort lst <))
  (define (swap-value current found)
    (if (> current found) current found))
  (define (swap-indicator current found)
    (if (> current found) #t #f))
  (define (iterate fragment found break)
    (if (or (null? fragment) break)
      (if break
        found
        (car lst)
      )
      (iterate
        (cdr fragment)
        (swap-value (car fragment) found)
        (swap-indicator (car fragment) found)
      )
    )
  )
  (iterate ordered-lst value #f)
)

The magic of this is the early return. By setting break to true at the same time as setting the new element in found, we return early and even larger elements are not returned.

Update

In my initial testing, I used this example given 24 and array of 10, 9, 35, 2, 29, 44. The problem with this is that if 25 comes after the 29, it would not be picked up. The early return sees to that. To remedy this, I use a sort-function to order everything. In this way, 25 will always come before 29 does.

  ; split's a list
  ; lst - a list to be split
  ; at - a numeric index at which to split the list
  (define (split lst at)
    ; splits the list
    ; n - new list
    ; l - an old
    ; i - a counter
    (define (iter n l i)
      (if (or (null? l) (= i at))
        (cons (reverse n) l)
        (iter (cons (car l) n) (cdr l) (+ i 1))
      )
    )
    (iter () lst 0)
  )  

Here’s the algorithmic process.

1. Add the first element from the old list to the new list
2. Remove the first element from the old list
3. Repeat with the new and old list
4. Until either the list is null or the counter as reached the designated index

There are two arguments for this procedure. The first is the list itself to be split. The second is a simple integer. To get the split parts of the list, you’ll have to car or cdr the result. For example, (car (split a-list 3)) will return the first portion of the list while a (cdr (split a-list 3)) will return the latter half of the list.

Here’s some sample output.

original: (0 1 2 3 4 5 6)
split at index: 3
first: (0 1 2)
tail: (3 4 5 6)

original: (hello world how are you doing today ?)
split at index 4
first: (hello world how are)
tail: (you doing today ?)

Splitting lists in Scheme is really handy.

Happy splitting.

;The procedure #[compiled-procedure 13 ("list" #x3) #x14 #x103498714] has been called with 1 argument; it requires exactly 2 arguments.

My code looked something like this:

(define (get-last-item lst)
  (define (recurse tsl l)
    (if (null? l)
      (car tsl)
      (recurse (cons (car l)) (cdr l))
    )
  )
  (recurse () lst)
)

In Scheme, it’s not so easy to realize you’ve missed an argument when you’re coming from a language where anything inside parenthesis are arguments. But in this case, it’s cons.

Why? It needs two arguments, something to car and something to cdr. That recurse line should look something more like this:

      (recurse (cons (car l) tsl) (cdr l))

Now, you may ask, “how did you know it was cons?” Aside from looking for something where I messed up arguments (1 instead of 2), I looked at the internal names. When you see something like #x14 #x103498714 in an error message, and as long as it’s a scheme procedure itself and not one of those fancy special forms, it will always have that representation internally. I ran cons point-blank in the Scheme interpreter and it returned the representation that shown in the error:

#[compiled-procedure 13 ("list" #x3) #x14 #x103498714]

I’m getting better at debugging Scheme code, but it’s still an uphill climb.

Happy cons’ing

;The procedure #[compiled-procedure 13 ("list" #x26) #x1a #x10349b102] has been called with 1 argument; it requires exactly 2 arguments.

One thing to notice: called with 1 argument; it requires exactly 2 arguments. That is a give away that you’ve missed argument somewhere, even if the code isn’t what is mentioned previously, as in this case, list.

  (cond
    ((< (distance (list-ref (- (length pt-list) 1) ) origin) delta-distance)
      (append pt-list p-list)
    )
    ((> (distance (list-ref 0) origin) delta-distance)
      (append p-list pt-list)
    )
    (else
      (append (car parts) p-list (cdr parts))  
    )
  )

Looking through that code, it isn’t really obvious what’s wrong. Distance takes two “points” and calculates the distance between them. Origin is point (0,0) and delta distance is previously calculated. The pt-list was a list of points to sort through and the p-list was a list-ized singular point for insertion. Confused yet? I was too.

Look at the innocent list-ref though? How many arguments does that have? The documentation says it has two arguments. I realized I missed the list argument in the call to list-ref.

Happy list-ref’ing.

;Ill-formed special form: (define sum-range a b count)

(define sum-range a b count)
 ; no procedure code yet
)

The error message mentions special form. If you’re learning Scheme, you should remember that define is a special form. It’s special in that it does not use the applicative ordering method for evaluation, among other things I suspect. So, somehow, the special form for define is incorrect. Any ideas? Can you spot the syntax error?

Notice that sum-range does not have a leading parenthesis? The procedure needs to be lead by a parenthesis so that it is its own expression (in terms of the special-formy-ness that is define). In short, the code should have read like so:

(define (sum-range a b count)
 ; no procedure code yet
)

It was really as easy as that.

Let’s say you write code like this. It’s code for tax bracket eerily similar to real life. For our purposes though, it looks like a complete and utter mess.

(define (tax amount)
	(define total
		(cond 
			((<= amount 35000) (* amount .15))
			((and (> amount 35000) (<= amount 100000)) (+ (* 35000 .15) (* (- amount 35000 ) .25 ) ) )
			((> amount 100000) (+ (* 35000 .15) (* 65000 .25 ) (* .35 (- amount 100000) ) ) )
		)
	)
	(if (> amount 50000) (+ total (* .05 (- amount 50000))) total )
)

This example goes like this: define the total as the result of the cond, where the cond will decide which bracket to use. Conceptually, it’s not really important to know how the tax is calculated to discuss organization. Plainly, this code is repetitive and obviously busy.

Using nested procedures though, we can clean it up. Since there are three brackets, let’s make three nested procedures. Granted, this may not look any simpler, but it is. That’s because the logic driving the calculations are abstracted away from the conditionals from which they originate. Indeed, this would definitely be better with some variables, but you can’t have everything.

(define (tax2 amount)
  (define (bracket1)
    (* amount .15)
  )
  (define (bracket2)
    (+ (* 35000 .15) (* (- amount 35000 ) .25 ) )
  )
  (define (bracket3)
    (+ (* 35000 .15) (* 65000 .25 ) (* .35 (- amount 100000) ) )
  )
  
  (define total
    (cond 
      ((<= amount 35000) (bracket1) )
      ((and (> amount 35000) (<= amount 100000)) (bracket2) )
      ((> amount 100000) (bracket3) )
    )
  )

 (if (> amount 50000) (+ total (* .05 (- amount 50000))) total ) 
)

Notice that last if-statement though? It still has some messy junk in there that’s still doing calculations. You could easily trim part of that down. But there’s a problem with trimming it down completely. Notice its use of total? It was previously defined as the value returned from the cond above it. If I were to refer to it in a previously defined procedure-within-a-procedure, possibly called state-bracket, I would get an error stating that total doesn’t exist yet, and that’s true, it doesn’t. What could I do? I could pass it in as an argument!

Notice the change in the last if-statement and the addition of a new nested procedure.

(define (tax3 amount)
  (define (bracket1)
    (* amount .15)
  )
  (define (bracket2)
    (+ (* 35000 .15) (* (- amount 35000 ) .25 ) )
  )
  (define (bracket3)
    (+ (* 35000 .15) (* 65000 .25 ) (* .35 (- amount 100000) ) )
  )
  (define (state-bracket)
    (+ total (* .05 (- amount 50000)))
  )
  
  (define total
    (cond 
      ((<= amount 35000) (bracket1) )
      ((and (> amount 35000) (<= amount 100000)) (bracket2) )
      ((> amount 100000) (bracket3) )
    )
  )

 (if (> amount 50000) (state-bracket total) total )

)

This code is abstracted more than it was originally. That means it’s more flexible and likely easier to read at a glance. I will admit that though that are improvements to be made. For instance, the concurrent repeating of constants could be eliminated. Personally, I feel setting a define up so that it has a conditional value is a hack, but apparently that’s the best way.

And that’s all about logical organization and abstraction with the nested procedures Scheme offers.

Happy abstracting!

The given code from the book is:

(define (factorial n)
  (if (= n 1)
      1
      (* n (factorial (- n 1)))))

I left this code as is. Factorials are easy to understand, pick any n-value and multiply each value below it until you get to 1.

Imagine you made a call to (factorial 2). The result will be 2 because of 1 * 2. Then imagine (factorial 1), and the result being 1 because the truthy-branch of the if-statement is used instead of the calculation branch. So far, so good, right?

Now, imagine you had a call to (factorial 0). What happens? You’re going to get a dreaded infinite recursion error, which will look similar to this:

;Aborting!: maximum recursion depth exceeded

What could cause this behavior? Perhaps the author of this method simply really trusted himself to not miscount in his recursion. Perhaps it was an oversight, but whatever the case, look at the condition that controls the procedure. Notice if (= n 1), and that there is only a single value that will make this procedure stop, and that is 1.

To fix this to accept 0, while not affecting the result of the factorial numerically, you can simply exchange the (= n 1) with (< n 1). This will force a 1 whenever n is less than 1, so that covers 0 and all negative values.

Happy factorial!