[REBOL] Re: Model hacking
From: robbo1mark:aol at: 21-Jun-2001 12:25
Iam happy to "collaberate" with you on discussing these items at as "high level" / natural
language or as "low level" / some bits or compiled language as you & others wish.
You all know what my preferred end use for knowledge gleaned from these discussions is
so I'll make it explicity clear right here right now, I *want* to glean as much knowledge
and as much understanding of the structure and composition of REBOL and REBOL values
which I can hopefully use for my own ends which is formulating sufficient information
and understanding to some day implement my own *bastardized* REBOL at some unspecified
However, whatever our motives we can all benefit in our understanding in sharing knowledge
& model "hacking" as Joel calls it, so hopefully others will participate too.
Hopefully you will Count me in! if my motives don't exclude me?
In a message dated Thu, 21 Jun 2001 10:36:20 AM Eastern Daylight Time, Joel Neely <[joel--neely--fedex--com]>
<< I (personally) think that the recent discussions on mutability
and SAME? vs. EQUAL? may have narrowed our scope and bogged
us down a bit too much (and I hereby claim my share of the
blame for that! ;-)
I think we'd agree that understanding the rich set of available
data types is one of the keys to using REBOL more effectively
and accurately. One of the issues I've been pondering lately
is the kinds of characteristics that allow us to group,
distinguish, and describe this embarrasment of riches.
I thought I'd make it an "open source" pondering and toss out
some ideas for expansion, refinement , pruning, and improvement
by the community. I've made up some terms here, and am very
open to suggestions for better jargon. Some of these
1) LITERAL -- Some types (e.g., decimal!, time!, block!) have
the property that you can explicitly represent
a value of that type in REBOL source code. For other types
(e.g., list!, object!, or function!) you can only write
expressions (e.g., make or copy) that cause such a value to
be constructed with the expression is evaluated.
2) REFERENCE vs. SCALAR -- Values of some types (series!, for
example) are "referred to" in a
way that lets them be shared among words, blocks, etc. Other
type (such as integer!) are not shared.
3) ELEMENTARY vs. COMPOSITE -- Values of some types have
"sub-"components that REBOL
explicitly lets us talk about (e.g., time! values with their
/hour, /minute, and /second fields). Other types (e.g. char!
and logic!) do not.
4) ACTIVE vs. PASSIVE -- Values of some types actually "take
some action" when evaluated, while
others are "just there". This is tied to the distinction
of course. "Active" types include function! and tuple!, while
types include issue! and money!.
5) SYSTEM vs. USER -- Some types are predefined by REBOL and
the user cannot create values of that
type (e.g., op!) while other types can be created at will
by the user's expressions (object! and function!)
6) CLOSED vs. OPEN -- Some types (logic! and datatype!) have
a set-in-concrete set of possible
values, while others are open-ended and new values may be
created at will (function! and block!)
7) MUTABLE vs. IMMUTABLE -- ... I don't think I'll say any more
about this one right now! ;-)
Are these useful distinctions? Are there others that would
be helpful? Can we actually identify how each type fits into
each of these?
Programming languages: compact, powerful, simple ...
Pick any two!