A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2020; you can also visit the original URL.
The file type is application/pdf.
Filters
ICurry
[article]
2019
arXiv
pre-print
Preserved Fulltext
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
arXiv:1908.11101v1
fatcat:nuehgz5f3ndt3ck5tb6muyar4u
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.
802.11 Wireless And Wireless Security
2011
Review of Business Information Systems (RBIS)
Preserved Fulltext
A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2018; you can also visit the original URL.
The file type is application/pdf.
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
doi:10.19030/rbis.v8i1.4502
fatcat:vk7zftjbknhpbbstl3fz74u2ze
more »
... wireless protocols that are currently being worked on by the various standard developing bodies.
Synthesizing Set Functions
[article]
2018
arXiv
pre-print
Preserved Fulltext
A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2020; you can also visit the original URL.
The file type is application/pdf.
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
arXiv:1808.07401v1
fatcat:rrfgguk6ozh6fbs6kvwldtezga
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.
Adding Data to Curry
[article]
2019
arXiv
pre-print
Preserved Fulltext
A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2020; you can also visit the original URL.
The file type is application/pdf.
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
arXiv:1908.10607v1
fatcat:vubjepbn2ba37owpqffzzqzgbi
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.
From Logic to Functional Logic Programs
[article]
2022
arXiv
pre-print
Preserved Fulltext
A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2022; you can also visit the original URL.
The file type is application/pdf.
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]
2007
arXiv
pre-print
Preserved Fulltext
The Internet Archive has a preservation copy of this work in our general collections.
The file type is application/pdf.
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
arXiv:cs/0701147v1
fatcat:cdfmj5wyvbgutcse64rz7bfd5u
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.
Equivalence Checking of Non-deterministic Operations
[article]
2019
arXiv
pre-print
Preserved Fulltext
A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2020; you can also visit the original URL.
The file type is application/pdf.
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
arXiv:1909.09562v1
fatcat:53w7hqijtrhtfixyvypuygauru
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.
CurryCheck: Checking Properties of Curry Programs
[article]
2016
arXiv
pre-print
Preserved Fulltext
A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2020; you can also visit the original URL.
The file type is application/pdf.
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,
arXiv:1608.05617v1
fatcat:qhhamg5qrzemxlnp47zqyqewmm
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.
Compiling ER Specifications into Declarative Programs
[article]
2007
arXiv
pre-print
Preserved Fulltext
The Internet Archive has a preservation copy of this work in our general collections.
The file type is application/pdf.
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
arXiv:0711.0348v1
fatcat:ci5jzljdprfedpsstivbbw6ao4
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.
Memoized Pull-Tabbing for Functional Logic Programming
[article]
2020
arXiv
pre-print
Preserved Fulltext
A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2020; you can also visit the original URL.
The file type is application/pdf.
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
arXiv:2008.11999v1
fatcat:i7c6gnt22jblveiamsljjgkwwe
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.
Combining Static and Dynamic Contract Checking for Curry
[article]
2017
arXiv
pre-print
Preserved Fulltext
A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2020; you can also visit the original URL.
The file type is application/pdf.
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]
1994
Lecture Notes in Computer Science
Preserved Fulltext
A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2018; you can also visit the original URL.
The file type is application/pdf.
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
2010
Communications of the ACM
Preserved Fulltext
A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2017; you can also visit the original URL.
The file type is application/pdf.
Default Rules for Curry
[chapter]
2016
Lecture Notes in Computer Science
Preserved Fulltext
A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2016; you can also visit the original URL.
The file type is application/pdf.
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
doi:10.1007/978-3-319-28228-2_5
fatcat:hpiewwmztrbz5crekzqd65x7qe
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.
Implementing Equational Constraints in a Functional Language
[article]
2011
arXiv
pre-print
Preserved Fulltext
The Internet Archive has a preservation copy of this work in our general collections.
The file type is application/pdf.
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
arXiv:1108.5609v1
fatcat:j5nee5yj5vfgdlt4llrdn76od4
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.
« Previous
Showing results 1 — 15 out of 1,420 results