World: r3wp

The fact that I needed to allocate a local struct was pointed out 
to me by the new initialisation checks in Red, so that's pretty good

It would be nice to be able to use SIZE? on a datatype, instead of 
an actually existing data value:

size? integer!

That might only be useful with integer! as it should be extended 
to 64-bit when Red/System will be ported to 64-bit platforms. But 
I think that a specific macro would be more appropriate (something 
like integer-size?).

or rather: get-integer-size

No, I simplified the example. I actually wanted to get sizes of structs 
without allocating one

Try with an alias (untested).

Doesn't it get the size of the pointer then?

Let me try...

SIZE? doesn't seem to recognize the alias.

An alias is an abstract definition, it doesn't allocated anything. 
So we can decide that the size of an alias is the whole struct size.

allocated => allocate

Yes, that's what I would like

In the runtime, there's now a new generic pointer type defined:

#define byte-ptr!	c-string!

However, it's type incompatible with the previous definition, which 
NULL still uses:

null: 		pointer [integer!]				;-- null pointer declaration

The documentation specifies a third definition, namely integer!

This comes back to the lack of a void pointer type again

There is a ticket about null: https://github.com/dockimbel/Red/issues/96

Failing that, I think these definitions should use the same type

The new ALLOCATE and FREE use c-string! which makes using them on 
generic byte arrays, and comparisons with NULL, confusing

NULL will be adapted to cop with that (either using polymorphism 
or by replacing it by a NULL? macro).

I find ALLOCATE and FREE using c-string! unintuitive

Other types need to be cast to use these functions

Same as malloc() with C void pointers.

Still, why do we have now have three different definitions of a generic 
pointer?

There is no such thing as a generic pointer in Red/System.

I know, but I #define it as handle! like we talked about before, 
but there's now no way to define handle! in such a way that it works 
everywhere

Have you tried with defining it as integer!?

I once did, but I doubt it will now compensate for c-string! and 
NULL

Integer! is conceptually the closest type to handle!.

Yes, so why not define NULL and byte-ptr! as integer?

About NULL, please read the ticket on github I have posted above. 
NULL will be changed.

Sure, but why not fix this inconvenience right now?

I don't care what handle! is, just that there are three incompatible 
definitions

Because I currently work on another ticket.

It's just changing the two lines I cited above

I don't mean right now right now, I mean before making NULL polymorphic

The NULL changes will be done this weekend, you won't have to wait 
too long.

That still leaves the incompatibility between byte-ptr! and the documentation

byte-ptr! as integer?: certainly not, byte-ptr! as it names implies 
is a byte! pointer, so semantically different than just integer!.

But you're saying all the time that a void pointer is conceptually 
closest to an integer?

Right.

You should erase the "void pointer" expression from your mind, it 
is corrupting your vision. :-)

Again, I don't care much what it is (although I wouldn't expect ALLOCATE 
to return a c-string!), just that the definitions are compatible, 
so you don't have to insert confusing typecasts everywhere

I'm just following what you have written in the manual about pointers

the definitions are compatible
: which ones?

NULL, byte-ptr! and the manual use three type incompatible definitions. 
I must compare and pass these types

NULL and documentation will be fixed during this weekend.