World: r3wp

This needs 'foreach-file from rebol.org

>> include %foreach-file.r
>> out: copy [] ff: func [file][repend out [file modified? file]]
>> foreach-file %./ :ff

== [%./!/basics_wide_desktop_computer_system.xml.ttx 21-Jun-2006/16:05+1:00 
%./!/basi
cs_wide_hard_disk_drive.xml.ttx 21-Jun-2006/8:...
>> sort/skip/compare out 2 2

== [%./ft/wavs/balloon.wav 23-Aug-2001/13:00+1:00 %./ft/wavs/down.wav 
23-Aug-2001/13:
00+1:00 %./ft/wavs/error.wav 23-Aug-2001/13:00...

thanks

Hmmm, has anyone looked at my FILE-LIST script on REBOL.org? If so, 
would it make sense to add an option to sort the results, or an option 
to have extra data returned (e.g. attrs or date-time) along with 
the file names themselves?

; version 1
my-face: make face [
    my-data: none
]
make-my-face: func [ extra-data ] [
    make my-face [ 
        my-data: extra-data 
    ]
]
; end of version 1

; version 2
my-face: make face [
    my-data: none
    new: func [ extra-data ] [
        make my-face [ 
            my-data: extra-data 
        ] 
    ]
]
; end of version 2


Quesion: I have a lot of my-face objects ( 1,000,000+ ) in an appication. 
Which version is better? Will the version 2 take more memory since 
the "new" is a object method instead of a function?

1 million objects?  how much RAM is that taking?

It depends. Every my-face shows an Unicode character bitmap. They 
are put in a pool for saving memory. If a character is not needed, 
it won't be loaded. ... Showing a long article wich Chinese character 
in it is a nightmare. Short article is not a problem though.

why don't you simply use AGG to "stamp" each character in a bitmap? 
 using the draw command over and over (per character or per line)

this can limit your memory use a lot! especially if you do a pre 
analysis and count the recurrence of each character in the article 
(so you can keep only those that recur, saving some speed).

I guess some of this is what you already do...

version 2 definitely takes more memory.

With v2 that object method will be copied to every object. The factory 
function approach you use in v1 is better.

And with that number of objects, if you can use blocks instead of 
objects, it will reduce the weight even more.

but notice he is creating faces... can't replace that with block 
 !

it's possible to replace it with block, when you create draw dialect 
instead of pane of faces

Right, to clarify, if your my-face object has other overhead that 
could be externalized, do that, and use blocks that contain a reference 
to the lightest-weight face you can use.

Yes, even better rebolek.

It's exciting to see someone pushing REBOL this way though!

placing bitmaps with draw is possible even in non-AGG versions of 
View

do you think such a big draw block will hold?

hm, not sure, but you can have one face per line (or column - don't 
know which direction Jerrry uses :) filled with draw block

well, I guess it depends on exactly what he is outputting... but 
by what I understand, the display is less an issue than the actual 
loading of all the characters.

if he's just loading characters then keeping images in block is definitely 
better

you can have block like this: [unicode-number image! unicode-number 
image! ...] and then just use SELECT

yep.

Thank you for all your comments. I'll try them out.

How about a /native refinement to return files in 'request-file to 
return files in the native file format?

Why not just write a TO-LOCAL-FILES function to do that for all files 
in a block ?

because it means I could do this

show-text field form any [ request-file/only/native copy "" ]

and not get "none" in the field

umm.. let me rephrase that!

>> form to-local-file any [%hello %""]
== "hello"
>> form to-local-file any [#[none] %""]
== ""

form any [ to-local-file request-file/only/native copy "" ]

form any [ to-local-file request-file/only copy "" ]

which errors if request-file returns none

This doesn't:
form to-local-file any [request-file/only %""]

ahh.. :)

Too easy, eh ?

yeah .. but I think it would be good to still have the switch as 
it reduces the work.

mmm... I'm not convinced.

it's a switch to control what is being returned by a function

I'd like an inverse of the 'case function.  It goes through conditions 
and evaluates the associated block if the condition is *false*.  
The following does what I need:

inverse-case: func [conditions [block!] /local test][
    while [not tail? conditions][
        set [test conditions] do/next conditions
        either test [
            conditions: next conditions
        ][
            return do first conditions
        ]
    ]
    return test
]


Any pitfalls with this approach?  Also, any naming suggestions?  
I was thinking 'assert or 'assert-all.

Example:

assert [
    exists? %rebol.exe [make error! "rebol.exe does not exist"]
    0 < size? %rebol.exe [make error! "rebol.exe is empty"]
]

0 < (size? %rebol.exe)

I don't even have a feeling for assert

so, this is just case, with not in front of each condition?

so, why not just call it .. not-case ?

I guess it's to do with usage: though it functions like 'case, it 
is more like 'all with a step-by-step fallback.

Mmm.. yes, I've needed that kind of expression sometimes.