内容大纲 / Abstract

• no more need for your functions to carry around "binding environments", or "variable lookup functions", or "binding contexts" (unless you want to), and no more need to engineer explicit renaming maps, or to correctly maintain separation invariants and thread them through your code;
• pointers to substructures can be just pointers to substructures, and you can deference when you want to and practice information-hiding when you don't -- all efficiently, and without worrying (too much) about how it's implemented;
• common code patterns can be, and are, factored out as useful typeclasses;
• it's easier to notice and express algebraic code rewrites, including as properties for property-based tests;
• tests and test-generators themselves are less dependent underlying representation and so can be easier to read, write, and maintain.

• the language -- can it do what we need it to do? if so, is the resulting code readable? does it add value overall? -- and of
• the maths -- adapting mathematics to an executable environment can and does throw up ideas, due to an ambient notion of state and execution flow. In the case of Haskell, this shows up as new monads and some cool new typeclasses.