Abstract. Wayfinding in road networks is a hierarchical process. It involves a sequence of tasks, starting with route planning, continuing with the extraction of wayfinding instructions, and leading to the actual driving. From one task level to the next, the relevant road network becomes more detailed. How does the wayfinding process change? Building on a previous, informal hierarchical highway navigation model and on graph granulation theory, we are working toward a theory of granularity transformations for wayfinding processes. The paper shows the first results: a formal ontology of wayfinding at the planning level and an informal model of granularity mappings.

We propose three extensions to patterns and pattern matching in Haskell. The first, pattern guards, allows the guards of a guarded equation to match patterns and bind variables, as well as to test boolean condition. For this we introduce a natural generalisation of guard expressions to guard qualifiers. A frequently-occurring special case is that a function should be applied to a matched value, and the result of this is to be matched against another pattern. For this we introduce a syntactic abbreviation, transformational patterns, that is particularly useful when dealing with views. These proposals can be implemented with very modest syntactic and implementation cost. They are upward compatible with Haskell; all existing programs will continue to work. We also offer a third, much more speculative proposal, which provides the transformational-pattern construct with additional power to explicitly catch pattern match failure. We demonstrate the usefulness of the proposed extension by several examples, in particular, we compare our proposal with views, and we also discuss the use of the new patterns in combination with equational reasoning.

Abstract: Current best-practices for defining Domain-Specific Modeling Languages call for metamodeling techniques, which do not take into account the future use of such languages in multiview design environments. Tool implementers have tried a variety of ad-hoc techniques to maintain views in-synch, with modest results. To improve this state of affairs, a declarative approach is elaborated to automate multiview synchronization, building upon existing metamodeling techniques and recent advances in the field of function inversion for bidirectionalization. An application of these ideas to EMOF and a discussion of the resulting Declarative MVC software architecture are also provided. A significant benefit of the approach is the resulting comprehensive solution to a recurrent problem in the software modeling field. 1

Type classes are perhaps the most exciting feature of Haskell’s type system. Although type classes were only proposed as a solution for overloading identifiers, they have become an active research topic where experimental type class extensions are still being proposed. On top of that, the underlying principles are also used to encode various other extensions, such as extensible records, implicit parameters, and subtyping. However, implementing type classes and type class extensions is not a trivial task. It is not only a matter of type checking to resolve overloading, but also evidence for overloaded identifiers has to be inserted. A uniform approach to easily formulate type class extensions side by side is missing. In addition, error messages concerning type classes are difficult to understand or sometimes not present at all. We propose a constraint-based framework for the resolution of overloading. Assumptions and proof obligations are explicitly encoded into the constraint language of this framework. Furthermore, type class extensions can be easily formulated using Constraint Handling Rules (CHRs). The confluence requirement is circumvented by using only propagation CHRs, and by specifying design decisions in the form of heuristics. Using the resulting framework, we show how various context reduction strategies can be specified side by side. Furthermore, we explain how scoped instances and overlapping instances are naturally supported. We also show how functional dependencies can be supported using the existing translation into CHRs.

This article details the design and implementation of OCAMLGRAPH, a generic graph library for the programming languageO CAML. This library features a large set of graph data structures--directed or undirected, with or without labels on vertices and edges, as persistent or mutable data structures, etc.--and a large set ofgraph algorithms written independently of the graph data structure. Such a genericity is obtained through a massive use of OCAMLmodule system and of its functions, the so-called functors.

In a companion paper, we have presented an alternative representation of grammars in Haskell, explicitizing the grammar’s recursion, decoupling the grammar from its semantic actions and making semantic actions independent of matching order. In this technical report, we present the implementation of some interesting grammar algorithms in order to provide evidence for the increased power and declarative style of our novel grammar representation. The presented code is a simplification of parts of our freely available Haskell library grammar-combinators.

Abstract. Argumentation theory is an interdisciplinary field studying how conclusions can be reached through logical reasoning. The notion of argument is completely general, including for example legal arguments, scientific arguments, and political arguments. Computational argumentationtheoryisstudiedinthecontextofartificial intelligence, andanumber of computational argumentation frameworks have been put forward to date. However, there is a lack of concrete, high level realisations of these frameworks, which hampers research and applications at a number of levels. We hypothesise that the lack of suitable domain-specific languages in which to formalise argumentation frameworks is a contributing factor. In this paper, we present a formalisation of a particular computational argumentation framework, Carneades, as a case study with a view to investigate the extent to which functional languages are useful as a means to realising computational argumentation frameworks and reason about them.