[Date Index] [Thread Index] [Author Index]
Re: combination problem solved with Mathematica
Whether or not it is an advantage to use a language that is "not limited by datatype" is something about which reasonable people can disagree. It is certainly true that once in a while, the ML type system gets in one's way, as it did in this case. It would actually be quite nice to have a function that can behave in any of the following ways: unit -> unit 'a list -> 'a list 'a list * 'b list -> ('a * 'b) list 'a list * 'b list * 'c list -> ('a * 'b * 'c) list and so on. Unfortunately, that kind of polymorphism is simply not part of the ML type system. That's life. The reason that reasonable people can disagree about the importance of this is twofold: 1. As I showed in my example, I can come close to achieving what I want by using lists, in which case the type of the function is 'a list list -> 'a list list If I have a collection of diverse types, I can bundle them up into one with a `datatype' declaration and then pick them apart later. Thus although I can't get exactly what I wanted, I can come close enough for most practical purposes. 2. Strong typing has two considerable compensating advantages. First, typechecking often finds my mistakes for me before I actually run my program. Second, it often allows for much more efficient code generation in those cases where the compiler can use its knowledge of types to figure out much better machine code to generate for programs. Finally, I should note that comparing programming languages is a tricky business, especially when you include standard library functions. The trouble is that a good library can radically alter the character of a language, and is it often true that the language and library were designed by different (groups of) people entirely.