In this thesis we consider the problems of inefficient store use by functional programs. We present a sequence of denotational store semantics for strict, call-by-name and lazy higher-order functional languages of recursion equations and lists to model store use by programs in those languages. In particular we consider the problems associated with giving a strict semantics to globally defined lists and suggest a novel solution based on equivalence classes of values. We also consider the congruence of these store semantics with the stadard semantics of the languages.

 Then we present analyses and optimizations to reduce the use of store by programs in our simplest strict languages. Reducing store use will reduce the overhead of garbage collection and increase the execution speed of those programs. There are two particular optimizations we employ to reduce store use. Firstly {\it compile-time garbage collection}. We annotate programs to indicate that at certain points during execution certain parts of the store may be garbage collected. This optimization is validated by a {\it generation} analysis, which tell us which parts of the (list) value of an expression are guaranteed to be unshared when evaluation of the expression finishes, and an {\it inheritance} analysis which tells us which parts of the (list) values of subexpressions of a given expression are also part of the (list) value of that expression.

 The second optimization is {\it destructive allocation}. We annotate store allocators (such as {\tt cons}) to indicate that old store can be reallocated rather that new store. This optimization is validated by the generation analysis and a {\it destructive function} analysis which tells us whether a given function can reuse parts of store bound to a given argument of the function rather that use free store.

 Correctness of the analyses and optimizations is considered, using the store semantics as a reference. We identify a relatively little known problem with the correctness of store reuse optimizations - {\it interference} - and consider how it may be alleviated.

 We apply the analyses and optimizations to example programs and quantify the improvements in them. We find that many programs are significantly, sometimes extraordinarily, improved.