Re: Proposal for study: Add a categorical Initial type to ocaml

From: skaller (
Date: Tue Oct 12 1999 - 21:20:35 MET DST

Date: Wed, 13 Oct 1999 05:20:35 +1000
From: skaller <>
To: John Prevost <>
Subject: Re: Proposal for study: Add a categorical Initial type to ocaml

John Prevost wrote:
> Something like that. We can probably define unsafe_create like this:
> let unsafe_create i = (Obj.magic (Array.make i 0) : 'a array)

        Thanks for the example, using Obj.magic. Since this
is not really documented, I wasn't sure how it worked.
This makes the code much cleaner.

> (The above works, I've tested it.


> Now. What can we gather from this? First: by abusing Obj.magic, we
> can do what we want. Obviously, it's not strictly a nice thing to do,
> but if we can prove to ourselves that the code works right, then from
> the point of view of the API's client, everything's great.

        Yes. You've used Obj.magic much as I'd envision I'd
have used an 'initial' value.

> What else can we gather? Well, what would be different if this were
> implemented with options? There'd be the boxing inefficiency, of
> course. Anything else? Not really.

        Yes: the implementation would be much messier.

> So, is there a problem with my solution of working around the type
> system under the API level?

        Obj.magic isn't documented; it isn't really part of the
language. [But I think your solution is fine, provided it works]
> > The initial is not 'strange',
> > rather it is fundamental, the dual of the 'unit' type.
> No--it's strange. The reason it's strange is that it's something that
> can happen to a user that they don't expect. Like null in Java.

        Which is better: initialising something with 'null',
leaving it uninitialised, or initialising it with a dummy value,
GIVEN that it must be declared before the first value is

        It would not be entirely unreasonable to argue
that the dummy value is the _worst_ option, since failing
to subsequently initialise it with the proper value is
guarranteed NOT to be detected by the system (and will be
reflected only in unexpected program semantics). Null seems
better; even a core dump indicates there is an error.
> Why is it [null] a pain in the ass? There's no way to turn it off.

        It's a built in 'a option, for every pointer.

> Like I've been saying, with option you can turn it off, with Obj.magic, the
> implementor ought to be damned sure he's doing things right. But with
> these special "uninitialized value" sorts of things, people like me
> who've gotten used to good type systems keep looking over their
> shoulders because they're afraid it might turn around and bite them in
> the butt.

        How is this different from Obj.magic? Can't that bite you
in the ass too?

> It's appropriate for exceptions to be thrown when out of bounds array
> accesses happen--although I'd rather it weren't.

        It's better if the compiler checks. In Pascal, array bounds
cannot be exceeded. [The index must be of the type for which the
array is declared, which guarrantees it is in bounds]. Of course,
an automatic conversion for int to a subrange can fail :-)

>It's reasonable for
> the programmer to check and make sure this doesn't happen. It's not
> reasonable for the programmer to check that index i of an array that
> was passed in has actually been assigned before now. Much like it's
> not reasonable for the programmer to have to check that the argument
> is not null on a function that doesn't claim to accept null as an
> argument (my Java pet peeve).

        The way I understand 'initial', the programmer not only
doesn't have to check, the programmer _cannot_ check for it.
The check must be done by the system.
> I really think adding anything that can cause more runtime errors is
> likely to be a wart, and no language needs more warts.

        As I said above: I do not see that this argument holds water.
The problem is that sometimes storage must be allocated before
initial values are available (in a procedural language).
It is possible then, to forget to initialise the storage properly.

        Forgetting is the problem, and it causes a run time error,
no matter whether a special 'initial' value is used, Obj.magic is used,
a dummy value is used, or the store is just left uninitialised.
There is no getting around this: the only difference is the _kind_
of run time error.

John Skaller,
1/10 Toxteth Rd Glebe NSW 2037 Australia

This archive was generated by hypermail 2b29 : Sun Jan 02 2000 - 11:58:27 MET