World: r3wp

I still think, it will be good to have a list of examples, so it 
can be actual seen, what all this means. You and I understand it, 
but does everyone else?

i think, these should be listed somewhere in the core guide.

hmm. examples of valid and invalid words? agreed. but it's a different 
thing from a table with all datatypes and saying that some of them 
are words - that's confusing; only values of the word! type are words.

what you say instead is that some values do not have a mold representation, 
so that they mold to something that once evaluated, returns the value 
(eg make object! ... and so on).

it's to avoid letting people grow with "wrong" ideas ;-)

We might move to beyond "I'm new" here, but we have a slighty different 
understanding, I think.

none is always a word

There is a possible trap here for the new one. This is output from 
my terminal:

>> blk
== [none]


Is that "none"-word a word in the REBOL understanding of a word? 
It depends on, how I made it. Did I write:

>> blk: [none]
== [none]

or did I write:

>> blk: []
== []
>> append blk none
== [none]


For the programmer being new to REBOL, it may be hard to see the 
difference. And the sentence "none is always a word" may only apply 
to the situation, where values are being fed into REBOL, not when 
I write:

>> blk
== [none]

Or what?

that's the difference between not having a mold representation and 
having it.

none values mold to a word. so, yes, it's a word you see there.

you see a word not because there's a word in the block, but because 
none values mold to a word.

it's MOLD the issue here, not NONE!.

(neither WORD!)

Gabriele; "there is no mystery, words are just words".


I'll reiterate what John said.  It may not be obvious to everyone. 
 It's like tying your shoelaces.  Once you know, you just "know" 
and it becomes impossible to "not know".  But until then it's a mystery 
and you trip over your shoelaces.


none always looks like none.  There is nothing obvious in a: none 
 a: [none] until you trip.  Then you know, kinda.  It is very very 
easy to trip over   if first [false] ["I trip"].  The fact that false 
and #[false] are two completely different things needs to be disseminated 
to the new user, explicitly.  Mainly because in trheory it is obvious, 
in reality it is mysterious.

And as you are pointing out now...the issue is goes deep enough to 
warrant discussion among high level REBOL programmers, although perhaps 
not at the 'tieing shoelaces' level.  :)

but if you tell newbies that sometimes none is none and sometimes 
not, you're just confusing them.

not telling the truth is always against learning

so, you just tell the truth: MOLD is cheating. just use MOLD/ALL 
to see what's actually there.

Yeah, I explained to Robert that the group here may have to suffer 
through some 'Tier B' advice  :)  There is a knack to explaining 
the deeper issues that can only come with enlightenment.   I have 
been trying to explain that the visible none is not the value none, 
but lack the vocabulary, based on the lack of deep understanding 
and experience.  It will come.

Right now, I think I'm at the stage to just know enough to be dangerous. 
 :)  This particular conversation has helped immensely in gaining 
the proper vocabulary (for this issue), the next issue is just over 
the horizon :)

:-) We're getting closer!

Ok, we have words and we have datatypes. Words are also a datatype, 
namely of the type: word!

The exercise then is to figure out, which datatypes can be put in 
a block with a simple assignment, and which are simple words, even 
if they look like being of another datatype, when they are typed 
in.

A summary of REBOL datatype values can be found here: http://www.rebol.com/docs/core23/rebolcore-16.html

I see it from a different point of view:

A word is a value; all values have a datatype.

All values are evaluated by Rebol.

Some values evaluate directly (ie 1, 1.999)

Some values evaluate indirectly  (ie a, b c)

ie should be eg

i'd say that differently. some values evaluate to themselves; other 
values evaluate to some other value. a paren evaluates to the result 
of DOing it. a word evaluates to the value it's bound to. a lit-word 
evaluates to the respective word. and so on.

directly
 and "indirectly" is quite vague.

Gabriele, what is the correct way to specify, what's happening with 
a simple block assignment, like:
blk: [a-word 123]

It's kind of partly being reduced, so 123 ends up as a number! instead 
of a word!.

Why do you say that 123 ends up as a number! instead of a word! ?

>> type? 123
== integer!

123 is always a number. no evaluation needed. words cannot start 
with a digit so 123 never gets loaded as a word value.

From the previous discussion I got the impression, that everything 
is words, when they're typed in, or viewed as output. My reasoning 
goes as: if NONE is a word when inside a block (initally without 
specifying, what we do with that block), then everything inside a 
block must be words (initially). Then the input parser take that 
block and figure out, what's inside. Some of the stuff inside ende 
up as other datatypes (in this case integer!), others are left as 
words. Or?

What I find a bit peculiar is, that things like [integer! none +] 
are left as words and not being parsed to the expected datatypes.

no, you're wrong

when you LOAD, text is converted to rebol values. type is determined 
by syntax.

only things that have a syntax that matches a word! are parsed as 
words

123 is parsed as an integer. 123.0 as decimal. 123.1.1 as tuple. 
and so on.

values like none, true, false, etc. do not have such syntax (actually, 
it has been introduced later, and it is #[none], #[true], etc.)

a b c d ... all match the syntax for word! values and are loaded 
as such. the spelling does not matter at all. from the point of view 
of load, there is absolutely no special meaning to the word none 
or the word false. they are just word values like any other word 
value.

Ah, I'm beginning to see the light! If integer! shoud be seen as 
a datatype!, then it has to 'read' the on the word somehow, and if 
"!" was used to distinguish it, then I couldn't use "!" in my own 
words. And none is just a word, nothing special about it's presense. 
And I could have my own none values, like: my-none: :none

But but but ... why doesn't it look it up and see, if that word has 
a value? Will that give problems? *thinking*

then it has to 'read' *that* on the word somehow

looking up the values of words is something that is not what LOAD 
is supposed to do. you could load a dialect block or just some data. 
words can be used just as symbols, not to reference values.

So to sum it all up. To attack the problem, Brian original posted 
about none being a word! sometimes and being none! sometimes, programmers 
should learn the rules about, how REBOL distinguish values. The special 
char rules, Gabriele pointed out up there. And then, if none of those 
special chars are encountered, the sequence of characters are just 
seen as a word.
Is this correct? :-)

I will likely put this in any tutorial that I prepare:
	reduce [ does  [ join "R" "3" ] ]

Geomol, i think that's correct, but i may have missed a few chars 
or rules, so please check the core guide.

re: comments in 'core' on the plague of MI ...

multiple inheritance works rather nicely in Curl since you are required 
to provide 'secondary'  constructors - I prefer prototype-based with 
an option for class hierarchies, personally ( try experimenting with 
Logtalk if you can find time ).  I am watching Io, the language, 
evolve as Rebol3 emerges: what is interesting to me is that I ask 
'But is that Oz ?' in Oz. ( which is multi-paradigm )  I used to 
hear a lot of 'getting it' about Prolog and Smalltalk.  After almost 
2 decades in both, I think many of them "didn't get it" ( class hierarchy 
obsessed, as ST purists are/were ).  Ruby is so much like Smalltalk 
that I am quite enjoying watching Groovy play catch-up with Ruby 

Most issues in Rebol have a parallel in Javascript; where ( for the 
neophyte) experiments with 
	typeof

in a console is about the only way for the average developer  to 
'get  it' given
	d1 = Date  // now you use d1 as a function d1()
	d2 = Date()   // d2 is a string that looks like a number   

 d3 = new Date() // d3 is an object but it is UTC but it is presented 
 local time but it is compared UTC .... 
or
	s1 = "string"
	s2 = String("string")
	s3 = new String('string')

 s3[1] = 6   // s3 is an object, as typeof of reveals; String 'equality' 
 in JavaScript even with === is no end of grief  and  for what convenience 
 ?
	s3["size"] = 6
or
	a1 = Array(42)
	a2 = new Array(42)

I think the latter 2 show just how rushed LiveScript was pushed/forced 
out to market as "LavaScript" before the Sun "StrongTalk" folks had 
much influence on the Netscape folks ....  Rebol3 is in better hands 
than 'ActionScrtpt'  as it drifts into classes - because it is being 
kept 'in hand''

The changes in Groovy as it complied with the JSR for Java scripting 
are interesting ( Groovy is almost neat as Rebol would be if it were 
confined to, say, living on  top of VisualBasic ;-)  Now to avoid 
'Rebol on Rails' ...

I think some people who adopted Spring to cope with Java would appreciate 
Rebol ( there, too, you have to 'get it ' )

 MySubClassObject.prototype = new MyParentClassObject()   // now go 
 mess with THAT object before it is useful ...
	// ...

 MySubClassObject.prototype.superclass = MyParentClass  // to fake 
 having a superclass other than Object
cannot be much easier to "get" than anything about Rebol
	use    ; now mostly use /local
and

 bind   ; modifies the block it is passed; use COPY refinement to 
 preclude this side-effect

Smalltalk80 was like "Rebol4" as compared to the first passes at 
an O-O language ...  someone who actually understands Smalltalk contexts/blocks 
and JavaScript should 'get it' with Rebol ( some of those people 
are using Seaside with Squeak, Dolphin and/or VisualWorks ST )

  my 2 cents:  a1 should have been an array of fixed size and only 
  a2 should be a Vector object

I meant that I don't much ask ''But is that Oz?" the way we ask "but 
is that "Rebol?" or "But would that be Rebol?"  It comes from my 
aversion to the questions/attacks of  purists who insisted that Turbo 
Prolog was not really a PROLOG.  Neither is what Prolog became (Prologia 
IV)

The Slate team for Smalltalk3 ( if you think of JavaScript as Smalltalk2 
 [heresy] ) now have Self and Strongtalk to look over with 15+ years 
of hindsight.
It appears to have slowed them down a lot.

I can't wait to get my hands on that Rebol3 beta ...

PS  if you don't think JavaScript was Smalltalk2, just look at Io, 
the language ;-)

PPS  the author of CTM was probably asking himself "But will they 
see that this is not Oz? " with every chapter (Peter Van Roy,  'Concepts, 
Techniques and Models of CP', MIT Press) - the O-O chapter is arguably 
the worst flaw in a fine MIT intro book - unless it is the flaw of 
totally ignoring JavaScript as a functional prototype-based lang. 
( and I don't recall mention of Curl or Rebol )

Another language evolving: Cecil into Diesel

ah, c'mon
	mold/all reduce [ does [ join "Rebol" "3"]]
is cute ...

 ( as I wait to be reduced to a puddle one atom thick for failing 
 to fit the mold )
I'll keep my posts, well, shorter.  Promise. sorta

it's my 'Liquid Rebol' joke; it belongs in chat.  New people always 
post in the wrong threads.  Better "I'm new" than "They're new" or 
"We're new"
	joke = new Rebol(2)  // javascript

 funnier: make classInstance! RebolObject [prototype! classObject! 
 object! ]

;; this is neat

 mold make object! ["test"]   ;; warning: to preserve a spec block 
 be sure to use    obj: make object! copy/deep specBlk

;; copy/deep issues are rampant in Smalltalk ( if you get the impression 
that I think Smalltalkers neglect Rebol, yer rite )

In relation to Roberts post:

>> load mold reduce [ does [ join "Rebol" "3"]]
== [func [] [join "Rebol" "3"]]
>> load mold/all reduce [ does [ join "Rebol" "3"]]
** Syntax Error: Invalid construct -- #[
** Near: (line 1) [#[function! [][join "Rebol" "3"]]]

What!? :-)

geomol, that's a bug. i think it's in rambo too.

load mold/all reduce [does [join [ Rebol" "3" ]] ;; thanks. In STSC 
APL we could use 'load' or 'laod' ...
laod: :load  ;; Rebol3 is free of wordspace worry size anxiety
;; my Rebol tutorial would include something on quotes , such as
	>>'test'
	== test'
	>>mold 'test'
	== "test''"

 >>mold join 'test' "tested"  ; note use of {} to avoid double double-quotes
	>> ""test""  ;; error - but which error and why?

 >> "'test''"  ;; be-aware that PDF files may use left-single-quote, 
 right-single-quote, left-double-quote  and single-quote != apostrophe 
 != backtick ...
;; and definitely something to include 
	>> help rejoin
	>> source rejoin

( I am now talking with a publisher. Hurray!  The hard part is behind 
me!   Now to have some fun ...   Dead-line?  What dead-line was that? 
 When!?  )

>>system/console/prompt: [ reform [ now/time ">> "]]  ;; good tutorial 
candidate from 'Rebol for Dummies' by Ralph Roberts
>>to-integer #2A  ;; Hex. But what was the question?

>>big-Q: does [ rejoin [ none ". But the answer is: " to integer! 
#2A]]
>>big-Q

>>little-Q: [ rejoin [ none ". But the answer is: " to integer! #2A]]
>> do little-Q

>> do big-Q ;; now you get an error because none is the has-no-value 
word
>> type? none 
>> path? 'none/first

;; 24Arghhh!{]}['   there was a typo 2 posts back ... cannot go back 
4 2 posts ...
;;

load mold/all reduce [does [join [ "Rebol" "3" ]]] ;;  typo. Arggh!!! 
 in code ending:  " thanks.  In STSC APL blah-blah "
laod: :load
laod mold/all reduce [does [rejoin [ Rebol" "3" ]]] ;; better
laod mold/all reduce does [join [ Rebol" "3" ]]  ;; huh?
mold/all reduce does [join [ Rebol" "3" ]]  ;; oh ...

comment {
	[func [][rejoin ["Rebol" 3]]]
versus
	{#[function! [][rejoin ["Rebol" "3"]]]}
}