Hi Eric >Hi Elan, > >Sorry I've had to delay responding. You wrote: > >>That's the problem. type? any-string! indeed returns datatype! However, >>any-string! is not a datatype!. As you point out later, it's a >>pseudo-type!. Therefore, it's a mistake when type? returns datatype! as >>any-string's type. Type? should report that any-string! is a pseudotype!, >>right? >> I'm not quite sure whether you agree with this statement? After I read the rest of your message, I tend to think you disagree. What is the point of insisting that any-string! being a pseudotype, is a datatype, when make complains that it cannot process any-string! as a datatype! - and that is because any-string! is a pseudo-type? I'm just proposing that the datatypes be classified consistently with the way make processes them. After all, datatypes and make are closely related. >>> >>>I <<think>> what happens here is that any-type! is not a fundamental >>>datatype, >> >>never heard of a fundamental datatype. According to make's help text it >>doesn't require a FUNDAMENTAL datatype, but a datatype. Perhaps make's >>attempt to use any-string! as a datatype! fails, and therefore ... >>eventually, REBOL reports the error. > >I got the term fundamental datatype from the REBOL help file valabout.html: > > Fundamental Datatypes > Following are the fundamental datatypes of REBOL. These are the scalar, > and constructed values. These datatypes are divided into scalars and > series. > That's in the new beta manual, right? I guess REBOL and I will have to read it. ;-) Then let make complain that it cannot process any-string! because any-string! is not a "fundamental datatype"! At this point in time make reports that it cannot process datatypes, even though it can process datatypes, provided they are not pseudotypes. > >Also, MAKE, in its interface, does not require any particular datatype; both >arguments are specified as any-type!, which means that any errors will occur >internally, during whatever processing MAKE performs. Agreed. Look: >> make ** Script Error: Cannot use make on unset! value. ** Where: make [snip] >Note the word "expected" - this error happens, I take it, before LENGTH? ever >gets called. Maybe it would be more precise to say that the error happens, when length?'s first block, the argument block, is evaluated. > >Here's the error message from MAKE: > >>> make any-string! "any-strings, anyone?" >** Script Error: Cannot use make on datatype! value. >** Where: make any-string! "any-strings, anyone?" > >This seems to be an error message peculiar to MAKE, and I interpret it to >mean that MAKE "attempted" to make a new datatype, and failed. Agreed. [snipped more interesting stuff on datatypes, pseudotypes and make. Read Eric's message, if you haven't.] > >Conclusion: pseudotypes are datatype!s, they just aren't make-able. If pseudotypes are datatypes, and make *can* make datatypes, but make *cannot* make datatypes that are pseudotypes, wouldn't it be more meaningful for make to report that it cannot make pseudotypes, which indeed it apparently can't, than for make to report that it cannot make datatypes, which it can? I believe that the way make determines what it is incapably of making, is by asking the argument it received what kind of type it is at the time it generates its error message. type? any-string! returns datatype! and that is what make uses in its error message. So, all I'm saying is, if any-string! returned the type pseudotype! instead of datatype!, then make would not print a misleading error message. Misleading in that make claims it cannot make a datatype! value, even though - if I understand your examples correctly - it can, if that datatype! is not a pseudotype. Elan Elan
