Actually, the best arc code IMO uses a fifty-fifty mix of functional and sequential thinking....

> my "set x" functions were clobbering each other

As a beginner you probably want to use '= instead- That's the more general command. Most arc lispers will only use 'set in rare cases.

> (def ugh (string) ...

Avoid naming the variable 'string: It will probably be OK, but since arc has functions and variables in the same namespace (google "lisp-1") you're clobbering the 'string function.

Here's how I'd rewrite this code (as far as I understand it, which isn't very far, I'm afraid so this is a very very rough approximation :-)

  (def ugh (str) 
   (let x 5
    (forlen i str 
       (let v (trunc:/ 12 (+ i 1))
         (if (is #\A str.i)
	     (++ x v)
	     (-- x v)))
    x))

If you really, really wanted to get rid of the "sets" you could write something as the following, which is in pure functional style (you might not want to do this, though... there's better languages for experimenting with a pure FP style, like Haskell)

(Again, very rough, untested code)

  (def ugh (str) 
   (apply +
    5
    (map (fn (c i)
             (let x (trunc:/ 12 n)
                 (if (is #\A c)
                     x
                     (- 0 x))))
         str
         (range 1 len.str))))

  arc> (on c "arc" (prn index ":" c))
  0:a
  1:r
  2:c
  nil

  (def ugh (str)
    (let x 5
      (on c str
        (let v (trunc (/ 12 (+ index 1)))
          (if (is c #\A)
              (++ x v)
              (-- x v))))
      x))

; Time is initialized at 30 min (x). ; Check each element in a string containing either "A"s or "B"s; ; if "A" add "v" minute(s) to x, if "B" subtract "v" minute(s) from x (let's call this value "xi"); ; Upon each check for A or B re-initialize x to be the current xi value multiplied by 2 (This way the next check ; can use the new x for it's increase/decrease)

; Use these 4 calls to validate function works correctly: ; (ugh "AAAA" 1) = 255 ; (ugh "BBBB" 1) = 225 ; (ugh "ABAB" 2) = 250

My original-like solution using "Sets" which work: * I changed to get rid of trunc, and make easier to read and align to the specs above.

    (def ugh (str v)
      (set x 15)
        (for i 0 (- (len str) 1) (set xi (* x 2))
          (if (is "A" (cut str i (+ i 1)))  
              (set x (+ xi v))
              (set x (- xi v))i))x)

As pointed out I tried unsuccessfully to remove the "sets". drcode and skenney26 both suggested ideas which do not work (not to their fault rather it was my laziness in asking the question properly). I re-worked the suggested solution to present the spirit of the intended function using the new specs above.

      (def ugh (str v)
        (let x 15
          (on c str
            (let xi (* x 2)
              (if (is c #\A)
                  (++ x (+ xi v))
                  (-- x (- xi v)))))
          x))

My solution after looking hacking with suggestions for ideas:

    (def ugh (str v)
       (let x 15
          (on c str 
             (++ x (sub-ugh x v str index)))x))

    (def sub-ugh (x v str i)
        (if (is "A" (cut str i (+ i 1)))
          (++ x v)
          (-- x v)))

Why wouldn't the ARChitects of LISP or ARC make a set like function that is global within a function ? Doesn't this seem like a smart thing to do ? Is this against the spirit of lisp/arc/scheme ?

  (def ugh (str v)
    (let x 15
      (for i 0 (- (len str) 1) (set xi (* x 2))
        (if (is "A" (cut str i (+ i 1)))  
            (set x (+ xi v))
            (set x (- xi v)) i)) x))

  (= x 100000)
  => 100000
  (ugh "AAAA" 1)
  => 255
  x
  => 100000

Here's a more concise version of that function:

  (def ugh (str v)
    (let x 15
      (on c str 
          (= x (* x 2))
          (if (is #\A c) (++ x v) 
              (-- x v)))
      x))

  (def ugh (str v (o x 15))
    (let x2 (* 2 x)
      (if (is "" str) x
          (is #\A str.0) (ugh (cut str 1) v (+ x2 v))
          (ugh (cut str 1) v (- x2 v)))))