World: r3wp

Super -- Thanks for the info.  I'm still learning about parse!

You have to remember to structure your rules using LL style. Do you 
notice that I checked for one word first, then looped over the subsequent 
words? That was to avoid putting the "-" after the last word as well. 
Parse uses right recursion - not like yacc, which uses left recursion.

I was just wondering about the trailing dash, but thought that could 
be handled in a different step.  Your method is cleaner.

replace/all form [a b c d e f] " " "-"

Cleaner yet.

Can anyone help me why the following appears to work, but still returns 
false?

data: [ table [1 2 3] [4 5 6] ]

parse data ['table some into [ some [ set n integer! (print n) ] 
(print "-")] ]

do you need an 'end ?

just found out that this seems to work, but I don't really see why 
I have to include end. As I've understood "into" is supposed to fail 
and continue if the next item isn't a block!


parse data ['table some into [ end | some [ set n integer! (print 
n) ] (print "-") ]  ]

Ahh, another block around the into statement did the trick :P Thanks 
for the help though


parse data ['table some [ into [ some [ set n integer! (print n) 
] (print "-") ] ]  ]

shouldn't datatype! be included in rule block parsing?

how do you do this:

blk: ["somestring" string!]

We can't do:

parse blk [string! datatype!]

and get a match.

I see I can do a reduce on the blk when passed to parse and get it 
true but not sure that is safe for my situation.

be nice if there was a lit-type!

string! is considered a word here. you must provide the datatype 
in its serialized state:

parse ["something" #[datatype string!]] [string! datatype!]

same if you use none or other things that would be considered words 
in an unreduced block.

I don't get what you mean by serialized state

>> parse ["something" #[datatype string!]] [string! datatype!]
** Syntax Error: Invalid construct -- #[

** Near: (line 1) parse ["something" #[datatype string!]] [string! 
datatype!]

>> blk: ["something" string!]
== ["something" string!]
>> type? second blk
== word!
>> type? second reduce blk
== datatype!
 ; this you know, right? OK...

I guess you mean datatype! with the "!"

yes Henrik

What I'm trying to avoid is any reducing

I dont' want any execution of code as I don't know what might be 
passed by the user

But I still need to validate the passed block

>> mold/all string!
== "#[datatype! string!]"
>> blk: ["something" #[datatype! string!]]
== ["something" string!]
>> type? second blk
== datatype! ; voila :-)

didn't know mold/all did that for string!

cool Henrik

I think that could work

your "lit-datatype" is actually serialization. it exists for everything 
that otherwise would lose its datatype inside a block

nice.

mold/all will display how to serialize something so you don't need 
to reduce a block to get the right datatype in there.

yeah I see which is exactly what I'm looking for.

>> type? first [none]
== word!
>> type? first [#[none]]
== none!

a great and valuable tool (also speeds some things up)

yeah I knew that one but didn't think about that for datatypes.

Yes greatly

It's gonna help me for what I'm doing.

I'm sure it will :-)

:)

Hmmm this still might be a problem though.  Because serialization 
is good if you know to put that into the block yourself but how to 
you take dynamic data that is user inputed and serialize the datatype 
that is in it?

if you insert the right datatype in the string with code, the datatype 
should be recognized automatically. the other syntax is for manual 
entry.

>> type? first head insert [] string!
== datatype!

what if they just enter a field and that field is translated as a 
block as [string!]

that depends entirely on how you build the block

Remember you don't know what is in the block as it might not be string!.

I'm gonna have to work on this a bit - still seems like a cumbersome 
way

But it helps to know that as it gives me more options

I think I have a way around that.

Thanks Henrik.

no problem

Keep in mind that you can parse for 'string! (the lit-word version 
of the word string!) and that will match without reducing.