World: r3wp

neither in belgium

at least u can party all nite

we have a little more advanced culture, they are so young those americans

in montreal they are pretty advanced ... :)

moved to Chat;  we're kinda polluting the All group.

Carl asked how many messages here, and guessed 100,000
I see just on 181,000.

Your numbers will vary -- it depends on the private groups you are 
a member of.

Plus we each member-to-member messages. They are not counted in my 
181,000

Ok, Brian, now on your above function, try to parse this: "12.3.2.2.2.2[.3.4 
5 6 7] 8 9"

Gabriele; don't use that loadall, it's broken - badly broken.  Chris 
Ross-Gill posted a link to a much better load-junk, but his version 
does weird things with "$10,000,000.00" and still doesn't handle 
the recursion required by a real REBOL load.  In defense of us both, 
they were quick jobs posted only as examples.   I'm still unclear 
why the addition of foreign! data would break REBOL.  I'm of the 
opinion it would increase REBOL usabilty, by an order of magnitude 
for people not programmers by nature, and open up entirely new fields 
of endeavour, not make it impossible for professionals to write awesome, 
concise code as they do today.   But ... as you can see from that 
hack job of loadall, I'll defer to gurus.

I'll defer to gurus

 - that's my point, gurus are telling you that this is a very bad 
 idea...

so, either you know something we don't, and then you're the only 
one that can implement this, or we know something you don't :)

Gabriele - and if the latter is true, then Gurus should explain to 
normal mortals, why it is not easily possible and what consequences 
would proposed solution bring :-)

But - BrianH already explained that ...

again, the reason is that it is impossible to come up with a general 
solution, and that this is a UI issue and NOT a language issue. unless 
you throw in AI, "language" for a computer cannot be the same as 
"language" for a human.

so, either we have AI, and the computer can figure out what a human 
means when reading the text the human wrote (but it'll have to ask 
questions most of the times! like when a human is talking to another 
human), or it can only be a specilized thing (eg. a date field that 
tries to be "smart" - but that's just a big set of rules)

I think that your answer is too abstract :-) All that guys wanted 
was - any known rebol datatype should be recognised, and the rest 
should be assigned under junk! or similiarly named datatype. What 
is AI about that? :-)

load-all: func [
	s [string!]
	/with limit [string!]
] [
	s: either with [
		parse/all  s limit
	] [
		parse s none
	]
	forall s [
		s/1: any [
			attempt [load s/1]
		] [
			s/1
		]
	]
	s
]


But you have to decide, what you wish as a delimiter or as part of 
item.

there was a bug
load-all: func [
	s [string!]
	/with limit [string!]
] [
	s: either with [
		parse/all  s limit
	] [
		parse s none
	]
	forall s [
		s/1: any [
			attempt [load s/1]
			s/1
		]
	]
	s
]

Gabriele; no sorry; I guess I obfuscated my point too much with the 
money! example.  I don't want REBOL to figure out all the possible 
human combinations of money.  I want REBOL to load a value that we 
humans commonly use as a format of money, without a syntax error. 
  The make phase would create a foreign data value and keep going. 
  Let the gurus that write general applications worry about the math 
operations on junk and account for it.  But let a professor load 
his book and use the uber powerful series operations of REBOL for 
ad hoc analysis.   No AI involved here, just a feature of the language 
that "if a piece of source does not match one of the lexically strict 
57 datatypes, it floats in a REBOL block as foreign".    And foreign 
is similar but not quite exactly the same as quoting the text as 
string!, without need of quoting the text.   I see great power in 
this feature.


Excuse the poor example;   I misdirected my intention when I mentioned 
that arg1 had a good hint, my mistake (but I would if I had brains, 
include this hint as a subfield of foreign! data, just because, why 
not, the current lexical parser already made a guess).  Our good 
Mr Hawley has a plan for a LOAD refinement /else with a type spec 
that looks very promising, but then it leads to being able to distinguish 
actual quoted input from coerced input, so I still lean toward foreign.


My plan (and I place burden of foreign! management for CODE blocks 
to the gurus) would let normal people load any data and run with 
it.  Even it they only use 4 or 5 REBOL functions at the console, 
the potential userbase becomes orders of magnitude greater than what 
we have today.   That it turn opens up a few that will write concise 
clear time lasting code that could analyze books or the sum of human 
knowledge using our favourite thinking environment.  No?

for me the key point lies not in the fact that we can already make 
mezz func which simulates the foreign! handling with a function such 
as ASSIMILATE.


the difference lies in the fact that if the native function can load 
invalid data, then it should simply because of the the fantastical 
speed its able to convert string data into rebol literal values of 
a variety of types.


hooking up interpreter driven code within the handling of that will 
slow it down.  using the parse with next refinement works... but 
its nowhere near as fast, for loading, say 300MB of scientific data. 
 which is an actual case I had to deal with.  just doing a replace/all 
on that file took 30Minutes.  assimilate with foreign! handling  
would have taken about 5-10 seconds, and the code would have also 
been easier to write over all.

Brian and Pekr, you can easily define where your foreign! value (garbage) 
would start, but you cannot define in a *general* way where it should 
end. You can only define that on specific cases and with specific 
rules. That's Gabriele's point. 


For example, let's see how an invalid input could be parsed using 
a theoretical foreign! type (represented below as quoted string for 
easier reading).

Test input string to parse: "123 abc 4c5.6"

Possible alternative outputs from a relaxed LOAD:

[123 abc "4c5.6"]
[123 abc 4 "c5.6"]
[123 abc 4 c5.6]
[123 abc 4 c 5.6]
[123 abc "4c" 5.6]
...

Question: which one is the correct output that LOAD should produce?

Answer: you can't know until you ask me what I wanted to express.


You cannot expect from LOAD to know how to handle invalid data (and 
to determine where it ends), the best thing LOAD can do is to stop 
on syntax error. If you have hints or rules on how should foreign 
be parsed, then write some parse rules and use string! parsing.


LOAD/else is a nice REP, but again it can only work on specific data. 
You cannot feed it with *any* data and expect it to work.

usuall rebol separators is the ovbious reply... spaces.  we all agree 
that we don't expect the system to behave magically.

for my part I just know how many times, this would have simplified 
parsing of mechanically generated data.

oh my... it could be simple, just load as junk! until you found a 
valid separator (blank, newline or tab) then continue to load.
What's the problem ????

Those who are saying endless that it's better to throw an error have 
never been in that case...

And if it can not be included in core as a new datatype! (constructed 
by to block!) then it's useless. I don't want it as a mezzanine because 
it would be slow.

at least junked tokens could be formated as a string! it would be 
more usefull than thorwing an error and stoping

to block! could return a false status if there are junks but we don't 
want useless errors anymore...

Doc, the point to LOAD/else is that it requires a parameter that 
is the answer to the question of what the calling code wants to happen 
at that point. This solves your concern, and is the major difference 
relative to all of the foreign! proposals.,

I don't know whether /else is the right name for that option, but 
at least it's short.

Load/foreign ?

More like load/on-error.

It would require you to provide a handler, or perhaps a word that 
denotes a stock handling strategy.

Like load/on-error "10,000,000.00" 'string.

Or 'skip.

by defaut it  should be a string conversion with a charset or a string 
with delimiters

By default, it will be an error. The default will be when the /on-error 
option is not used.

Otherwise you will be *required* to specify a strategy for dealing 
with the data, perhaps as a function or code block if you like.

you know what i mean, i'm talking about a default conversion when 
the option is selected

There will be no default - the parameter will be required.

It's either specify the option or don't.

like for parse.
default use: parse data none
with specific separators: parse date "..."

You are passing a parameter there - it's not the same thing. If we 
allow a none parameter (which we shouldn't), it should mean 'skip.

However, there should be a 'local parameter for localized numbers 
and dates.

we don't need to skeep, the only skiped chararcters are the separators

*skip

Yeah, you should definitely skip separators. Use load/on-error data 
'skip if you are expecting separators, as REBOL doesn't have them.

Except for whitespace, of course.

see the sqlab code, it's exactly how it should behave

his load-all, we don't need more fonctionnalities

No, that won't work. It will break on nested structures.

The whole point oif LOAD is handling the whole data syntax of REBOL.