[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Strange behavior of "root" in "over"'s context

From: Giovanni Zezza
Subject: Re: Strange behavior of "root" in "over"'s context
Date: Fri, 31 Dec 1999 13:46:46 +0100

Il Thu, 30 Dec 1999 21:58:56 +0300, Valeriy E. Ushakov scriveva:

>First, to be pedantic, Lisp is *NOT* a functional language.  Second,
>functional languages do *NOT* have _vari_ables.  The most common
>definition of being "functional" is referential transparency, once you
>have variables (e.g. something that you can destructively modify), the
>referential transparency is gone.

Then the question could be why Lout has to be a pure functional language;
or better (let be Lout what it want to be) why a formatting language has to
be pure functional.
Though very interested in linguistic matter (either natural or
computational one) I'm even more interested in having the job done; and I'm
inclined to think sometimes a non functional approach may be more
straightforward than a functional one.
(Thus, another interesting question, though out of topic in this list,
might be: it's possible to have a good designed, free of TeX-like
intricacies, powerful and still "conventional" formatting language?)

>Also (speaking of "more esoteric languages") note that Lout relies on
>the constraint satisfaction engine to perform the layout.

Sorry, I don't understand what this means. Please, give me some references,
if the answer is too long.

>Currently you can use several syntactic kludges to perform simple
>arithmetic on length.  E.g. to shift the vertical mark to 0.3f from
>the right edge of the object you can write
>    -0.03f @HShift { 1w @HShift obj }
>You can do more arythmetic by using @YUnit and @ZUnit as accumulators,
>    1f @ZUnit +10p @ZUnit 0.5z @ZUnit # set 1z = (1f + 10p)/2
>    1z @Width { @FullWidthRule }

I think this is what I was looking for (actually, I tried something like,
but wasn't able to get @HShift accepting a negative value; I'll try again).

>      # ... and so on, defining an algebra on lengths.  See @Diag,
>      # where this is done for vectors (via PostScript), User's Guide,
>      # p178.

Then this is (at least) the second time you do it[1]. Sorry, but I can't
understand why not to have a built in arithmetics written one time and
forever; and why to write it in Lout, like pretending Lout itself not
already know it, while using it all the time.
The problem, I agree, is to have a good syntax and semantic.

>that will introduce a special scope where arithmetic signs have there
>usual meaning, so that one could write

I understand (and agree) the need to have a special scope within only
arithmetics may be used, but I think it shouldn't be restricted a priori to
lengths only.

>    @LengthArith { {1f+10p}/2 } @Wide { ... }
>    x //@LengthArith{0.5f+2p} y
>Instead of messing with @ZUnit assember-like tricks.

This seems to me a reasonably good and comfortable (though a little prolix)


[1] Speaking of PostScript (and Jeff Kingston's complaint about Lout not to
be a complete formatting system because it relies on it) I don't completely
agree with Jeff Kingston's point. (Actually I don't completely agree about
a formatting system having to be a single, self contained monolithic thing,
instead of an environment built up from several instruments.) PostScript is
a great graphic language, and it seems to me a waste of time rewriting even
a subset of it in Lout.
A good thing, instead, would be a better integration with PostScript, maybe
having Lout understanding some PostScript's semantic, or at least
communicating in both directions with it (let's say, Lout isn't Lout but
Lout+PostScript). How this might be achieved (either with an internal
Ghoscript interpret or whatever) I don't know, but I know I would be
grateful to have it.

reply via email to

[Prev in Thread] Current Thread [Next in Thread]