1,420 Hits in 1.2 sec

ICurry [article]

Sergio Antoy, Michael Hanus, Andy Jost, Steven Libby
2019 arXiv   pre-print
FlatCurry is a well-established intermediate representation of Curry programs used in compilers that translate Curry code into Prolog and Haskell code. Some FlatCurry constructs have no direct translation into imperative code. These constructs must be each handled differently when translating Curry code into C, C++ and Python code. We introduce a new representation of Curry programs, called ICurry, and derive a translation from all FlatCurry constructs into ICurry. We present the syntax of
more » ... y and the translation from FlatCurry to ICurry. We present a model of functional logic computations as graph rewriting, show how this model can be implemented in a low-level imperative language, and describe the translation from ICurry to this model.
arXiv:1908.11101v1 fatcat:nuehgz5f3ndt3ck5tb6muyar4u

802.11 Wireless And Wireless Security

Cathy Hanus, Michael Hanus
2011 Review of Business Information Systems (RBIS)  
The purpose of this paper is to educate the wireless user or prospective wireless user regarding 802.11 wireless and wireless security. This is achieved by a review of the literature. Our review of the literature includes an overview of the most popular wireless standard, 802.11, some of the benefits of wireless networks, some of the vulnerabilities in wireless networks and some basic security recommendations specific to wireless networks. In addition, the paper gives an overview of some future
more » ... wireless protocols that are currently being worked on by the various standard developing bodies.
doi:10.19030/rbis.v8i1.4502 fatcat:vk7zftjbknhpbbstl3fz74u2ze

Synthesizing Set Functions [article]

Sergio Antoy, Michael Hanus, Finn Teegen
2018 arXiv   pre-print
Set functions are a feature of functional logic programming to encapsulate all results of a non-deterministic computation in a single data structure. Given a function f of a functional logic program written in Curry, we describe a technique to synthesize the definition of the set function of f. The definition produced by our technique is based on standard Curry constructs. Our approach is interesting for three reasons. It allows reasoning about set functions, it offers an implementation of set
more » ... unctions which can be added to any Curry system, and it has the potential of changing our thinking about the implementation of non-determinism, a notoriously difficult problem.
arXiv:1808.07401v1 fatcat:rrfgguk6ozh6fbs6kvwldtezga

Adding Data to Curry [article]

Michael Hanus, Finn Teegen
2019 arXiv   pre-print
Functional logic languages can solve equations over user-defined data and functions. Thus, the definition of an appropriate meaning of equality has a long history in these languages, ranging from reflexive equality in early equational logic languages to strict equality in contemporary functional logic languages like Curry. With the introduction of type classes, where the equality operation "==" is overloaded and user-defined, the meaning became more complex. Moreover, logic variables appearing
more » ... n equations require a different typing than pattern variables, since the latter might be instantiated with functional values or non-terminating operations. In this paper, we present a solution to these problems by introducing a new type class "Data" which is associated with specific algebraic data types, logic variables, and strict equality. We discuss the ideas of this class and its implications on various concepts of Curry, like unification, functional patterns, and program optimization.
arXiv:1908.10607v1 fatcat:vubjepbn2ba37owpqffzzqzgbi

From Logic to Functional Logic Programs [article]

Michael Hanus
2022 arXiv   pre-print
More details are in the textbook of Lloyd (1987) and in surveys on functional logic programming (Antoy and Hanus 2010; Hanus 2013) .  ...  2009) or default rules (Antoy and Hanus 2017) .  ... 
arXiv:2205.06841v1 fatcat:du6oucg3zrfptfxrlxhkky55ue

A Generic Analysis Environment for Curry Programs [article]

Michael Hanus
2007 arXiv   pre-print
We present CurryBrowser, a generic analysis environment for the declarative multi-paradigm language Curry. CurryBrowser supports browsing through the program code of an application written in Curry, i.e., the main module and all directly or indirectly imported modules. Each module can be shown in different formats (e.g., source code, interface, intermediate code) and, inside each module, various properties of functions defined in this module can be analyzed. In order to support the integration
more » ... f various program analyses, CurryBrowser has a generic interface to connect local and global analyses implemented in Curry. CurryBrowser is completely implemented in Curry using libraries for GUI programming and meta-programming.
arXiv:cs/0701147v1 fatcat:cdfmj5wyvbgutcse64rz7bfd5u

Equivalence Checking of Non-deterministic Operations [article]

Sergio Antoy, Michael Hanus
2019 arXiv   pre-print
Checking the semantic equivalence of operations is an important task in software development. For instance, regression testing is a routine task performed when software systems are developed and improved, and software package managers require the equivalence of operations in different versions of a package within the same major number version. A solid foundation is required to support a good automation of this process. It has been shown that the notion of equivalence is not obvious when
more » ... rministic features are present. In this paper, we discuss a general notion of equivalence in functional logic programs and develop a practical method to check it. Our method is integrated in a property-based testing tool which is used in a software package manager to check the semantic versioning of software packages.
arXiv:1909.09562v1 fatcat:53w7hqijtrhtfixyvypuygauru

CurryCheck: Checking Properties of Curry Programs [article]

Michael Hanus
2016 arXiv   pre-print
We present CurryCheck, a tool to automate the testing of programs written in the functional logic programming language Curry. CurryCheck executes unit tests as well as property tests which are parameterized over one or more arguments. In the latter case, CurryCheck tests these properties by systematically enumerating test cases so that, for smaller finite domains, CurryCheck can actually prove properties. Unit tests and properties can be defined in a Curry module without being exported. Thus,
more » ... ey are also useful to document the intended semantics of the source code. Furthermore, CurryCheck also supports the automated checking of specifications and contracts occurring in source programs. Hence, CurryCheck is a useful tool that contributes to the property- and specification-based development of reliable and well tested declarative programs.
arXiv:1608.05617v1 fatcat:qhhamg5qrzemxlnp47zqyqewmm

Compiling ER Specifications into Declarative Programs [article]

Bernd Braßel, Michael Hanus, Marion Muller
2007 arXiv   pre-print
This paper proposes an environment to support high-level database programming in a declarative programming language. In order to ensure safe database updates, all access and update operations related to the database are generated from high-level descriptions in the entity- relationship (ER) model. We propose a representation of ER diagrams in the declarative language Curry so that they can be constructed by various tools and then translated into this representation. Furthermore, we have
more » ... ted a compiler from this representation into a Curry program that provides access and update operations based on a high-level API for database programming.
arXiv:0711.0348v1 fatcat:ci5jzljdprfedpsstivbbw6ao4

Memoized Pull-Tabbing for Functional Logic Programming [article]

Michael Hanus, Finn Teegen
2020 arXiv   pre-print
Pull-tabbing is an evaluation technique for functional logic programs which computes all non-deterministic results in a single graph structure. Pull-tab steps are local graph transformations to move non-deterministic choices towards the root of an expression. Pull-tabbing is independent of a search strategy so that different strategies (depth-first, breadth-first, parallel) can be used to extract the results of a computation. It has been used to compile functional logic languages into
more » ... or purely functional target languages. Pull-tab steps might duplicate choices in case of shared subexpressions. This could result in a dramatic increase of execution time compared to a backtracking implementation. In this paper we propose a refinement which avoids this efficiency problem while keeping all the good properties of pull-tabbing. We evaluate a first implementation of this improved technique in the Julia programming language.
arXiv:2008.11999v1 fatcat:i7c6gnt22jblveiamsljjgkwwe

Combining Static and Dynamic Contract Checking for Curry [article]

Michael Hanus
2017 arXiv   pre-print
Antoy and Hanus [6] describe a tool which transforms programs containing contracts and specifications into programs where these contracts and specifications are dynamically checked.  ... 
arXiv:1709.04816v1 fatcat:gubkjo2vszawnc4efd2xji6mw4

Lazy unification with simplification [chapter]

Michael Hanus
1994 Lecture Notes in Computer Science  
Recently, Antoy, Echahed and Hanus [1] have proposed a narrowing strategy for programs where the functions are defined by case distinctions over the data structures.  ... 
doi:10.1007/3-540-57880-3_18 fatcat:dqkwgzzpo5e57ntrs3rgyxapei

Functional logic programming

Sergio Antoy, Michael Hanus
2010 Communications of the ACM  
doi:10.1145/1721654.1721675 fatcat:3jer6iphojcmxmkjh7sv4kdaeu

Default Rules for Curry [chapter]

Sergio Antoy, Michael Hanus
2016 Lecture Notes in Computer Science  
In functional logic programs, rules are applicable independently of textual order, i.e., any rule can potentially be used to evaluate an expression. This is similar to logic languages and opposite to functional languages, e.g., Haskell enforces a strict sequential interpretation of rules. However, in some situations it is convenient to express alternatives by means of compact default rules. Although default rules are often used in functional programs, the non-deterministic nature of functional
more » ... ogic programs does not allow to directly transfer this concept from functional to functional logic languages in a meaningful way. In this paper we propose a new concept of default rules for Curry that supports a programming style similar to functional programming while preserving the core properties of functional logic programming, i.e., completeness, non-determinism, and logic-oriented uses of functions. We discuss the basic concept and sketch an initial implementation of it which exploits advanced features of functional logic languages.
doi:10.1007/978-3-319-28228-2_5 fatcat:hpiewwmztrbz5crekzqd65x7qe

Implementing Equational Constraints in a Functional Language [article]

Bernd Braßel, Michael Hanus, Björn Peemöller, Fabian Reck
2011 arXiv   pre-print
KiCS2 is a new system to compile functional logic programs of the source language Curry into purely functional Haskell programs. The implementation is based on the idea to represent the search space as a data structure and logic variables as operations that generate their values. This has the advantage that one can apply various, and in particular, complete search strategies to compute solutions. However, the generation of all values for logic variables might be inefficient for applications
more » ... exploit constraints on partially known values. To overcome this drawback, we propose new techniques to implement equational constraints in this framework. In particular, we show how unification modulo function evaluation and functional patterns can be added without sacrificing the efficiency of the kernel implementation.
arXiv:1108.5609v1 fatcat:j5nee5yj5vfgdlt4llrdn76od4
« Previous Showing results 1 — 15 out of 1,420 results