World: r3wp

warning: odd? and even? are already defined in Rebol, you might prefer 
to use names like pair? and impair? instead like you wrote above

Thanks for the answer.  I am aiming in the direction of corecursive 
types, to model a category thing.  So the following works.

Co-recursive types:
>> owed: func [x] [either paid? x [negate x][false]]

>> owed?: func [x] [either all [integer? x negative? x] [true] [false]]
>> paid: func [x] [either owed? x [negate x] [false]]

>> paid?: func [x] [either all [integer? x positive? x] [true] [false]]
>> a: 5
== 5
>> owed a
== -5
>> owed? a
== false
>> owed? b: owed 5
== true
>> a: paid b
== 5
>> paid? a
== true
>> paid? paid -5

Now I need custom types.

--Type inference from a newbee point of view:

What if I wanted to form true (but un-native) datatypes ?  To program 
them, I shall use the same method as other types in Rebol: 

To mention the type as its value : seasoning!: seasoning!, like the 
definition of the type money!: 'money.

Rather, I would like to do type inference as they do, for example 
in ML (I adapt the example from Felleisen's LittleMLer):

So I would need to define a new type and verify the type of a word 
with type?
seasoning!: ('salt or 'pepper)
Unfortunately this does not seems possible 
** Script Error: Cannot use or~ on word! value
** Near: 'salt or 'pepper
In Rebol:
>> source integer!
integer!: integer!
type? 1
== integer!
but
natural!: (0 or natural +1)
Type inference:
seasoning? salt
Would like the answer == seasoning
is-of-type? 'salt seasoning
Would like the answer == true

Am I forced to turn to Ocaml to do this?  I am stuck.  Thanks for 
any help!

I don't know exactly what you can accept and what not, but this will 
work:

seasonings: [salt pepper]


seasoning?: func [value [any-type!]] [found? find/only seasonings 
get/any 'value]
seasoning? 'salt

As far as I know it is not possible to define new types.


Not sure that would solve your problem anyway.  A word can point 
to a value that has only *one* type (ignoring the heirarchy -- eg 
block! is also series!). So complex assertions about something would 
not be easy.


Maybe rethink the need.....Use objects to hold both a value and a 
type:
>> item: make object! [value: 'salt type: 'seasoning]
>> item/type
== seasoning
>> 'seasoning = item/type
== true

You could encapsulate that in a couple of functions and expand the 
scope (maybe make type a block with multiple values)

Gabriele Santilli has made some custom types. I don't remember having 
fully understood how it works, so I can't tell you how he did it 
! But it can be found here:
http://www.colellachiara.com/soft/YourValues/libs/

custom-types.r is GPL.

(It's really very clever. :)

Just reading the code... Needs a demo.
custom-types.r  needs  standard-actions.r

I'll try to make one.

Hmm, there seems no easy way to make a demo. Gabriele is using an 
include mechanism (prebol.r I think) from the SDK . But it looks 
like
http://www.colellachiara.com/soft/YourValues/main.r
is the starting point.

Gabriele, if you're listening, the header of http://www.colellachiara.com/soft/YourValues/yourvalues.r
contains:
	File: %main.r   ; <-- should be %yourvalues.r   ??

Gosh, it's too hard for me to do in any reasonable time. I suggest 
looking at the code to figure out the method used, then see if you 
can make your own custom types.

Anton: the header is wrong because that file is generated with prebol 
using main.r

(a version of prebol with some minor modifications.)

about an example: there should be a complex.r in that dir that is 
a bit outdated (lacks support for molding and loading) but should 
be a good start. also template.txt is the starting point to create 
a new type.

you need to use starred actions on them though, i.e. add* instead 
of add, insert* instead of insert and so on, as well as make* and 
to*.

maybe somedaye i'll have the time to finish this stuff and add docs...

:) Now I think I remember I asked you that about the File: before 
sometime...

but, i'm not 100% sure Normand really needs this. custom types are 
not always the most elegant solution; actually, they are very rarely.

What are you up to these days anyway ?

also, i would really discourage a newbie from using that stuff as 
it is very experimental :-)

finishing the detective version 3, then (don't know if i can say 
that, so i won't.)

Why not ? :)

I wish I had some understanding of inference rules. Never studied 
Lisp stuff.

I think all those parens scared me away.

i don't think common lisp does any type inferencing.

That's how much I know. :)

and, i think an interpreted language would probably have a hard time 
at it, except for simple cases like the seasoning above.

which is elegantly solved as ladislav pointed out anyway.

the only advantage of having a real type in that case is type checking 
in fuction arguments; you don't get that with my custom-types (i 
don't think it is worth redefining FUNC etc. just for this), and 
it's not a big deal actually.

Are you actually using the custom types in any apps ?

i'm using something close (i.e. a very dumbed down and specialized 
version of it) in the backend for the portals for the Detective

basically the scripts interface to the mysql db via custom rebol 
values

I see.

I've just noticed a new global word PATH existing since View 1.2.10, 
an undocumented function.

--> rambo

About custom types: thats objects. they work like dynamic OO, no 
static typing and inferencing like ML

Thanks for all those suggestions.   I was out for quite a while and 
am very happy of all those remarks. It will help orient my trials&errs. 
 About  objects, dynamic versus static, If I understand it, in Rebol 
it is static?  I never had to use them except to encapsulate the 
whole of an app.  Is there a trick to mimick something dynamic to 
hold changing values?  Maybee a copied block is enough?  I wonder 
because I regularly try to add code to a bibliographic database, 
a kind of a variation on bibtex (never ended, allways in progress), 
And I am not too far from aiming the storage mechanism and wonder 
what I should use to hold something like from 5 to 10 thousand references 
(my actual need is 3.5K)  I used endnotes in the past, but dreamed 
about my own.  It is a lot of work (more than I expected as it is 
my first app).   Up to now I think I will use simply name-value pairs, 
like Carl's cardex.  This kind of data is more like a ragged array, 
the fields and their numbers allways vary, and I may amend their 
list with time.  The idea of using an object would be nice but need 
something where I may add or retract variable names and change their 
values.  By the way, I thank Volker for his edit-tools, that may 
help to add a writing pad.  And his double slider is refreshingly 
new for such and old paradigm as an editor.

The structure of an object is static (which fields in which order), 
but the values assigned to those fields are as dynamic as you want. 
Also, if you want to add or delete fields it is quite easy to create 
a new object with your changes at runtime. If you are just using 
an object as what other languages call a dictionary or hash map, 
you might as well use a block or hash type for your data.

Adding or deleting fields in objects can be tricky if you have multiple 
references to the object:
  obj: make object! [a: 1 b: 2]
  block: copy []
  append block obj
  obj/a: 9

  probe block     ; shows the object in the block is the same as obj
  obj: [a: 7]     ; attempt to update obj to remove b

  probe block     ; the object in the block still has a 'b -- it's 
  still the original

Otherwise, the technique is fine.

Or in other words, you can't add/remove fields in objects, but you 
can clone objects, and add/remove during cloning 

>> a: make object! [b: 1 c: 2]
>> b: make a [d: 3]
>> probe b

make object! [
    b: 1
    c: 2
    d: 3
]

>> c: make object! head remove/part find third b to set-word! 'c 
2
>> probe c

make object! [
    b: 1
    d: 3
]

Just as a little helper ...

>> third b
== [b: 1 c: 2 d: 3]

Thanks a lot.  It the kind of thing I normally learn the hard way, 
like the first time I was confronted to [ ] instead of copy [ ]. 
 Judging when it is better to use a block or object or structure, 
hash or else is not evident from a new eye.  The small Ladislav tutorial 
on blocks (series) is the kind of thing that helps a lot,, it help 
a newcommer realise how the language is articulated.

blocks are arrays. many items of the same kind. partners of loops. 
objects are records. items are addressed by names.

blocks are also good for records if you have only a few fields (2-3). 
like [key value]. then its sometimes easier to deal with offsets 
instead of names. block/1 -> key, block/2 -> value. less to declare.

blocks are also great for composing in, e.g creating a dynamic layout 
block to pass to the layout function or draw

Normand, probably blocks will be better for you than objects, because 
they are more flexible.

I am new in encription. What is alternative in Rebol for php MD5 
function?

checksum