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

Re: [zzdev] Re: [zzdev] More about dimensions (lists)

On Tue, Aug 08, 2000 at 11:48:39PM +0300, Tuomas Lukka wrote:
> Since when are there a finite amount of dimensions? That's news to me ;)

How do you plan to store, say, countably infinitely many dimensions in
your computer?

Tuukka wasn't saying that there is an upper bound for the number
of dimensions.  He just meant, AFAIK, that at any point there are
finitely many nontrivial dimensions. 

> A rank that loops is very useful when you work on operations that move
> the cursor one cell. Think about e.g. finite-state machines. If looping 
> ranks are not allowed, they become much more complicated, because all loops
> must go through two dimensions.

I believe Tuukka wasn't talking about banning loops, but about
banning loops where they don't have a meaning, ie. where they are just
a "convenience hack" - since that convenience hack could in fact be
done in other ways too, for example by defining the "cursor negwards"
operation on a headcell to meaning "cursor to endcell".

> A looping rank means a looping rank - a loop of states. It also meas a *finite*
> list, of the cells starting from the headcell, just as mentioned above.

A looping list can *also* be understood as a finite representation of
a repeating infinite list.

> The question is: do you *want* to distinguish?

And the related question is, whether the clone relation is transitive.
Ie. if A is clone of B and B is clone of C then A is clone of C.  I feel
that it should be.

> d.1 is also used to connect first name and last name, command parameters,
> may things like that.

/me has some problems with using one thing for many things, but that's
probably because /me has been brainwashed by the department :-)

> Try rereading the place
> in literary machines where Ted talks about "noids" and the enforced difference
> between '0' and 'O'.

Is "literary machines" available somewhere, in a readable format?

> Languages that support lambda calculus usually
> pour a HEAP of syntactical sugar on top of it - guess why.

Hmm, how about a list?

Take Scheme.  It has no syntactic sugar on top of lambda calculus.
It just has the minimal set of special forms necessary in a strict
language - and a set of means to build new special forms.  If Scheme were
nonstrict, even those would be unnecessary.  I believe one could build a
Scheme implementation from just lambda calculus in fully parenthesized
prefix syntax, some basic values and primitives for interfacing with
the rest of the world, and the special forms "if" and "syntax-rules".
The rest of the standard special forms such as let and case can be built
using the language itself.

I don't know about Tuukka, but my sense of aesthetics says that things
should have a simple but powerful foundation (such as lambda calculus
for a programming language) which has powerful abstraction mechanisms
that allows you to build anything you like on top of it.  I don't care
if you define even a large standard library (such as Common Lisp does),
but I want the core to be small.

> Lambda calculus is a nice theoretical tool but for doing anything with it
> in real life, most people will usually need more powerful tools on top.

Actually, lambda calculus *is* all you need.  If you're using applicative
order reduction, you can build anything on top of it, and if you use
normal order reduction, you just need a handful of carefully chosen
additional special forms.  The reason most implementations of functional
languages have more primitives than that is *efficiency*, not expressive

Haskell, for example, has a very small core language, and there is a
set of ad-hoc syntactic sugar on top of it mainly because they didn't
have Polyglot :-)

> In the same way, having sets on d.next would be much nicer *theoretically*
> an in practice. On a theoretical level, I'd possibly agree.
> However, when you get into practice, the picture changes. It is much
> easier to do things if there are more dimensions "free" and dimensions
> have meanings.

How do d.1, d.2 and d.3 have any meaning at all?  Why not call them d.foo,
d.bar and d.baz?  They'd be about as descriptive.

And we have a countably infinite supply of dimensions.  How can we ever
run out of them?

Trying to understand,
%%% Antti-Juhani Kaijanaho % gaia@xxxxxx % http://www.iki.fi/gaia/ %%%