Custom Evaluators and Foreign Syntax

[hostilefork]

@Brett

Operations like DO and REDUCE on a block is so nice. I'd like that niceness to extend to dialects, my intuition is that perhaps by raising a usermode evaluator to plug in to the system operations such as DO and REDUCE can apply to a dialect and produce useful outcomes and sane errors.

So this seems to tie into your other post about "Kinds" of Values

@Brett

For demonstration I thought Kind could be a word followed by a #, followed by the existing syntax. E.g:

vid#[button "push me"] ; A block of VID dialect.
vector#[1 2 3]
kind of markdown#{*This* could be interesting.} ; Would yield MARKDOWN

Kind would be optional so existing forms would be unaffected:

kind of {simple string} ; would return _
kind of [simple block] ; would return _

I've mentioned that we now have inert forms, and this is possible...and I think the idea seems sound.

>> @vid:[button "push me"]
== @vid:[button "push me"]

>> kind of @vid:[button "push me"]
== @vid  ; or just vid ?

The name "KIND" was taken for a while to be the underlying type of an item regardless of quoting:

>> type of first ['''10]
== &[quoted]

>> kind of first ['''10]
== &[integer]

But I am now calling that "HEART". So KIND is available for this purpose now!

DO Could Have a Registry To Dispatch These

(I don't think we want to dispatch by binding, because things like vector are too likely used by variable names.)

This is interesting in terms of the DO vs. EVAL distinction. DO would be able to handle this, but EVAL would expect a block of Rebol.

I like it. Also, the polymorphism of DO with things like different languages.

>> code: @javascript:-{function () { console.log "your JavaScript here" }}-

>> do code
; would be able to work in the Web Console

If you had your string in a variable, just JOIN it...

>> js-source: -{function () { console.log "your JavaScript here" }}-

>> do join @javascript: js-source

That's awesome. I look forward to wiping out CSS-DO and JS-DO, and letting DO be polymorphic!

Pushing the Potential of Polyglot Polymorphic DO

The brevity of DO is a strength that makes it seem natural to be polymorphic. I thought it was very wasteful that when Rebol2 and Red's DO saw something it didn't recognize, it would just drop out: rebol2>> do 1020 == 1020 rebol2>> do <useless> == <useless> Pinning people's expections to this behavior--to where they write code that relies on it--is awful. There are plenty of things we can imagine for this undiscovered space. (Soon it's planned that the ReplPad will use shorthands like do 3 …

Hopefully this will fulfill your wish!