>    Arc > (eval (thad QYVSn5n1))
  >    ; this works... 

Actually (if I understand your code correctly), you don't need the call to 'eval here, since everything put into the REPL already gets evaluated.

  >    Arc > (eval (thad ((temp-table 0) 1)))
  >    Error: "Function call on inappropriate object

If you want to get the value of symbol instead, try using 'eval on the symbol.

  arc> (= tab (table))
  #hash()
  arc> (= (tab 'foo) 'bar)
  bar
  arc> (= bar [prn "Hello, " _])
  #<procedure: bar>
  arc> (tab 'foo)
  bar
  arc> (eval (tab 'foo))
  #<procedure: bar>
  arc> ((eval (tab 'foo)) "world")
  Hello, world
  "Hello, "

I hadn't thought of this option because I had been storing the order number in the key position and wouldn't have been able to bind anything to a number like '0'. I was doing this because; calling the table using any table function that return all entries, does not return the order as it was stored, but rather it seems to return them randomly (and the order stored was not sortable). ex. (temp-table) or (vals temp-table).

I hope that made sense.

As for the other question(s),I'll try not to overwhelm....

I'm letting users upload one or many spreadsheets of their choice.... so I then store into a newly generated table which in turn generates html table(s) accessible using their web session. After they close out the web session there's no need to store the data since it will write it back out to a new spreadsheet an store it locally for them. Since I am re-using these functions, i've made them generic, but if they refresh the webpage the html-table functions needs to re-run passing in the correct table-names...so I keep track of which tables had been created for re-loading, hence the storing of the table names as symbols in a table.

I doubt that made sense, but it's what i could muster after 6 hours in front of this code :)

Thanks. T.

Yes, if you need to keep track of things in a particular order (such as the order you added them), you should put them in a list.

Note that you can put the same data in both a list and in a table, if that is what you need for your application.

hence the storing of the table names as symbols in a table

If you want to have a mapping of table names to tables, you can store that in its own table:

  (= tables* (table))
  (= tables*!QYVSn5n1 my-data-table-1)
  (= tables*!UYg47nnb my-data-table-2)

  (let table-name 'UYg47nnb
    (let data-table (tables* table-name)
      ... (vals data-table) etc. ...

    (= my-data-table-1 (table))
    (= (my-data-table-1 'drink) 'milk)
    (= (my-data-table-1 'eat) 'eggs)

    arc> (keys my-data-table-1)
    (drink eat)
    arc> (vals my-data-table-1)
    (milk eggs)

    (= my-data-table-2 (table))
    (= (my-data-table-2 'run) 'fast)
    (= (my-data-table-2 'walk) 'slow)

    arc>(keys my-data-table-2)
    (walk run)
    arc>(vals my-data-table-2)
    (slow fast)

    (= tables* (table))
    (= (tables* '0) my-data-table-1)
    (= (tables* '1) my-data-table-2)

    (def load-ordered-tables ()
      (for i 0 (- (len tables*) 1)
        (let current-table (tables* i)
          (pr (vals current-table))
     )
      ))
	

    arc> (load-ordered-tables)
    (milk eggs)(slow fast)nil

If it turns out that you just need a list of your data tables, you can do this:

  (= tables* (list my-data-table-1 my-data-table-2))

  (def load-ordered-tables ()
    (each current-table tables*
      (pr (vals current-table))))

    arc> temp-table
    #hash((0 . (0 hUv086uP)) (1 . (1 CH3w2sdp)))
    
    arc> ((temp-table 1) 1)
    CH3w2sdp

    (= CH3w2sdp (table))
    (= (CH3w2sdp 'run) 'fast)
    (= (CH3w2sdp 'walk) 'slow)

    (def thad ()
       (eval `(vals ,((temp-table 1) 1))))

     arc>(thad)
     (slow fast)

The example:

    (= bar [prn "Hello, " _])

I'm not sure I understand what you're doing, but perhaps you need another table that maps the symbols you created to the tables they refer to. Call it table-names. Then you could rewrite thad like this:

  (def thad (table-or-table-name)
    (if (isa table-or-table-name 'table) (do-what-you-did-before)
        (thad (table-names table-or-table-name))))