World: r3wp

yeah exactly.  The unRebol way is to just string parse and then take 
the first token as a command...seems unworthy.  But I am willing 
to put up with a mirage for that immersive looky feely.

Well, I've never gone Forth, and I'm not sure what a block editor 
is, but maybe you can benefit from some console commands. I almost 
always use Crimson Editor. I have an EDIT command which launches 
Crimson Editor, and I navigate the filesystem in the rebol console 
using dir-utils.r, which supplies unix-like filesystem commands; 
CD, LS, MV etc.
http://anton.wildit.net.au/rebol/os/windows/edit.r
http://anton.wildit.net.au/rebol/library/dir-utils.r

The Ctrl-E execute trick in Crimson is close but it is still a mental 
context switch.  Editor -> Rebol -> editor -> etc...  My old mantra 
was "Compile Link Go...Away, Go Go Go is much better"

How do you launch rebol otherwise ?

I've set up my start menu so it's a few key presses away. The sequence 
is: Ctrl-Esc (to open the menu), down right down enter. (Actually 
now I think about it, I can reduce this a little bit.)

I'm actually not using Ctrl-E in Crimson Editor. It's just not as 
simple as launching it yourself, and every editor does it differently.

I have Crimson and Rebol/View as Quick Launch buttons on the windows 
taskbar.  But still...that mental switch.

So the mental switch is between the editor and the rebol console, 
being separate applications.

this is not entirely related, I think (I'm only a bit above beginner's 
level, so I may not be understanding your problem right) but I wrote 
a tool some time ago called Tester. It allows you to write code and 
test it directly without leaving the environment. This is not an 
editor per se, but a rigid workflow tool to write and test code. 
You can read about it in the !Tester group.

Yep.  A small annoyance...Rebol is more than worth it.  I probably 
just give in to the current state of editor/language being two different 
planes of existence.

Thanks Henrik I'll take a look.

you can execute inside the editor

Graham; Yep.  Things are close.  I'll get over it someday.  But can 
you imagine the nirvana of a Rebol console/editor?

there is REBOL console editor in library.

http://www.rebol.org/cgi-bin/cgiwrap/rebol/view-script.r?script=rem-ext42.r&sid=mkjym6ig

Thanks Rebolek, I'll take a second look at this app.  I've let the 
discussion move a little too far from Dialecting, so thanks everybody. 
 Just needed to talk a little bit about it.

btfiffin: I'm not sure how it works with latest REBOL, I had some 
problems. If it does not work, contact me privately, I have patched 
version

Rebolek; Cool, thanks.

I am not sure where your focus is.
Editor-dialect: put the edited code in strings, like
[ #1 {io-code} #2 {gui}]

Patch the inbuild editor to load and store there, instead iof storing 
to files.

And from the console a simple "ed #2" would edit it. but still in 
a seperate window.

Console: Or is it about that seperate window, do you want inside 
that rebol-console-window? More work, but rem-edit does that, maybe 
its author would help with fixing.

Sorry for the confusion here.  A forth "block" editor, uses a 1K 
chunk of disk as 16 lines of 64 characters.  There are forth words 
for the editor e.g.  9 LIST ( list block 9)     3 T ( Highlight line 
3)  P newword: ( n - n) DUP . ;   ( place the text "newword: ..." 
to end of command line onto line 3.  What you get is an editor that 
uses the same language that you are programming in.  Immersive.

Sorry Technically Inaccurate Typo.  newword: DUP . ;  would not compile 
in forth.  : newword DUP . ;  is correct.  Long Live Rebol.

rebol [
    Title: "Immersive" 
    Usage: {
>> fed
fed> p 3 This is a demo line, its not loadable :)
p with 3 " This is a demo line, its not loadable :)"
fed> print "This is pure rebol"
This is pure rebol
fed> "this too"
== "this too"
fed>
}
] 
ctx-fed: context [
    arg-lens: [p 2] 
    line: cmd: none 
    last-err: none 

    p: func [lineno line] [print ["p with" lineno mold line] exit] 
    t: func [lineno] [print ["t with" lineno] exit] 
    e: func ["format err"] [throw last-err] 
    do-line: func [line /local arg-len-pos res] [
        set [val rest] load/next line 
        either arg-len-pos: find/skip arg-lens val 2 [
            cmd: reduce [val] 
            loop arg-len-pos/2 - 1 [
                set [val rest] load/next rest 
                append cmd val
            ] 
            append cmd rest
        ] [
            cmd: load/all line
        ] 
        bind cmd self 
        case [
            error? set/any 'res try [do cmd] [
                probe disarm last-err: res
            ] 
            value? 'res [print ["==" mold :res]]
        ]
    ] 
    rebol/words/fed: func [] [
        forever [
            do-line ask "fed> "
        ]
    ]
] 
fed

Clever as ususal Volker! I think that's the right idea as well; just 
use the console with the expected commands built in, including block 
I/O. LOADability is important for REBOL dialects, but that doesn't 
mean you can't write an interpreter that parses strings if that's 
what you want and need. Personally, I greatly prefer true dialects 
for the power they provide.


Ultimately, Brian, a dialect should be what you want it to be, and 
the more interactive things are, the better (IMO). I'd love to see 
more interactive dialects like this.

Hey, thanks for the interest Volker.  And Gregg thanks for the comments. 
 But I'm still kinda stuck on an editor dialect that could handle 
random text in a parse block.  Even the nifty fed above will break 
on   "p $10,000,000" as rebol can't quite form a money value out 
of $10,000,000.  So the basic question exists.  Is there a way to 
block parse random potentially unloadable text?

Sorry Volker, missed the lineno arg to the p command.  Nice.

Brian, I think you would have to write your own load-parser, that 
can, first of all, match brackets [] {} "", including escaping strings, 
"^"", load well-formed rebol values etc.. as well as be able to handle 
non-matching brackets and ill-formed rebol values.
This is a tough job.

The essence of the problem is that if the file is not fully loadable, 
then you can't be sure that *any* part of it that you might be looking 
at is a properly formed value. For example, if there is one extra 
unmatched } at the end of the file, does that imply that the whole 
lot was supposed to be a string ? Would that mean that all the prior 
text shouldn't be treated as individual values then ?

My preference is to use block parsing whenever possible, and trap 
errors so you can warn if something isn't valid. Block parsing is 
just so much more powerful than string parsing, it's hard to give 
it up.


Of course, there are improvements I would like to see, so more "normal" 
text can load successfully; things like 50%, or 33MPH. Maybe R3 and 
custom datatypes will offer something in the area of expanded lexical 
forms. In any case, we should identify the most important things 
that don't load today and see if RT can do something about them. 
:-)

funny, in experience, I find it easier in many cases to do a hybrid 
model.  one where you load the string into some block you can then 
more easily parse.  There are many kinds of real-world data which 
is not easily loadable in REBOL and in cases where you must make 
a dialect over some outside data... blocks are rarely useable.

Agreed. What I often do is "parse" the data, using standard string 
manipulation, not really thinking as a dialect, and then writing 
a dialect against the loaded data.

exactly.

the hybrid model is much easier to "Get things done"

So the pros don't seem to mind a string parse followed by a block 
parse?

What would be the implications of  LOAD converting unmatchable types 
to string! behind the scene?  Or perhaps a new unstring! type to 
keep other dialecting more concise?

that's how I handle XML for example, a modified version of xml2rebxml.r 
.  I convert the tags into native rebol blocks, then handle the blocks 
within the application which expects the data... this way, you can 
more easily re-use code.

I have recently discovered the Issue! datatype.

and use it for many in-between values.

its like a power word, which accepts anything but a space.

(almost anything)

Ahh, just add a #.  Nice.

using string as a temporary data holder is ok too, as long as you 
can be sure the dataset will not get mixed up in a temporary value 
or actual string data.  either by its structure or content.

funny... I had been using rebol for 9 years and didn't know about 
that datatype... yet its extremely usefull

you just have to be carefull not to mix up other # using REBOL notation 
like char! (#"^/" ) or the serialized data format  (#[none] )

I can't say I've been 'using' Rebol for long, but I've been playing 
for quite a while now.  I discover something new every time I open 
up the system.  It's too cool how RT has put something as wide and 
deep as the ocean into a cup, a cup with blinking lights no less.

hehe  even if the cup has a few crack  ;-)

I feel its the most productive language out there.  not in how powerfull 
it CAN get but in how productive it IS from the onset of the very 
first time you use it.

Yep, that's what turned me all evangelical.

Issues can actually contain spaces, but they don't parse or mold 
that way. i.e. the datatype can hold them, but the lexical form doesn't 
allow it. Meaning you can get bitten, but do tricky things. :-)

>> a: #This issue has spaces in it
** Script Error: issue has no value
** Near: issue has spaces in it
>> a: to issue! "This issue has spaces in it"
== #This
>> probe a
#This
== #This
>> b: to string! a
== "This issue has spaces in it"

well, that holds for words to btw  ;-)

to = too

just an alternative form:

>> form #[issue! "aaaaa aaa"]
== "aaaaa aaa"

Is the dialect conecpt original in REBOL? Or is it from another language? 
Does any other language have this concept too?