How can I get a handle to a nested procedure in skill++?

Using legacy SKILL, which is dynamically scoped, you must use either funcall or apply to execute lambda functions.

However, in SKILL++, it is possible to call function objects directly.  For example, consider the following set of procedures organized into a package:

/*
  Example of how to organize a package in SKILL++

  The procedures are only exposed through the global var (testPackage)
*/
importSkillVar(testPackage)
testPackage =
let(((count 0))
  procedure( increment()
    preincrement(count)
  ); procedure
  procedure( decrement()
    predecrement(count)
  ); procedure
  list(nil
    'increment increment
    'decrement decrement
  )
); let

You can then call the functions directly, such as:

load "testPackage.ils"
testPackage->increment()
testPackage->decrement()

The problem I have is I have the string name for the procedure I want to call.

In the context of your example,  say I had another procedure in the package,  some how in that procedure I get the string "increment" (maybe it was read from a file or an ipc message),  how do I use that to call the increment procedure?  I guess an other option is to store the function objects in table or DPL like you show and then look them using the string.

BTW I did see this approach of only exposing the one global variable,  but in my case I don't even need to expose them,  the functions I need to call via a string name are called from within the package,  but I can still use the same approach even if I don't need to use expose them externally.

Thanks for the reply, it helped!

Btw,  how do you format code here?  did not seem like the normal markdown worked

It's not entirely clear (to me at least) what your goal is here. If you create a function within a function using procedure() in SKILL++ it is local to the function - that's intentional (and very useful). Your alias myAlias1 is also local because you put it in a let.

If you want to make them global (but still lexically scoped) you can use globalProc() instead of procedure. If you don't want to make them global but callable via a string name of the local function within the lexical scope containing the functions, you can do:

funcall(symeval(stringToSymbol("myFun1") theEnvironent()))

In other words, use symeval() with a symbol but with the environment passed instead.

Regards,

Andrew

Hi Andrew,

I was about to answer the same but you were faster!

I would just use concat (and strcat) instead of stringToSymbol (and symbolToString) as they are faster and more flexible (they support both string and symbol inputs [even numbers for concat] and several arguments as well)

Cheers

Aurélien

AurelBuche said:

I would just use concat (and strcat) instead of stringToSymbol (and symbolToString) as they are faster and more flexible

I even originally used concat in my reply, but changed to stringToSymbol as it's a little more expressive. The performance difference is pretty unlikely to be significant (the difference was ~7s vs 4s for 100 million stringToSymbol/concat calls). But fair enough... I'd probably use concat myself!

Andrew

I know the difference is extremely little but before answering I used the time profiler and got the following results

(which makes me think that stringToSymbol uses concat internally)

(for i 0 1000000 (stringToSymbol "abcdefghijklmnop") (concat "abcdefghijklmnop"))

Function Name Total Inside CallCount

------------- ----- ------ ---------

TOTAL CPU Time (secs) 0.53 0.53

toplevel 0.53 0.06 1

stringToSymbol 0.24 0.24 1000001

gc 0.14 0.14 1

concat 0.09 0.09 2000002

symeval(stringToSymbol("myFun1") theEnvironent())

That's what I was missing.

I know it was a contrived example.  In the end the outer function would return one of the nested functions (a "server"),  which the user would invoke.  The "server" would need to invoke some of the inner functions given string name of the function. I nested the functions to keep them local and only expose the "makeServer" outer function.  Hopefully that makes sense..

Searching the reference for e_environment is also helpful.  

Hi John,

Regarding your question about formatting, I use a simple script that Andrew Beckett created back in 2010.  I'm not sure how to share that script, but it basically boils down to this:

FILE=$1

echo "Content-type: text/html"
echo ""
enscript --color --language=html -Eskill --output=- $FILE

Then, you can copy-paste the output of that into the type-in field using "Tools->Source Code".