Functional logic programming languages, such as Curry, integrate features of functional and logic paradigms, in particular, demand-driven deterministic evaluation from functional programming with non-deterministic search from logic programming. Though useful for programming, this combination can lead to unintended results and subtle bugs. To support programming with this powerful computation model, this paper proposes a method to detect unintended non-determinism at compile time. For this purpose, we propose determinism types to approximate the determinism behavior of functions and expressions. In contrast to standard types in strongly typed languages, determinism types do not restrict the set of admissible programs but support the programmer and programming tools in reasoning about functional logic programs, e.g., to enforce determinism in top-level I/O operations. We present the motivation behind this approach, discuss core concepts of functional logic programming and Curry, and outline methods to check for determinism through type-based analysis.

We present an approach for automatic function inversion in Haskell. The inverse functions we generate are based on an extension of Haskell's computational model with non-determinism and free variables. We implement this functional logic extension of Haskell via a monadic lifting of functions and type declarations. Using inverse functions, we additionally show how Haskell's pattern matching can be augmented with support for functional patterns, which enable arbitrarily deep pattern matching in data structures. Finally, we provide a plugin for the Glasgow Haskell Compiler to seamlessly integrate inverses and functional patterns into the language, covering almost all of the Haskell2010 language standard.