Re: [Cheetahtemplate-discuss] #set vs. #data

[<ir...@ms...>]

On Fri, Aug 24, 2001 at 12:48:13PM -0500, Ian Bicking wrote:
> I kind of like the idea of using #block *only* for defining sections,
> i.e., no #redefine.

Extending templates and using #redefine is a stylistic choice. 
Tavis loves it; I prefer to use a separate nested template instead of
extending.

Now that #block's only practical use is so tightly wedded to #redefine,
it's unfortunate it wasn't called #define.  But it's not worth changing
now because of existing templates and because "#define" is ambiguous.

One can of course use #block to mark out sections but never redefine
them, as you said.  But in this case, the "#block" and "#end block"
are essentially comments.  Which brings up the question, why not use
comments instead?

There is a little-known method .kill() Tavis added at my request,
which deletes the block.  But its use in modern Cheetah is little,
since an #if statement gives the same net result but is more flexible.

As an aside, PHPLib templates work by converting the block to a placholder
value and inserting a reference to itself.  But PHPLib's templates don't
have display logic or other directives to worry about.

> Attribute definitions (for inheriting... something like actual class
>   definitions, perhaps with #define [like def in python], accessed
>   with $self.attrname)

Same as #data, if I understand what you're saying.

> Maybe attribute definitions could take the place of macros -- i.e.,
> you could do something like:
> 
> #define $row($name, $phone)
> <tr><td>$name</td><td>$phone</td></tr>
> #end define
> 
> Where $row becomes a method.  But if you don't give arguments, then
> it's a zero-argument method.  Since it's a method, you still do
> variable insertion at runtime, using the searchList, $self, etc.
> 
> OTOH, it would be nice to have pure string variables of similar sort.
> In part because strings are easy to inspect, while methods are rather
> opaque.  For instance, 
> 
> #define title
> My Page
> #end define

Fine for one variable, but what if you have N variables?  You'd need N * 3
lines to define them all.  (Or N * 4 lines if you put a blank line after each
one.)  Wouldn't it be cleaner to do:
	#data
	var1 = "Value 1"
	var2 = "Value 2"
	#end data
and have them all fit on half a screenful?  (I assume we're talking about
constants that won't change.)  Plus if you *do* need to calculations or
function definitions, you can put them in the #data block too, so all the
assignments are together.

> Obviously, $self.title doesn't need to be a method, and it would be
> nice to be able to extract the title without having to execute a
> method.  Maybe zero-argument functions should be like 
> #define $title().
> 
> Nested defines might also be possible, like nested blocks.  But again,
> if those defines have variables I'm not sure how that's supposed to
> work.  I really don't like the notion of compile-time evaulation
> vs. run-time.  There shouldn't be any compile-time evaluation, just
> parsing (and #include *could* be considered a parsing directive).

We want to make sure Cheetah doesn't get too complicated, with special
cases and hard-to-predict interactions all over the place.  Consider
Java vs Python.  Java has all these extra rules and constructs for inner
classes (=classes inside classes), accessing an overridden method
( super.METHOD() ), a special syntax in the init method to call the
superclass' init method ( super() ), and it even has a "new" operator
for creating an instance.  Python gets along beautifully without any of
that crap.  Want an instance?  Call the class.  Want to call an
overridden method?  Just do it.  Want to create an inner class?  Just do
it.  Want to rename your class?  No need to rename __init__ .

Macros have proven uses, as do blocks and placeholders.  It's already
difficult enough to explain the differences between them, but they do
their jobs well.  Adding #setquote is easy because it's just a different
quoting mechanism.  But adding a new concept that is "sort of like a
placeholder and sort of like a macro" just makes it more difficult for
people to get their heads around Cheetah as a whole.  (Guido has said
the same thing about Python.)  Perhaps we can do it someday, but it will
need to address a widespread, well-defined and discrete need.

-- 
-Mike (Iron) Orr, ir...@ms...  (if mail problems: ms...@ji...)
   http://iron.cx/     English * Esperanto * Russkiy * Deutsch * Espan~ol