World: r3wp

[

, "]", "/" and "-" were chosen because they can be typed on a US 
English keyboard without using the shift key. The fact that you can 
program in REBOL without using the shift key most of the time speeds 
up your typing of REBOL code (though not the name REBOL).

I'll just make a remark about "invalid" data.  If the lexical stashed 
those in foreign! it would no longer be "invalid", it would become 
the REBOL foreign! datatype!   You can't add email! url!   but they 
are sitll loadable values.   And again, professionals are NOT who 
I want to assist here.  It's the casual home user.   Allow 1000 casual 
users, 30 might become rebols, 1 might become a valued member of 
REBOL3 that we learn something from or develops Video Altme.   We 
add to the pile.

beware Brian, there are some commas in your last sentence...

a comma would be lexically foreign!

I was typing in English, not REBOL. There's a difference.

Need the Rebolish group for contrast (if it's still around...)

If I had known English and REBOL the same amount of time, I would 
be able to read REBOL quicker because the rules are stricter, and 
because I wouldn't have to look for periods and commas. This goes 
more so for C-like syntax - even slower to read.

brian, I think everyone is just talking about a standardized, way 
to load human-readable data.  we know its not REBOL data.

On my current screen I can barely see periods and commas in AltMe 
(netbook).

Why can't junk be REBOL data, with semantics of junk!  ??

If can tell someone that he can use his "CURRENT" data directly within 
rebol, there is a chance he'll actually try it out..

Ahh, the point exactly.  ;)

we aren't talking about code, we are talking about DATA.

I think we should have a function called 'ASSIMILATE.

Maxim, I agree with you! I just remember that LOAD is for loading 
REBOL data, not human data. We should have standard functions for 
parsing human data, localized. But there are real disadvantages to 
making LOAD that function.

which is even more semantically exact than import.

it's not the only one problem, the need to parse data previously 
only to remove such junks reduce the overall performance of our scripts

and the new name is... REBORG    ;-)

LOL

For that matter, every option added to a function is an option that 
needs to be checked at runtime. That has overhead too.

Steeve; I'm not bringing up this point for OUR scripts, it' grandma's 
and Joe the Plumbers.

are the republicans allowed to use our fabulous REBOL ?

If you want to make a grandma language, good for you. I say language 
instead of dialect because changing the syntax changes the langage 
- dialects use thee same data syntax, that is where they get their 
speed.

Steeve, I'm sure we have Republicans in the community (Paul?) :)

lol

Do you not see the simplicity of foreign! data?   No speed problems, 
the lexical gets to a point where it would throw and it stashes a 
foreign!, keeps on truckin'.

Here's the current source for LOAD:

load: func [
	{Loads a file, URL, or string.}
	source [file! url! string! any-block! binary!]

 /header  {Includes REBOL header object if present. Preempts /all.}

;	/next    {Load the next value only. Return block with value and 
new position.}

;	/library {Force file to be a dynamic library. (Command version)}
;	/markup  {Convert HTML and XML to a block of tags and strings.}
	/all     {Load all values. Does not evaluate REBOL header.}
	/unbound {Do not bind the block.}
	/local data tmp
][
	; Note: Avoid use of ALL func, because of /all option
	if any-block? :source [return :source]

	data: case [
		string? source [to-binary source]
		binary? source [source]
		; Check for special media load cases: (temporary code)
		find [%.jpg %.jpeg %.jpe] suffix? source [
			return load-jpeg read/binary source
		]

  url? source [read source] ; can this possibly return not binary! 
  ?
		file? source [read source] ; binary! or block of file!
	]

 ; At this point, data is binary!, a block of file!, or something 
 weird.

	if binary? :data [
		unless find [0 8] tmp: utf? data [
			cause-error 'script 'no-decode ajoin ['UTF tmp]
		]

		; Only load script data:
		if any [header not all] [ ; Note: refinement /all
			if tmp: script? data [data: tmp]
		]
	]

	unless block? :data [data: to block! :data] ; reduce overhead

 ; data is a block! here, unless something really weird is going on
	tmp: none
	
	; Is there a REBOL script header:
	if any [header not all] [ ; /header preempts /all
		tmp: unless any [

   ;not any [file? source url? source] ; removed: hdr in string is same
			unset? first data ; because <> doesn't work with unset!
			'rebol <> first data
			not block? second data
		][ ; Process header:
			attempt [construct/with second data system/standard/script]
		]
		; tmp is header object or none here
		case [
			tmp [
				remove data
				either header [change data tmp][remove data]
				tmp: tmp/type = 'module ; tmp true if module
			]
			header [cause-error 'syntax 'no-header data]
		]
	]
	; tmp is true if module, false or none if not

 ; data is a block!, with possible header object in first position

	; Bind to current global context if not a module:
	unless any [
		unbound
		tmp ; not a module
	][
		bind/new data system/contexts/current
	]

 ; data is a block! here, unless something really weird is going on

	; If appropriate and possible, return singular data value:
	unless any [ ; avoid use of ALL
		all
		header ; This fixes a design flaw in R2's LOAD
		;not block? :data ; can this ever happen?
		empty? data ; R2 compatibility
		not tail? next data
	][data: first data]
	; If /all or /header, data is a block here

	:data
]

hell, I even have a "I LOVE BUSH" day every year... I'm 1/365 republican 
!

argh..... my screen exploided...

and I'm not even American!

;-)

brian, is there another function that is specified for loading human 
data ?

Adding foreign! doesn't really change LOAD does it?  It changes the 
native  make  phase  no?

We don't want foreign! by default though (or ever, but that is another 
matter), and you can't provide options to TO. We would have to support 
foreign!, or better yet fallback, incrementally with TRANSCODE.

Quick 'n' dirty 'load-junk (cvts: for R2; junk! is string!; blocks 
mess things up): http://www.ross-gill.com/r/load-junk.r

See, that is what we need! A separate function.

Ignores comments!

Agreed Mr. B.

comments == commas...

Look how complex LOAD is already. That is why it is now mezzanine: 
The complexity is better handled by REBOL code.

It's still fast though :)

Chris, 404s for me

hum... Brian, switch is not faster than case in load ?

Hmm, that'd be http://www.ross-gill.com/r/junk.r

Nope, case is one of the fastest functions in REBOL, even R2.

We profile everything :)

i know for R2, but in R3 switch is native, no  ?

Ok, I'd gladly accept a separate function, but ship it with REBOL 
for grandma and the professors of the world.  Don't make them hunt 
it down and DO it as a special case.    But to be honest, I'd still 
prefer a foreign! datatype! and advertise REBOL as a human readable 
language.  Much power in that ad imho.

but we also need an unknown!  ,   junk!  ,   or  WTF!   datatype 
   ;-)    

note the intentional use of commas  ;-)

Switch is native in R2 as well.