World: r3wp

What makes a good dialect? That's a hard question to answer. What 
makes a good GPL (General Purpose Language)? There is no formula 
I know of, but I would say it should be:


* Focused. *Domain* specific is the key. If you don't know the domain, 
it will be hard to get it right.


* Well thought out and refined. Don't just take the first pass and 
call it good. Like a writer, think about the words you choose and 
how they're put together. 


* Small. Think about how the language will grow, but don't try to 
put too much in it.

Thank Gregg. It's very helpful. DSL stands for Domain-Specific Language, 
right? http://en.wikipedia.org/wiki/Domain-specific_language

yes

As mentioned, you can parse in two different ways in REBOL: string 
parsing and block parsing. Recently (after using REBOL for years!!! 
Yes, you always keep discovering new things in REBOL.), I start to 
think about the two different ways of parsing, before I make a dialect. 
It's rather crucial, which way you choose, creating a dialect. String 
parsing is good for dialects, where you allow the user to type almost 
anything ... where you give lots of freedom. Block parsing is good, 
when you want the rules to be more narrow ... when you want the user 
to think in terms of works and symbols.


Latest I made the math dialect for NicomDoc. I choose string parsing 
giving lots of freedom. The dialect ended up specifying presentation 
more than semantic. The dielect is good to produce the formulas, 
just like you want them visualized. If (when?) I would make a math 
dialect, where I would put weight on the semantic (the meaning of 
the mathematical symbols), I would choose block parsing.

*terms of works and symbols* = terms of words and symbols

.

The next requirement for 'Filtered Import' <http://www.rebol.org/cgi-bin/cgiwrap/rebol/documentation.r?script=filtered-import.r>
is support of depth:

import [
    name ["Chris" "RG"]
    address [
        street "19th Terrace"
        town "Birmingham"
        zip 35205
    ]
][
    name: block! [string! length is more-than 2 string!]
    address: block! [
        street: string!
        apt: opt string!
        town: string!

        zip: issue! [5 digit opt "-" 4 digit] else "Must have a valid US 
        zip code"
    ]
]

== [
    name ["Chris" "RG"]
    address [
        street "19th Terrace"
        apt none
        town "Birmingham"
        zip #35205
    ]
]

I'm not quite sure how to pan this out.  Also, the 'name rule doesn't 
have any set words, it is operating on an unnamed series.  I think 
I want this type of rule to match the content.  In that if [string! 
string!] does not exactly describe the content, 'name throws a bad-format 
error.

But this target is achievable, there are some clear patterns.  And 
means that 'Filtered Import' can process more complex Rebol data 
(though not objects), basically Json class data.

Nice Chris. If you can nest named and unnamed value blocks, what 
you say seems logical, that the parent block is given as the error 
location.


Why do you use literal bitset values, and have the human-friendly 
format of charsets just as a comment in the code?

You mean 'digit vs 'chars-n?  I've been using the latter for some 
time, mainly for consistency.  I'm going to migrate to more common 
names where there is a precedent.

I mean you have:
 comment {[
        chars-n:  charset [#"0" - #"9"]   ; numeric
        ....

But then the code actually uses:


    chars-n:  #[bitset! 64#{AAAAAAAA/wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=}] 

Why have the second one, the #[bitset!] syntax, at all?

I assumed the literal was faster to start...

Albeit, I'm not a master at measuring such things...

It will definitely be faster (about 8x here), but either one is so 
fast, that the difference is insignificant, unless you're doing it 
10,000 times, then you'll save .2 seconds or so.

Gregg wrote (in group Rebol vs Scheme):

I would *love* to see mini-primers on language design for Lisp, Forth, 
Logo, etc. in REBOL.

I've taken the first step for a BASIC dialect:

do http://www.fys.ku.dk/~niclasen/rebol/basic.r

It only knows a few commands so far: auto list new old
And these statements: end goto print rem run
And these functions: cos sin

Example of use:
BASIC

>auto
   10 print "Hello World!"
   20 0
>run
Hello World!
>list
   10 print "Hello World!"
>

Very cool John. Now, let me throw another thought into the mix, just 
for fun. 


If you were to write a language interpreter long ago, you would do 
it in a low level language like ASM or, later, C. In those languages 
you didn't have high level constructs like we have in REBOL. Certain 
languages have very specific models; consider Lisp and Forth, each 
has a few core definitions and the rest of the language it built 
on those. Lisp has lists, Forth has blocks, etc. 

With REBOL, we can do things in many ways. 


1) Leverage all REBOL has to offer. For example, how hard would it 
be to write a simple Lisp system if you (basically) use blocks for 
lists and supply a few standard Lisp functions? Is eval'ing a Lisp 
paren/list different than DOing a REBOL block?


2) Write lower level code, simulating how you would have to write 
a language using something like C or ASM. You could go as far as 
writing a simple virtual machine with its own set of ops.


3) Write dialects that are designed for building specific kinds of 
languages, showing the core concepts of languages, where they're 
similar, and where they differ; tools for teaching language design. 

I think all of those approaches have something to offer.

I think that making a Basic interpreter in Rebol is more useful, 
powerful, and educational than almost any other endeavour I have 
heard regarding Rebol (ever!).


-	People like the idea of Basic.  
-	Almost all programmers know some Basic
-	Although "basic" it tells programmers this is simple to do.
-	It is a great way to learn a dialect.

-	It has "news worthiness" would be good to write a compete dialect, 
and post on SlashDot.

-	If you can run QBasic - it would me instantly thousands if not 
millions of applications that could run instantly on any platform. 
Probably all would be faster even with graphics.

What may happen, is people (kids for example) would begin hacking 
old Basic applications rewritten in Rebol, to show off.

100 lines of Basic becoming 7 lines of Rebol for example.


There is a group of people hacking Nintendo emulators with a program 
that emulates the joystick, and attempt to play games in the shortest 
time possible.  It is very interesting, but why these types of things 
take off is that people can have fun, and without too much knowledge, 
show off their talents.

This Basic dialect parse in block mode, and this set some restrictions 
on the syntax, but it's probably faster and easier to program the 
parse rules. To make a QBasic would require, I used string parsing. 
Probably the same for most other languages. Unfortunately I don't 
have much time for this project atm., because I have 3 examins in 
the coming week, and after that I'm on vacation for 2 weeks. But 
I would like ot do more of this. Maybe we could make a real project 
with some goals!?

I added a few new things to the BASIC:

added DELETE command, added arguments to LIST, added STOP statement 
and some more (see source). Example of use:

>> do http://www.fys.ku.dk/~niclasen/rebol/basic.r
connecting to: www.fys.ku.dk
Script: "BASIC" (24-Jun-2007)
BASIC

>auto 5 5
    5 print "Line 5"
   10 rem goto 20
   15 blab
   20 print "Line 20"
   25 stop
   30 0
>run
Line 5

Mistake at line 15
>10 goto 20
>run
Line 5
Line 20

STOP at line 25
>

Yes, I was not suggesting YOU do this, but rather than it be a goal 
of the Rebol community...

I use this guide as a base for the BASIC interpreter: http://www.nvg.ntnu.no/bbc/doc/BBCUserGuide-1.00.pdf
I found it on this site: http://www.nvg.ntnu.no/bbc/docs.php3

I choosed that one, because I once owned a BBC Micro. I have no idea, 
how far that is from QBasic. But I guess Basic is Basic. They probably 
differ in stuff like graphics and sound.

To Gress's post:

1) Yes, it's interesting to find out, how much we get for free using 
e.g. blocks in REBOL to simulate lists in other languages. Maybe 
using hash! will benefit in some situations!?

2) Using rebcode is also a way to write lower level code. But it 
should also be possible to define REBOL functions, that work like 
(or simulate) the lower level commands in other languages. 

3) Yes, it would be interesting to find out, how languages differ 
in their cores.

LOL (I can't spell your name, sorry!)
*To Gregg's post*

Read before you post! Read before you post! Read before you post!

(Does that help? ;-) Well, we sometimes get a laugh, when people 
don't do that.)

Could this group we [web-public]?

It's an interesting discussion of techiqyes that deserve a wider 
appreciation.

Web public. Yes
Gress = Gregg. NP :-)


QBASIC - Ahhh, now we get to have some fun. QBASIC is not your old 
fashioned, line-numbered BASIC. I think it would be cool to do both, 
but the Q(Quick)BASIC language is much better for writing programs 
that actually do something. I've been tempted to do something like 
that myself. To actually run exisiting QB code, screen access would 
pretty much be a must-have feature. Nothing like those old character 
mode interfaces you know.

Gregg, yes, you se my point....Sunanda, agreed.

If you want basic, why not take one and use r3-dll? :)

I also haven't got any problem with this group going web-public. 
I guess, it's just to change it.

Web public. Yes

A z-machine interpreter could be fun - plenty of infocom games to 
play. ... http://en.wikipedia.org/wiki/Z-machine

Thanks......I've changed the designation to [web-public]:

http://www.rebol.org/cgi-bin/cgiwrap/rebol/aga-display-posts.r?post=r3wp248x150

http://maschenwerk.de/foerthchen/


This guy has written a forth in javascript ... guess it's doable 
in Rebol

The start of a BBC BASIC interpreter using string parsing: http://www.fys.ku.dk/~niclasen/rebol/bbcbasic.r

How do we best get this rolling? I'm interested in making some language 
interpreters in REBOL, because I see future potential. Reichart and 
Gregg talked about QBASIC, which I don't know. Where are the specifications 
for that language? BASIC is a start, and along the line, I would 
like to dig into other languages as well. Is it best keeping it all 
public, or should we make new groups for teams interested in this?

Very nice...  As for the other questions...can't say...but well done 
sir.  And a nice reading code space to boot.

Nice John! I'm not sure how best to get rolling. I'm totally buried 
at the moment, but I can provide web space for the project if we 
need that. I also a number of grammars and things here, if we need 
references.

Oddly, I don't seem to have a QBASIC grammar. :-\

I started on a VB grammar once, which is similar, and I still have 
most of my manuals here somewhere. :-)

Not sure if the various sites for lex/yacc tools and such might have 
one/

Gregg, first I'm making a simple 'engine' or 'template' for BASIC. 
Today I implemented expressions, some simple string handling and 
a little more. I'll make conditions (IF) and loops (FOR), then that 
should be a good start to build on.

Uploaded new version of BBC BASIC intepreter. Added expressions and 
conditions. Added IF and INPUT. Example:

>> do http://www.fys.ku.dk/~niclasen/rebol/bbcbasic.r
connecting to: www.fys.ku.dk
Script: "BBC BASIC" (18-Jul-2007)
BASIC v. 0.0.2 

>auto
   10 input "Name",name$

   20 if name$="Carl" then print "Hi " name$ else print "Hello " name$
   30 0
>run
Name?John
Hello John

So far this is implemented:

Keywords: AUTO, DELETE, LIST, NEW, OLD, GOTO, RUN, END, IF, INPUT, 
LET, PRINT, REM, STOP
Functions: COS, SIN
Expressions can beside unary +, - use: +, -, *, /, ^, (, )
Conditions can use: or, eor, and, =, <>, <=, >=, <, >

It's possible to add strings together and strings can also be tested 
in conditions.

3 datatypes is implemented. Examples:
a$ is a string
a% is an integer
a is a real.