World: r3wp

I want title to be local without defining it in the spec. Eval template 
is a function that might be used for many different templates

IMy understanding is that if you bind a word to the local context 
then it's a local even if it's not defined in the spec but I probably 
have multiple misunderstanding (though I just read the Bindology 
Bible by Ladislav)

unfortunately that is not true, at least not in this REBOL version

local contexts are somewhat "static", i.e. they cannot be enlarged

(section 15)

local without defining it in the spec
 -- I don't think that's a good way to think about modeling it.

I see. This is a major limitation. I see the rebol3 has a blog entry 
that "bind expands contexts" How could I approach this with the current 
rebol ?

No, that's right. Contexts cannot be extended with new words (at 
this time).  I would pass a context to your function with the template 
and all the words in it. This context will have to be built at the 
beginning.

It's still not clear to me what the real goal is. i.e. where values 
come from and how eval-template may be reused without giving it some 
parameters to guide it.

Sorry, I mean you eval-template function can create a context on 
the fly with the words in it.

ok Anton, I will try to implement this with your approach

It's not a terribly easy thing to do, but can be done.

Gregg, the GOAL is to be able to have a generic eval-template function 
that can evaluate multiple templates without having to include hundreds 
of locals in eval template. The values are generated dynamically 
with a code-block e.g. eval-template template code-block where code-block 
is [title: func-title "aha" tag1: emit-whatever ...

hmm, I may not understand your wish, Joe, but don't you want to have 
it this way?

Today I reread the blog, and I was not comfort with the idea that 
simple bind should auto-extend context ... maybe just my internal 
feeling, dunno .... just wanted to state opinion of less experienced 
reboller :-)

eval-template: func [
    template
    /local res
] [do something with the template...]

Eval-template will accept a template string
1) convert to block
2) extract the words
3) create a context with these words
4) unset all words in the context

5) do your code bound to the context   ( do bind your-code the-context 
)
6) handle errors
7) return results

What I've been using in the past is different versions of eval-template 
for each template and I found the typical bug to be when missing 
a local given that the templates are evaluated multiple times

After extracting the words you need to convert them all to set-words 
and put them in a spec block, eg:
spec: copy []
foreach word words [append spec to-set-word word]
append spec none
; now you can create the context using the spec
the-context: context spec
; now unset each word in the context, etc..

Yes anton, I will code it this way. I am worried that unbinding the 
words every time is a performance hit

Possibly, we can optimize it later. Binding is supposed to be pretty 
fast in rebol.

Ladislav, I will try to communicate better. What do you mean by "don't 
want to have it this way ?"

eval-template: func [
    template
    /local res
] [do something with the template...]

I just thought, that you wanted to have a function accepting and 
processing templates

Yes, my problem is an error handling problem. So far the template 
blocks are global, and I want to have functions that can build the 
templates without actually passing the template as a parameter

it looks, that you actually don't need UNBIND

Could I ask again for pseudo-code? I'm having the same problem as 
Ladislav I think.

If we could step back and look at the problem, without implementation 
details, it would help me to understand.

Yes, it's a bit confusing jumping straight into it like this.

I'm only asking because I think you're making this a lot harder than 
it needs to be, but I can't be sure if I don't understand the problem.

I've found that I can make things hard for myself, if I fight REBOL, 
or easy, if I don't.  :-)

Yes, I can't say I find myself needing to do such an operation very 
often. Been a while since I generated html though.

a new attempt. The code that follows works except that I have to 
define the tags as locals, which is a pain when there are lots of 
them

template:  	to block!  "<html><head><title> title </title></head><body>tag1 
tag2 tag3</body></html>"

blk:		remove-each val copy template [tag? val]	 ?? blk ; == [title 
tag1 tag2 tag3]

eval-template: func [
	/local res title tag1 tag2 tag3
][
	res: 		copy ""

	bind/copy 	blk 'res

	title: 		"hey"
	tag1: 		"this is tag1^/"
	tag2: 		"i am tag 2^/"
	;tag3: 		"might not be set^/"

	repend 		res bind/copy template 'res
	res
]


probe eval-template

so in this example tag3 is none because it was not set in the body 
but this is clearly an error. I am trying to solve 2 things:

1) Not having to declare the locals title tag1 tag2 tag3 in the function 
spec but have them as locals (might not be possible)

that *is* possible if needed

2) detect when one of the variables has not been set  . In the above 
example with locals defined this can easily be fixed by checking 
for tags that are none

Ladislav, then if there is an elegant way to define the locals inside 
the function body given blk: [title tag1 tag2 tag3] my problem is 
solved

Why not just use FUNCTION with your existing code body and spec; 
make eval-template funcs on the fly?

You would have to define a function every time, yes.

(for the same reason - contexts can't be extended with new words).

Yes,  but how costly is this ? ( I currently can generate 1000 pages/minute)

I would still lean towards a higher level solution at some point, 
but this makes more sense to me than messing with bindings.

;This is one way how to do it:
eval-template: lfunc [template [string!]][] [
	res: 		copy ""

	bind/copy 	blk 'res

	title: 		"hey"
	tag1: 		"this is tag1^/"
	tag2: 		"i am tag 2^/"
	;tag3: 		"might not be set^/"

	repend 		res bind/copy to block! template 'res
	res
]

see http://www.fm.tul.cz/~ladislav/rebol/lfunc.rThis would throw 
an error if the tag3: line is commented

Profile it. :-) How many do you *need* to generate, how much data, 
how many tags, etc. There are a lot of variables here (no pun intended).

there are three approaches so far: 1) building function everytime 
with locals (anton/gregg) 2) template object (anton) and 3) lfunc

I am going to code this using lfunc for the simplicity it brings 
and see what I learn Thanks all

the LFUNC approach would cause an error if the 'TAG3 variable were 
used in the template, otherwise it wouldn't cause an error. Is that 
what you wanted?

(if your templates are not changing, the corresponding template objects 
can be made once and reused many times).