World: r3wp

; or b) step through the path and resolve each value in turn:

resolve: func [:path [path!] /local wd val][
    wd: first path: copy path remove path val: get wd
    while [all [block? val not tail? path]]
        wd: first path remove path
        val: val/:wd
        if word? val [val: get val]
    ]
    val
]

I am trying to compare what I can do in Rebol to what I can do in 
another language with functors

What hamstrings me is that a path cannot be extended unless the blocks 
are literally nested or in an object

I am hoping some one will da ythat in R3 path! is more like a series!
path: this/thing
path: append path 'what
rez: path

(sorry, missed an opening bracket in 'while)

path: 'this/thing
append path 'what
probe path
probe to-block path

sorry what is a bad choice
make that 'whatever

bind to two valid paths
compose with one word nested in a block
you can append all you want
type? is path
and the path will not be valid

my little pword func was the shortest thing I could build

path: join 'language/en 'one
probe resolve path
path: join 'language/en 'two
probe resolve path

The path is not valid, so long as you are trying to resolve it with 
'do.

why should that be so?

the path is just word1/word2 and then is just word1/word/word3

Only word1 ever binds to a value

word1/word2/word3 ; guy can't even type ...

The path! that my 'pword func returns responds as expected to 'do

Iin your example (again, if I understand correctly), 'do (or default 
behaviour) resolves each stage in the path.  So, with a given path 
-- t2/f/b -- it'll go t2/f == 't1-- but this is just a word, not 
the value associated with the word.

It's equivalent to this:
val: 't1
val/b

But is any valid deep path only the forst word has to have  a value 
associated with it.
  e.g. 
     block/tag1/tag2/tag3

Only if you're evaluating with 'do.

Even if I am doing
   result: constructedPath

That's sort of the same as evaluating with 'do.

What should the behavior of 'join and 'append' and 'insert be when 
passed a path and a word?

What I'm getting at is there are limitations in the default handling 
of paths.  But paths are series and you can evaluate them however 
you want to.

Yes, get first path is a godsend

Here is what Carl has said:

Of course, not to discourage anyone, but we're going to be careful 
and choosy about what becomes part of R3. We've got our standards. 
We still value small, fast, and smart. REBOL is about getting great 
advantage and leverage from a well-designed tool, not about becoming 
yet another bloated and hard-to-manage computer language.

join foo/bar 'ton -- will try and evaluate foo/bar then append 'ton
join 'foo/bar 'ton -- will give you 'foo/bar/ton

That is great but also of no help if a word is holding the path
   'foo/bar
I was hoping the solution was in
   to-lit-word

path: 'foo/bar
join path 'ton ; ??

fails with 
  ** Script Error: Cannot use path on word! value

Hmm, works here.

to-path reduce[path 'word]   ; works OK but what a klunk

Only if the blocks are literaly embedded.
Could you try with the example
  t1
  t2

join to-path 't2 't1

no, in the example that I posted above :-)

>> t1: [a "one" b "two" c "three"]

>> t2: [f t1]

'f has no value so it is just like a functor
I am not askeing to be able to just use
   t2/f/a
with no further ado
I must build the path
   newPath: to-path reduce [ t2/f  'a]

is a pain ( and only because of how to-path is implemented;  to-lit-path 
is no more help as far as I can see at this hour

I'm not sure why -- newPath: join 't2/f 'a -- doesn't work...

Hold on, -- join to-path t2/f 'a --??

That just caused Rebol 2.6.3 to blow away
I did not send teh missuve to Microsoft that I was proffered

the missive

It works on 2.6.2 (Mac) 2.7.5 (Win)

let me fire up Rebo/View again

but how will this help me where I have a WORD that is holding that 
initial, partial, path ?

join to-path do path 'a

path: 't2/f
do join to-path do path 'a

;same error
>> t1: [a "one"]
== [a "one"]
>> t2: [f t1]
== [f t1]
>> pp: join 't2/f 'a
== t2/f/a
>> do pp
** Script Error: Cannot use path on word! value
** Where: halt-view
** Near: t2/f/a
>>

2.6.3 just ditched me again with that one ...

This is the limitation of evaluating paths.  'do does not evalute 
't1 when it is returned from 't2/f

I think 2.6.3 does not want 'path used as a word ;-)

so do you think that   
   to-path reduce [ my-path  'my-next-refinement]
the best that I can do?

If your interpreter chokes on 'join, then I guess so...

I could try just Rebol/Core and see if that make a difference

It is not very often that Rebol blows out on me ... I can't remember 
when last before I started looking at my functor issues

That's 3 times tonight with only 2 teeny blocks and 2 paths  and 
no do against any file and nothing added to user.r