AltME groups: search

END means end-of-input, not end-of-rule. If you really want to break 
out, try putting the parse call in a LOOP 1 and then BREAK in a paren, 
or in a function and RETURN or EXIT.

Just try the idiom

a: [b | skip a]

and you will see, that it always means the same as

a: [thru b]

to doesn't match the end... it moves to it..  its different than 
simply putting  end in a rule.  thru is supposed to move PAST the 
result of a to.

>> parse/all "12345" [[to "5"] a: (probe a)]
5
== false
>> parse/all "12345" [[thru "5"] a: (probe a)]

== true

>> parse/all "12345" [[to end] a: (probe a)]

== true


so if I try to move past the end, its logical that it raises a failure, 
since it cannot advance one more character.

Exactly like the idiom a: [b | skip a], which you did not even try

did you try it with complex rules?

I try to keep it simple.

yes, I always thought that commas should be removed of decimals, 
and simply ignored when loaded.


in mechanical data, commas are never used for decimals.  because 
apps need to load it back and all software accept that dots are for 
decimals and commas for separating lists.   why should REBOL try 
to be different, its just alienating itself from all the data it 
could gobble up effortlessly.

It's worth timing. I'll try both, in R2 and R3.

The biggest problem would be the different datatypes for different 
versions of SQL Server, if there is no good documentation for the 
native format. But BCP does the job quite well. I CALL it when necessary 
and try to FIND if any error output. 

There is XML format files as well, easier to understand but no functional 
differencies betwenn non-XML format files.

Endo, I will try to find newest version and let you know. But do 
not expect it to translate every regular expession.

Yes, yes  ..  so to try to get to the bottom of this - what shoud 
the true byte count of that VIEW exe be, please ?  thanks

Andreas, the changes doc wasn't updated yet. Most of the native changes 
that didn't have checkmarks next to them weren't done. This was a 
minimal release, so some stuff got put off to 2.7.9. Give me a moment 
and I will try to list the changes in that list that were in this 
release.

Not for me ... I try the Control-C, and also Control-X and right 
click, copy .... but can't paste into Rebol.

Slide 5: yes, I guess they are looking for a savior. I was on the 
boat too until yesterday (among the sick ones), when I jumped into 
the water to try to reach an island nearby. ;-)

the last time there was a language fork .. RT made some announcements 
to try and make rebol more attractive

Doc will try to be there to report on Red progress

Then something is wrong with the basic setup. When starting boron-gl 
alone, you should get a normal Boron console where you can try some 
functions

If you try to CALL/OUTPUT this script from 2.7.8, it will just freeze 
your REBOL session.

try using `prin rejoin [... crlf crlf]`

APPLY. Try this: apply :test [flag]

rename capabilities in file handling do not normally allow paths 
to be used (in the OS itself).  otherwise these are a called 'move 
file operations. 


e.g. if you try using paths with rename in the DOS shell, you get 
errors.

none uses Knuths definition

 - you should try to comprehend. None of the functions you mentioned 
 uses the Knuths definition.

In case you again try to misunderstand, then it is "none of the Rebol 
functions you mention"

This is about the HTTP scheme, but I can't find a group for R2 schemes.


Does anyone have a patch for the HTTP scheme that handles 204 (No 
Content) responses where no headers are returned? The standard scheme 
throws an error as there are no headers to parse. Here is the 'success 
case handler:

        success: [
            headers: make string! 500

            while [(line: pick port/sub-port 1) <> ""] [append headers join line 
            "^/"]

            port/locals/headers: headers: Parse-Header HTTP-Header headers
            port/size: 0

            if querying [if headers/Content-Length [port/size: load headers/Content-Length]]

            if error? try [port/date: parse-header-date headers/Last-Modified] 
            [port/date: none]

            port/status: 'file
    ]


For anyone familiar with the scheme, would the proper behavior be 
to set all related 'port fields to zero or none? e.g.

            port/locals/headers: headers: none
            port/size: 0
            port/date: none
            port/status: none

Did you try send/only ?

I'll try, but the alternative terms aren't precise enough for me 
to remember.

But the meaning is documented, so try to read the doc (it was Carl 
who documented it, not me)

Fair enough, I'll try. Those terms only work when you immediately 
follow them with code examples that display the precise meaning. 
Not a bad habit to stick to anyway :)

Ladislav's terms are better, in the sense of being more descriptive, 
but I'm unlikely to remember them because I've been using the old 
designations for 10+ years. I'll try, but don't give me a hard time 
if I don't get it at first.

Try:
>> new: make object! third <object>

Oldes, try it with a skip of 3 or 4 to see why a block is returned. 
Not very handy in the 2 case though... but I guess there was a desire 
to avoid special cases.

Neither, sorry :-)
index? never gives the absolute position.
just try index? head b/1

try mold/all after and you will see the (hidden) parts

I try to think of situations, where I would need to do that. I also 
don't think, I do it often. But it's an interesting idea. I try to 
come up with some situations, where I need to copy a value, that 
can sometimes be a series, sometimes not. Hmm...

There is a lot of type checking in REBOL. I feel too much sometimes. 
Calling many functions involve two types of type checking, as I see 
it. Take ADD. Values can be: number pair char money date time tuple
If I try call ADD with some other type, I get an error:

>> add "a" 1

** Script Error: add expected value1 argument of type: number pair 
char money date time tuple

I can e.g. add pairs:

>> add 1x1 1x2    
== 2x3

and issues:

>> add 1.1.1 1.2.3
== 2.3.4

But I can't add a pair and an issue:

>> add 1x1 1.2.3
** Script Error: Expected one of: pair! - not: tuple!


So that's kinda two different type checking. First what the function 
takes as arguments, then what actually makes sense. If the user also 
need to make type checking, three checks are then involved. It could 
be, the first kind isn't done explicit for natives, and that it's 
kinda built in with the second kind. But for non-native functions, 
the first type checking is done:

>> f: func [v [integer!]] [v]
>> f "a"
** Script Error: f expected v argument of type: integer

If you still try to pretend that there is no difference between the 
SAFE-OBJECT [...] expression and the MAKE OBJECT! [...] expression, 
then you are just presenting your stubbornness, rather than the will 
to find out how the things work.

Now, before you suggest a fourth type of equal test, maybe you should 
reconsider your statement, that this is a simple part of the language?

 - Ah, so now you are saying that the problem is that REBOL's MOLD 
 function does not *show* the binding of words?


This has nothing to do with simplicity, rather, it has to do with 
being intuitive. make object! changing the binding of words inside 
your B block is not intuitive, i agree. Intuition is not very useful 
when programming; still, there are many programming languages that 
try to be intuitive. I think REBOL is the *least* intuitive, especially 
if you have learned something about programming already.

Ladislav, if you try follow my thoughts, you can figure that out 
yourself.


Steeve, maybe that law is a design flaw, that causes many problems? 
Like the example returning "bug", which started much of this conversation.


Gabriele, ... Gabriele, you strengten my tolerance, and thank you 
for that. "that kills dialecting" I've seen you writing that before, 
and it puzzles me every time. (Well, probably different understanding 
again.) Thank you for suggesting Scheme, but I don't have time to 
dig into a new language right now.

Should we let it rest?

Ladislav, if you try follow my thoughts, you can figure that out 
yourself.
 I cannot, but nevermind

MAKE object! makes a copy of the block

 I gave a proof it does not make a copy. Interesting, how much you 
 try to reinvent the wheel, taking into account, that the correct 
 explanation to your results is available from public sources.

So we're back to, it isn't a bug, that MAKE doesn't copy the block, 
when making objects. It's intended behaviour. And MAKE does copy 
the block, when making functions, and that is intended behaviour 
too. And the SECOND function doesn't try to create a block, when 
used on functions:

>> f: does []
>> same? second :f second :f
== true

while THIRD does do that, when used on objects.

 And the SECOND function doesn't try to create a block, when used 
 on functions:
 - again, not exactly, in R3 this has changed

Thanks for the update, including the great docs Ladislav. I will 
try to give it more thought, and incorporate the new version in my 
work. In the meantime, here are some quick comments.


Have a naming convention for scripts that define include directives. 
e.g. %localize.r could be %#localize.r or %incl-directive-localize.r. 
Short is good, but special characters may affect portability.


If a directive doesn't require per-script or environment specific 
changes, like #comment, make it standard. And the way you designed 
#localize is very nice, in that it gives you control. Do you have 
helper functions for updating 'translate-list? I might call it translation-list, 
since 'translate sounds like an action.

Summary of the advantages of the first approach:

+ the file information is present in the error itself

Disadvantages:


- the error is "too complicated" for the interpreter to display the 
important informations

- the error has to be "intercepted" by TRY for the INCLUDE to be 
able to "enhance" it.

- also, since the INCLUDE works recursively, the TRY is used many 
times, and the code needs to take care, that the "enhancement" occurs 
only once

yes, will try it. I used a different code, so this one should work, 
I think

Try it in R3:
>> dt [i: 0 loop 1000 [i: i + 1]]
== 0:00:00.000251
>> dt [i: 0 loop 1000 [++ i]]
== 0:00:00.000383


Then the difference is more due to the code in ++ to tell whether 
i is an integer or a series

Hm, try do more loops on your system, Brian.

If you try to support both then you lose the ability of NEXT to trigger 
an error if it is passed a word by accident, a valuable debugging 
aid.

R2's COLLECT is pretty similar. The backports try to be as compatible 
with R3 as is practical in R2, though is a couple cases they are 
a bit ahead of their R3 versions, where there are some tickets that 
haven't gone through yet. In particular ENLINE/with, DELINE block!, 
and MAP-EACH/into come to mind.

One more note: there is a FLATTEN function definition somewhere, 
which was defined some time ago to be used to flatten hierarchical 
blocks. It should be possible to find it here, but, since it was 
long time ago, I will try to find my version and put it to rebol.org 
or somewhere to make it more available.

It is a potential security hole, but not more of one than assigning 
a function to an object field. It requires the same ASSERT/type call 
to screen for it. Still, it would be nice if it triggered an error 
on evaluation, especially since newbies would benefit from that error 
when they naively try to do a get-path for a function call instead 
of using APPLY or a direct call.

In R3, you can try do a >to binary!< on the results from the calculation 
and see the difference.

I have uploaded my latest EXIF-parser version at github - https://github.com/Oldes/rs/blob/master/projects/exif-parser/latest/exif-parser.r

To sort files you can use for example:

dir: %/e/DCIM/100CANON/
t: now/time/precise
result: copy []
foreach file read dir [
	error? try [
		ctx-exif/parse-file dir/:file
		exifdate: ctx-exif/get-tag-value 306
		repend result [exifdate dir/:file]
	]
]

sort/skip result 2

print ["sorted" (length? result) / 2 "files in" now/time/precise 
- t]
result

;>>sorted 120 files in 0:00:00.153

I can try to fix the 32bit version if you want.. but later

Andreas is supposed to give it a try this week.

Although I'm running into a bit of a wall when I try to import functions 
under cdecl. I'm getting undefined symbols (path values into the 
emitter symbol table) all over the place

When I compile the tests on Linux and try to run them on Syllable, 
I get this in the kernel log:

Well, I'll try it when the need for such optimized code will come 
(not in the short-term). I'll probably need a subset only.

Btw, I usually try not to read GPL code for features that I might 
have to implement in my pubic projects (not only Red). I've also 
stayed away from the host-kit source code for the same reason, knowing 
that I might have to work on similar features someday.

I usually try to refrain from being a spelling nazi, but I did have 
a snicker at "pubic projects (not only Red)" :-)

Good to know, I'll spend the next weekend in Spain, so I'll try to 
keep that in mind if I have to present my work. :-)

I've played with ALIAS to try to workaround that, but it wasn't a 
good idea.

(Didn't try, though.)

Thanks guys for the insights and propositions. I found it a bit difficult 
to follow in realtime, I'm not sure that AltME is the best tool for 
such conversations. Maybe we should give a try to the Red web forum 
next time: http://groups.google.com/group/red-lang?

Dockimbel it has a related topic ... Don't do like rebol did ... 
Claming to do things you don't.... and the object! type and whole 
OO justification made by Carl to justify his choice of a half assed 
OO concept  is null ... And that's what I want to share with people 
in red ... you shouldn't even try to be parasiting rebol (create 
your motion around rebol lack of motion using communication tools 
that are seen by 10 guys that are fanatics of rebol and won't support 
red...). Set you own discussion tools create a communication branch 
aside and invite people here to join you without counting on them. 
And more importantly try to convince non reboler to join and help 
you. face it there is way more people outside rebol community than 
inside.

you should look better, try the commits history.

That's why (after tax season) I'm going to try my hand at a Dalvik 
emitter :)

Could you try changing the base address in ELF.r? It is a the top 
of the file:
context [
	defs: [
		image [
			base-address	134512640	; #{08048000}
		]

Kaj: "I tested the new section headers on Syllable Desktop.

memmap_instance() RO overlap RW (08048000 + 00001000 -> 08048000)"


besides the entry point address being a problem, this could also 
be due to segment alignment, which we basically ignore, at the moment. 
could you try changing "page-size: 4096" to "page-size: 1" and see 
where that gets us?

Ok, will try with a similar pattern of code.

I'll try that

though in rebol not having type for vars and () for function arg 
submition, make difficult to identify var content  distinguish var 
from function ... Maybe then  a syntaxique item like th e $ in php 
for vars or the @ in ruby for tables would be an interesting point... 
Sorry I try to think about rebol syntaxe structure like someone seing 
it for the first time

nice machine... i would love to try

hm, kaj, could you try setting
base-address:  -2147483648
and see if that generates binaries which work?

Andreas, I'll give it a try

Let me try Desktop first on VMware

I'll try this again

Kaj: 
I tested the new section headers on Syllable Desktop.

memmap_instance() RO overlap RW (08048000 + 00001000 -> 08048000)"


besides the entry point address being a problem, this could also 
be due to segment alignment, which we basically ignore, at the moment. 
could you try changing "page-size: 4096" to "page-size: 1" and see 
where that gets us?"

give me a few minutes, i'll try to generate a binary that has that 
fixed

a red-generated dynamically linked binary, if someone wants to try 
on syllable :)

I will try to chip in once you get to more app / lib level :)

The interfaces between REBOL and AGG are rather REBOL specific. I'm 
not sure it's worth it to try to use them in Red

Thanks, I'll try it

Have you tried the input functions of your C library binding ? I 
tried input-line (under windows) some time ago, and it did not work. 
At that time, i did not try to allocate the c-string

input-next may have the same problem, but did you try it?

Try with an alias (untested).

Let me try...

Also, people installing View on Linux to try Red might encounter 
issues related to View installation.

But that happens with operating systems once you try them...

I don't think so. The called function will try to get its missing 
arguments from stack anyway.

I won't like loosing the comfort of AltME, but I'll try

Nice try :-)

The last reports were that GDb doesn't work anymore, but I'll try

I try to make sure that Red/System code can work the same on all 
platfoms (at least for 32/64-bit ones).

Great, I'll try it

I suppose they shift when the program uses different aliases. That's 
no problem for monolithic programs, but it would be when you try 
to define an interface to a library or other subsystem

jocko: try to compile it with the -g command line option, you should 
get the error location in sources.

I thought I'd try the GTK+ examples. Is there somewhere I can get 
C-library.reds?

nve: i don't have a home page yet, except for the try-topaz.html 
thing. so github is the place for now.

But what about concentrate all the effort on one product ?


We all have different goals. My main goal is to be able to try out 
experiments (like, what would it be like to add feature X to the 
language?); there's no way I can do this with R3. Also, I don't want 
to program in C (so, again, R3 and Boron are out).


My secondary goal is to simplify creation of web and mobile applications. 
R3, RED and Boron do not run inside the browser; RED may be able 
to target mobile platforms eventually, so we may be able to collaborate 
here.