🚀 go-pugleaf

Herman Rubin:
>  I was of the opinion that strong typing meant that objects (bit patterns in
>  memory, registers, discs, etc.) of one type could not be used as objects of
>  another type.  As someone who has deliberately used this of course highly
>  non-portable feature often, it is this aspect to which I object.

It is entirely possible to define a function of the form
	pun(to_type, from_type, source_object)

All versions of this are portable, but defining such a function so
that it is efficient on one machine does not always mean that it is
efficient on another machine.  In the general case (arbitrary types,
arbitrary platform) you will need to copy the object when you change
its type.

Tomas Breuel:
>  Dynamically typed programs are also impossible to prove type-correct,
>  and many trivial errors go unchecked.

This is true when you are using a statically typed language (which
does not provide support of dynamically typed programs).  This is not
true in general, however.

On the hunch you've killed the subject thread where we've been
discussing this, I will repeat:

 You can implement static typing in a dynamically typed language by
 introducing "functions" which do no processing but which have limited
 domains.  These functions are equivalent to type declarations.

 In a well-written program, in a well-designed language, you should not
 _usually_ need such a function.  All primitive functions of the language
 should have such functionality built-in.

Raul Rockwell