AltME groups: search

yep, I put there some 'demo extension' based on your template

I wouldn't call it a trick John, just a non-obvious syntax. I haven't 
used it much, but I wrote a func a long time ago when I needed it 
for something.

literalize-int-rules: func [template /local mark] [
; Turn a single integer value into a quantity-of-one integer
; rule for parse (e.g. 1 becomes 1 1 1, 4 becomes 1 1 4).
	rule: [
		any [
			into rule
			| mark: integer! (insert mark [1 1]) 2 skip 
			| skip
		]
	]
	parse template rule
	template
]

The m2_template may need adaption.

There's a patch for the generated M2 template in that Builder definition, 
but it's only needed for Syllable. It works with Linux, but isn't 
needed there

I'll wait for the answer of other people to continue. The I'll start 
experimenting and asking questions. I stopped working using REBOL 
object lot of time ago when I found really difficult to have an unique 
template to build many object with different fuctions.

as a testament to what is now possible with the new assimilation 
engine, just look at how insanely flexible it is at allowing you 
to provide just about any interface to a command...

using this information in the C header...

// command-template: [obj [object!]] prefix: obj- suffix: 3
// command-name: rxt-iadd
// command-template: [a [integer! decimal!] b [integer!]]
// command-template: [obj [object! x y]] prefix: xy-
// command-name: plus10
// command-template: [10 [litteral!] value [integer!]]

extern int r3t_integer_add(int a, int b)


;--------------------------------------

one ends up with this command interface... all calling the same C 
function.

    rxt-module: {REBOL [
        Title: {r3-test-extension extension}
        Name: r3-test-extension
        Type: extension
        Exports: []
    ]
    rxt-obj-r3t-integer-add3: command [ obj [object!]]
    rxt-rxt-iadd: command [ a [integer! decimal!] b integer!]
    rxt-xy-rxt-iadd: command [ obj [object!]]
    rxt-plus10: command [ value integer!]

    rxt-r3t-integer-mult: command [ a [integer! decimal!] b [integer! 
    decimal!]]

;----------------------------------------


note that in this setup, auto-exports is set to false and an rxt-prefix 
was added to every command name automatically.

btw, this command  


rxt-r3t-integer-mult: command [ a [integer! decimal!] b [integer! 
decimal!]]


was automatically generated by a function without any command-template, 
later in the header file.

Something looks reversed, like spec/headers is using the specific 
headers as a template rather than the reverse. Don't know why yet.

Graham: re. the headers discussion above, spec/headers is the user 
supplied headers. the ones in there are the default one (the template). 
in order for the user to be able to override the default, it is make 
template spec/headers and not make spec/headers template.

Graham: During your "journey" through this .. did you notice if there's 
a standard template that would make sense for various parts of the 
implementation?

I started with daytime, moved to smtp, and then ftp, fax and now 
imap.  I am using pretty much the same template with changes appropriate 
to the protocol.

template

Template is a good one, though it would need to be documented. Mask 
isn't quite right. Mold would be awkward because of MOLD.

Your "template" and "model" are the most accurate, if not specific. 
The word "ideal" would require too much explanation.

Someone should write a software book called 'The Joy of Naming'. 


We're used to 'facets, and I don't have anything against it, but 
it's telling that description for it uses both 'attributes and 'properties. 
I don't expect it will change at this point. We all just need to 
help new users learn what it means. 


'Template doesn't sound bad. It's funny, in OOP you have the concept 
of inheritance from a parent, but I don't know of a common term used 
for the view from the other direction. 'Attributes is probably the 
most common, but you don't hear it discussed as the base classing 
passing them on.

template panel?

This http://www.rebol.net/wiki/Template:GUI_TOC leads to this http://www.rebol.com/r3/docs/gui/gui.html
and this message


So, you found this page from the sitemap? Sneaky.

This GUI section 
is under construction (on a different server). It's not meant for 
publication yet. To be transferred here as they move into final draft 
stage.

Many of these links don't yet exist. They are being filled 
in at this time. Also, the image links are not yet setup.

So, no I didn't.

Proposal - Templates


Summary:  Templates would be code blocks that can be bound into other 
code and become part of the context in which they are called.

implements  a Template! type

template function 

template word block

The word argument is the template word that you define

The block argument is [some [word! block!]] where word is the different 
words you define for the template and the block is the code that 
gets reduced when the template word is encountered.

Operation:

mytemplate: make template! [count [print c] release [clear blk]]
mytemplate/release


Since I used /release which was defined in the spec all code where 
the word mytemplate is used will take on the action of the release 
which is to clear the blk word!

So in your example, mytemplate/release wouldn't be able to get the 
bindings of 'clear and 'blk from the calling context, since there 
isn't one. In order for the template to know what context to bind 
those words, a reference to that context would have to be passed 
as a parameter. The way that nested contexts are emulated in REBOL 
is through iterative overrides, not real nesting.


Making template! a datatype wouldn't help with this - it's part of 
the core semantics of REBOL. This is the same reason why the script 
or module Needs header can know what the target context to bind or 
resolve to is, but the IMPORT function can't.

Brian, the reference would be the template word that is defined. 
 The word would be bound to the context and assigned to the block 
when called.

Graham, the %n method supports switching template strings between 
languages with different sentence ordering.

Ladislav, the advantage would be that you don't have to allocate 
a substitution argument for that % escaping, especially if some of 
your template strings might need a %1 in them and others might not.

git init --template=... ?