World: r3wp

But Remove Tail Series is programatically different than Remove None 
as Tail returns an apparently empty series, not none.

Except in a more abstract sense that  remove tail x  and  remove 
none  both return what they were passed, unmodified :)

is this a bug or am I doing something wrong?

t: func [ip-val [word!]] [
    switch/default ip-val
    [
        'From [print "A"]
        'To [print "B"]
    ]
    [print "C1"]
]

t 'From ; should print "A"

Compared to 

t1: func [ip-val [string!]] [
    switch/default ip-val
    [
        "From" [print "A1"]
        "To" [print "B1"]
    ]
    [print "C1"]
]

t1 "From" ; should print "A1"

which correctly prints "A1"

The first example prints "C1" rather than "A"

t 'From => ?

>> t: func [ip-val [word!]] [
[        switch/default ip-val
[        [
[                'From [print "A"]
[                'To [print "B"]
[            ]
[        [print "C1"]
[    ]
>>
>> t 'From ; should print "A"
C1
>>

shouldnt that have printed A rather than C1

>> t: func [ip-val [word!]] [
[        switch/default ip-val
[        [
[                From [print "A"]
[                To [print "B"]
[            ]
[        [print "C1"]
[    ]
>> t 'from
A

OK ... so I dont need the "'" before the word ..... thanks

I remember being caught on that one once before.

I note that the parts of  dates, times, tuples etc are accessible 
using path notation.
Why not email! as well?

I would suggest that email/1 should be the part before the "@", and 
email/2 the bit after.
Then email/2/1 would access the first bit before the "." etc.

Graham: Are you asking for  email/1 & email/2 to map to the current 
email/user and email/host  refinements ?

oh no!

where was this documented??

under datatypes  http://www.rebol.com/docs/core23/rebolcore-16.html#section-2.3

:)

No doc ? We even don't read the one we have ;-)

Q: is there something to flatten a block of block ?
ie: 
>>> probe a
=== [[1 toto] [2 "this is text" 5.63] [#as12 none]]
>>> magic-code! a
=== [1 toto 2 "this is text" 5.63 #as12 none]

Yes this just came up again recently,

27 april  chat & parse

Thanks, didn't remember that

how is find/match supposed to work on blocks? I thought following 
will work? 

find/match ["Petr Krenzelok"] "Petr"

what I have in mind is very simple kind of select, not needing to 
enter whole search key ...

with blocks, I don't think that'll work with match, because it searches 
for the full element in a series, thus you need to search in two 
levels...

the block level and the string level

a find/deep would be very useful... recursive searching of blocks 
and objects. it could allow you to find a value in large objects 
and blocks quickly

find/deep is long requested feature, but it was said as not being 
as trivial, as blocks can contain self-references etc ...

and what is find/only about?

with find/match you can check for abbreviations

>> find/match "Hello World" "W"    
== none
>> find/match "Hello World" "H"
== "ello World"

>> find/match ["Pekr" "Krenzelok"] "Pekr"
== ["Krenzelok"]
>> find/match ["Pekr" "Krenzelok"] "Krenzelok"
== none

/only is for this:

>> find ["Pekr" "Krenzelok" "asking"] ["Pekr" "Krenzelok"]
== ["Pekr" "Krenzelok" "asking"]
>> find/only ["Pekr" "Krenzelok" "asking"] ["Pekr" "Krenzelok"]

>> find/only [["Pekr" "Krenzelok"] "asking"] ["Pekr" "Krenzelok"]
== [["Pekr" "Krenzelok"] "asking"]

I wrote some functions of this kind, but anyway, what is "the shortest" 
reverse of:

    y: to integer! x: #{80000000}

Maybe this ?
>> reverse third make struct! [i [int]] reduce [y]
== #{80000000}

; quick testing looks good

>> foreach v [-1 0 1 1000 7777 2000000][print same? v to-integer 
reverse third make struct! [i [int]] reduce [v]]
true
true
true
true
true
true

hmm, a "short" way could be:

>> to binary! reduce [y / 16777216 y / 65536 y / 256 y]
== #{80000000}

btw, is this on rambo? i really think that to binary! should work 
with integers.

I second that.

I don't remember seeing that in rambo.

Doesn't appear to be there. I searched "binary!" and "binary"

submitted

does anybody know why code below give me diffrent results? looks 
like get/set funcs operate on diffrent contexts:

ctx: context  [
  no-a: no-b: no-c: none
  set 'test does [
    foreach x [no-a no-b no-c] [set x "test-1"]
    foreach x [a b c] [set (to-word join "no-" x) "test-2"]

    foreach x [a b c] [print [join "no-" x get (to-word join "no-" x)]]
    foreach x [no-a no-b no-c] [print [x get x]]
  ]
]

test
probe no-a
probe ctx/no-a

to-word creates global words

oops

then how construct local words?