Putting Types To Good Use

Writing correct software is still difficult due to its increasing complexity, which requires many abstraction layers. We believe that functional programming languages might alleviate some of those difficulties at the source of software construction. Pure and lazy languages, like Clean and Haskell, provide very good support for abstraction, composition, and equational reasoning. They also feature advanced type systems, which can be used to warn programmers about a certain class of mistakes early. This thesis investigates the usefulness of hybrid static/dynamic typing and polytypic programming by applying these techniques to some common software or programming problems. We show those two techniques 'in action' to assess applicability, performance, and expressiveness of the programming techniques themselves, as well as their implementations in both Clean and (Generic) Haskell. The hybrid static/dynamic typing is exciting in the way it extends the type safety of a strongly typed functional language into the run-time world. The polytypic programming approach to writing software is attractive in its promise to reduce the amount of code that needs to be written, to enable better maintenance by adding code instead of rewriting, and to elegantly describe abstract algorithms that work for any data structure. We conclude, from the research presented, that Clean's hybrid static/dynamic typing provides us with additional protection against run-time errors by tagging values with their static types. Furthermore, it provides us with a way to store and retrieve any functional expression, even between different programs. Polytypic programming also keeps us from making mistakes in (tediously) writing similar code for many data types. Because the automatic derivation/instantiating of polytypic functions is both type directed and type safe (it cannot introduce type errors), there is less room for programming errors