Fun with functional dependencies Export

@misc{citeulike:587845, abstract = {This paper illustrates how Haskell's type class system can be used to express computations. Since computations on the type level are performed by the type checker, these computations are static (i.e., performed at compile-time), and, since the type system is decidable, they always terminate. Haskell thus provides a means to express static computations, and has a clear distinction between static and dynamic computations. Instance declarations define predicates over types, or in the case of multi-parameter classes, relations between types. With functional dependencies, multi-parameter classes directly specify functions, and, thanks to them, you can get the type checker to compute the values of function applications, rather than just checking that the result of an application is what you say it is. This way of expressing computation gives us the power of a small first-order functional programming language, with pattern matching and structural recursion. We can easily define things like booleans, natural numbers, lists, and functions over these types. We give some examples of completely static computations, the most elaborate one being an implementation of insertion sort. We also give examples where static and dynamic computations are mixed.}, author = {Hallgren, T.}, citeulike-article-id = {587845}, citeulike-linkout-0 = {http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.22.7806}, citeulike-linkout-1 = {http://www.cs.chalmers.se/~hallgren/Papers/wm01.html}, keywords = {functional-dependencies, functional-programming, haskell, logic-programming, type-classes, types}, posted-at = {2006-10-06 12:03:23}, priority = {2}, title = {Fun with functional dependencies}, url = {http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.22.7806}, year = {2001} }

TY - GEN ID - citeulike:587845 L3 - citeulike-article-id:587845 N2 - This paper illustrates how Haskell's type class system can be used to express computations. Since computations on the type level are performed by the type checker, these computations are static (i.e., performed at compile-time), and, since the type system is decidable, they always terminate. Haskell thus provides a means to express static computations, and has a clear distinction between static and dynamic computations. Instance declarations define predicates over types, or in the case of multi-parameter classes, relations between types. With functional dependencies, multi-parameter classes directly specify functions, and, thanks to them, you can get the type checker to compute the values of function applications, rather than just checking that the result of an application is what you say it is. This way of expressing computation gives us the power of a small first-order functional programming language, with pattern matching and structural recursion. We can easily define things like booleans, natural numbers, lists, and functions over these types. We give some examples of completely static computations, the most elaborate one being an implementation of insertion sort. We also give examples where static and dynamic computations are mixed. TI - Fun with functional dependencies KW - functional-dependencies KW - functional-programming KW - haskell KW - logic-programming KW - type-classes KW - types AU - Hallgren, T PY - 2001/// UR - http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.22.7806 ER -