Save variables to a file and load them later

Homoiconicity FTW!

;; Make some variables
myNum = 3
myTable = makeTable("my table" nil)
myTable["apple"] = 1
myTable["banana"] = 2
myTable["cherry"] = 3
myList = list(1 2 3)
myVars = '(myNum myTable myList)

;; Save them in a file
myFile = strcat(getTempDir() "/" makeTempFileName("myFileXXXX"))
myPort = outfile(myFile)
foreach(var myVars
    fprintf(myPort "%s = quote(%L)\n"
        var
        if(tablep(symeval(var)) then
            tableToList(symeval(var))
        else
            symeval(var)
        )
    )
)
close(myPort)

;; Unbind them.
foreach(var myVars
    set(var 'unbound)
)

;; Now reload them.
myPort = infile(myFile)
while(expr = lineread(myPort)
    eval(car(expr))
)
close(myPort)
;; Recreate the table
myTable = append(makeTable("my table" nil) myTable)

Note the code would be way simpler if SKILL had a read syntax for tables.

zmleitao said:

Is there an easy way in SKILL to save variables to a file so as to be able to later loading them from that same file.

You could also create a context file....

> help saveContext
 
saveContext( 
t_contextFileName 
) 
=> t / nil
 
Saves the current state of the SKILL language interpreter as
a binary file. This function must be used in conjunction with
setContext.
t
> help setContext
 
setContext( 
t_contextName 
) 
=> t
 
Allows contexts to be saved incrementally, creating micro contexts
from a session's SKILL context.
t
> help loadContext
 
loadContext( 
t_contextFileName 
) 
=> t / nil / error
 
Loads a context file into the current session.
t
> 

tweeks said:

Note the code would be way simpler if SKILL had a read syntax for tables.

Actually this brings up an interesting point: In SKILL, the only types whose default print syntax is also a useful read syntax are:

• symbols
• lists (including DPLs and assoc lists)
• fixnums
• flonums
• strings
• ports (but only the filename, not whether it was input or output)

Anything else does not (by default) print out enough information to recreate the object, so you have to do extra work to either

1. Generate code that recreates the object (e.g. makeTable() for a table), or
2. Convert the object into one of the above types, then convert back.

Footnotes:

• You can print structs, tables, and arrays with printstruct, if you have a skillDev license, but the output will not eval back into the objects when read with readline--you need to parse it.

   
• You can print function objects using pp(), and they will eval to a new function object when read with readline. 
  • Comments and formatting are lost, though if you had the debugger on when the code was loaded, you can find the line number in the file the procedure was loaded from by getting functionName._loadFile and functionName._loadLine

Actually tables do have a means of writing them to a file - there's writeTable() and readTable(). Of course the downside is that you can only read/write a single table to a file, which may not be what you want. 

Lists can easily be written out, using pprint(), or fprintf(port "%L" ...) and then read back in with lineread. You might want to use sstatus(fullPrecision t) to ensure that floats inside the lists keep more precision.

There is a means of serializing floats, using saveFloat() and restoreFloat(), but SKILL doesn't have a generic seralization capability (like pickle in python). Some things are inherently dynamic and would be hard to serialize. Contexts are sort of that capability though, and with loadTopContextForms() you have a better way of serializing code that needs to be re-invoked at context usage time.

Regards,

Andrew.

Thanks Andrew.  I learned several new things from your post!