Proceedings of the Sixth International Workshop on Graph Transformation and Visual Modeling Techniques (GT-VMT 2007)

Transcription

1 Electronic Communications o the EASST Volume X (2007) Proceedings o the Sixth International Workshop on Graph Transormation and Visual Modeling Techniques (GT-VMT 2007) Visual Programming with Recursion Patterns in Interaction Nets Ian Mackie, Jorge Sousa Pinto and Miguel Vilaça 12 pages Guest Editors: Karsten Ehrig, Holger Giese Managing Editors: Tiziana Margaria, Julia Padberg, Gabriele Taentzer ECEASST Home Page: ISSN

2 ECEASST Visual Programming with Recursion Patterns in Interaction Nets Ian Mackie 1, Jorge Sousa Pinto 2 and Miguel Vilaça 2 1 LIX, École Polytechnique, Palaiseau Cedex, France 2 Departamento de Inormática, Universidade do Minho, 4710 Braga, Portugal Abstract: In this paper we propose to use Interaction Nets as a ormalism or Visual Functional Programming. We consider the use o recursion patterns as a programming idiom, and introduce a suitable archetype/instantiation mechanism or interaction agents, which allows one to deine agents whose behaviour is based on recursion patterns. Keywords: Interaction nets 1 Introduction This paper is about visual programming with Interaction Nets, a graph-rewriting ormalism introduced by Laont [9], inspired by Proo-nets or Multiplicative Linear Logic. In Interaction Nets, a program consists o a number o interaction rules and an initial net that will be reduced by repeated application o the rules. The ormalism combines the usual advantages o visual programming languages, but with the ollowing additional eatures: Programs and data structures are represented in the same ramework, which is useul or tracing and debugging purposes; All aspects o computations, such as duplication and garbage-collection, are explicit. Interaction Nets have been extensively used or unctional programming as an eicient intermediate (or implementation) language. In particular, unctional programs can be encoded in Interaction Nets, using one o the many encodings o the λ-calculus. Section 3 reviews how a unctional language can be encoded in Interaction Nets ollowing this approach, without entering the details o any particular encoding o β-reduction. The ocus o this paper will be the adequate treatment o inductive datatypes, pattern-matching, and recursive unction deinitions. The remaining sections o the paper introduce and systematise the use o a unctional style or programming with Interaction Nets with recursion patterns, and introduce a new construct (the archetype, Section 4) which captures the behaviour o recursion patterns. We claim that this style is a good choice or deining and executing visual unctional programs. The style o programming we reer to is widely used by unctional programmers: it is based on programs that perorm iteration on their arguments, usually known in the ield as olds, and (the dual notion) programs that construct results by co-iteration, unolds. Among other advantages o using olds and unolds or programming, they can be composed to construct complex recursive programs, and they are particularly adequate or equational reasoning: proos o equality can be done using a usion law instead o recursion. The body o theoretical work on recursion patterns comes rom the ield o datatype-generic programming (see [4] or an introduction), which studies these patterns in a datatype-parameterized 1 / 12 Volume X (2007)

3 Visual Programming with Recursion Patterns in Interaction Nets way. The examples in the paper use lists, but it is straightorward to generalize the ideas to arbitrary regular datatypes. Section 5 introduces interaction net programming with recursion patterns; Section 6 and Section 7 then present archetypes or olds and unolds respectively. Section 8 concludes and discusses uture work. 2 Background Recursion Patterns. The ideas developed in this paper or Interaction Nets are very much inspired by Functional Programming. One undamental aspect that we will use extensively is the ability to use a set o recursion patterns or each datatype. For instance ew Haskell programmers would write a list sum program with explicit recursion as sum [] = 0 sum (x:xs) = x + (sum xs) Most would deine sum = oldr (+) 0, where oldr is a recursion pattern encoded as the ollowing higher-order unction: oldr z [] = z oldr z (x:xs) = x (oldr z xs) A unction like sum is oten called a old. The use o recursion patterns has the advantage o being appropriate or program transormation and reasoning using the so-called calculationbased style [1]. To see how less obvious olds can be deined, consider the list append unction: app :: [a] -> [a] -> [a] app [] l = l app (x:xs) l = x:(app xs l) This is a higher-order old that iterates over its irst argument to produce a unction (id is the identity unction): app = oldr (\x r l -> x:(r l)) id. The dual notion o old is the co-recursive unold that allows one to produce lists whose tails are constructed recursively by the unction being deined. For instance the Haskell unction downrom 0 = [] downrom (n+1) = (n+1):(downrom n) can be written alternatively as downrom = unold (==0) id pred where pred is the predecessor unction, and unold is deined as ollows unold :: (t -> Bool) -> (t -> a) -> (t -> t) -> t -> [a] unold p g x = i p x then [] else x : unold p g (g x) One o the reasons why unolds are important [5] is that together with olds they give us back the power o arbitrary recursion: the composition o a old with an unold is a unction (known as a hylomorphism [14]) whose recursion tree is the intermediate structure constructed by the unold. In a language with a suiciently rich type system, most useul recursive unctions can be deined in this way. Proc. GT-VMT / 12

4 ECEASST Interaction Nets. An interaction net system [9] is speciied by giving a set Σ o symbols, and a set R o interaction rules. Each symbol α Σ has an associated (ixed) arity. An occurrence o a symbol α Σ will be called an agent. I the arity o α is n, then the agent has n + 1 ports: a distinguished one called the principal port, and n auxiliary ports labelled x 1,...,x n. A net built on Σ is a graph (not necessarily connected) where the nodes are agents. The edges between nodes o the graph are connected to ports in the agents, such that there is at most one edge connected to every port in the net. Edges may be connected to two ports o the same agent. Principal ports o agents are depicted by an arrow. The ports o agents that have no edge connected are called the ree ports o the net. The set o ree ports deine the interace o the net. The dynamics o Interaction Nets are based on the notion o active pair: any pair o agents (α, β) in a net, with an edge connecting together their principal ports. An interaction rule ((α,β) = N) R replaces an occurrence o the active pair (α,β) by the net N. Rules must satisy two conditions: the interaces o the let-hand side and right-hand side are equal (this implies that the ree ports are preserved during reduction), and there is at most one rule or each pair o agents, so there is no ambiguity regarding which rule to apply. I a net does not contain any active pairs then we say that it is in normal orm. We use the notation = or one-step reduction and = or its transitive relexive closure. Additionally, we write N N i there is a sequence o interaction steps N = N, such that N is a net in normal orm. The strong constraints on the deinition o interaction rules imply that reduction is strongly commutative (the one-step diamond property holds), and thus conluence is easily obtained. equently, any normalizing interaction net is strongly normalizing. As an example, we show a system or representing lists o numbers. Lists are inductively deined by an agent o arity 0 representing the empty list, and an agent o arity 2 representing a cell in the list, containing an element and a tail list. Lists are constructed such that the principal port o each agent corresponds to the root o the list. To implement, or instance, list concatenation, we need an additional binary agent app. Concatenation is deined recursively on one o the argument lists, as expected. As such, the principal port o the agent must be used or interacting with this argument. The necessary interaction rules are given in Figure 1, together with an example net, representing the concatenation o lists [1,2] and [3,4]. app app app 1 3 app 2 4 Figure 1: Interaction rules o agent app and an example net Thus, an implementation o list concatenation can be obtained by Σ containing {,, app}, with arity 0, 2, 2 respectively, and R consisting o the rules in Figure 1. 3 / 12 Volume X (2007)

5 Visual Programming with Recursion Patterns in Interaction Nets Related Work: Visual Functional Programming. Work in this area has addressed dierent aspects o visual programming. The Pivotal project [6] oers a visual notation (and Haskell programming environment) or data structures, not programs. Reekie s Visual Haskell [15] more or less stands at the opposite side o the spectrum o possibilities: this is a datalow-style visual notation or Haskell programs, which allows programmers to deine their programs visually (with the assistance o a tool) and then have them translated automatically to Haskell code. Kelso s VFP system [7] is a complete environment that allows one to deine unctional programs visually and then reduce them step by step. Finally, VisualLambda [2] is a ormalism based on graphrewriting: programs are deined as graphs whose reduction mimics the execution o a unctional program. As ar as we know none o these systems is widely used. Visual Haskell and VisualLambda have in common that unctions are represented as boxes with input ports or the arguments and an output port or the result; the contents o the box correspond to the body o the unction. They dier in that Visual Haskell uses variables to reer to unction arguments, while VisualLambda uses a purely graphical notation based on arrows. Kelso s VFP uses a notation without boxes, more inspired by the traditional representations o unctional programs used in implementation-oriented abstract machines (see Section 5). In particular, it allows or named unctions but also or λ-abstractions, and an explicit application node exists. Variables are used or arguments, as in Visual Haskell. Higher-order programming is a undamental eature o unctional programming. A unction can take unction g as an argument and g can then applied within the body o. Expressing this eature is easy i variables are used as in Visual Haskell and VFP; in VisualLambda a special box would be used as a placeholder or g (in the body o ) to be instantiated later, and an arrow would link an input port in the box o to the box o g. The work presented in the present paper uses a pure visual representation o programs, without variables. In this aspect it resembles VisualLambda, however our work diers signiicantly rom this in that no boxes are used, and all the graph-rewriting operations are local in the sense that only two nodes o the graph are involved in each step. A second diiculty arising rom the higher-order nature o programs is that a (curried) unction o two arguments may receive only its irst argument and return as result a unction. In a boxbased representation this means that it must be possible or a box to lose its input ports one by one a complicated process. Interaction nets treat this problem naturally as will become clear. Moreover in this paper we introduce a new notion (the archetype), which captures precisely the behaviour o many typical curried unctions. 3 Visual Functional Programming with Interaction Nets Using Explicit Abstraction and Application Nodes In this section we explain how a very simple unctional programming language can be encoded in Interaction Nets. The language has inductive types, pattern-matching on these types, and explicit recursion. We irst review the basic principle shared by most well-known encodings [13, 12, 16] o the λ-calculus into Interaction Nets, and show how this basic language can easily be extended to cover other eatures o unctional languages. Proc. GT-VMT / 12

6 ECEASST The usual way o representing unctional programs with interaction nets is based on a pair o symbols o arity 2, such that a β-reduction step corresponds to an interaction between an agent λ and an These representations are based on an explicit depiction o the λ-abstractions in the program, as well as applications o unctions to arguments. While this may be visually more complicated than the boxes used by some o the systems reviewed in Section 2, it certainly solves the higher-order problem in a natural way, since unction arguments are treated like any other arguments. The deinition o the application unction ap x = x illustrates this point (see Figure 2 let). λ Figure 2: App deinition (let) and β rule (right) We only discuss the eatures o the linear λ-calculus here, which is shared by all encodings. It is beyond the scope o this paper to unclude the details o the non-linear aspects, but reer the reader to [12, 13] or the encodings o the ull λ-calculus. ider an interaction system containing the symbols {@,λ} as explained above, as well as the β interaction rule o Figure 2 (right). This system deines the visual programming language or the linear λ-calculus. A visual unctional program consists o this interaction system, together with a closed unctional expression to be evaluated, represented by a net with a single ree port. We now outline how other eatures can be introduced in the interaction system to enrich this core language. The next eature is Inductive Types and Pattern-matching. ider a datatype T with constructors C 1...C n, with arities a 1...a n. This can be modelled in a straightorward way by an interaction system containing n agents labelled C i with arity a i, i = 1...n ; values o type T correspond to closed trees built exclusively rom these agents (in a tree all principal ports are oriented in the same direction). In a constructor agent, auxiliary ports are input ports, and the principal port is an output port. An example o this is the datatype o lists with constructors and, as in Figure 1. Pattern-matching over an inductive type T can be implemented by a special agent Tcase. For instance, the ListCase agent has arity 5, and its behaviour is deined by the two rules: List Case List Case Here two dierent nets are connected to the ListCase agent. One is a net to be returned when the argument list is empty, and the other is a net with three ports, used to combine the head and 5 / 12 Volume X (2007)

7 Visual Programming with Recursion Patterns in Interaction Nets tail o a non-empty list. Observe that one o these nets is not used in each rule, and must be erased with agents. The interaction o an agent with any other agent erases the latter and propagates new agents along its auxiliary ports. The approach outlined above allows or unnamed unctions only. In a visual language one would like to have the possibility o deining named unctions, which would most naturally correspond to agents in the interaction system. A special agent de can be used or unolding named unction deinitions. For instance a unction isempty can be deined by the ollowing interaction rule or the agent de: de λ is Empty List Case True False The ollowing igureshows the reduction o the visual program corresponding to the application o isempty to the List Case False de is Empty 1 2 λ List Case True False False True 1 2 True This agent also allows or a visually appealing treatment o recursion: it suices that the righthand side o interaction rules involving de reintroduces an active pair (the let-hand side o the rule) as a sub-net. To sum up, Interaction Nets allow to visually represent unctional programs and data structures in the same very simple ormalism; moreover higher-order eatures, which are a typical diiculty in the visual setting, are treated in a natural way, and the execution o the program can be eiciently implemented within the ormalism. 4 Agent Archetypes Although no standard programming language exists as a ront-end or programming with Interaction Nets, it is generally well accepted that any such language should contain some orm o support or modularity and reusability. In particular, a mechanism should exist to acilitate the deinition o interaction rules that ollow identical patterns. To illustrate, consider again the app agent o Figure 1. It is deined by case analysis on the structure o the argument, and in act any other agent deined in this way must have two interaction rules with a similar structure to those in Figure 1. We now introduce a concept designed precisely to isolate this structure, which we designate archetype. The ListCase archetype given Proc. GT-VMT / 12

8 ECEASST below should be interpreted as ollows: any agent that its this archetype interacts with both and, and the right hand sides o the corresponding rules are nets to be instantiated, that will be called respectively N, and N,. Archetype ListCase N, N, To deine a new agent ollowing the archetype, an instance is created, by simply providing the nets in the right-hand side o the interaction rules. This implicitly includes the agent declaration, as well as the instantiated interaction rules or this agent, in the interaction system being deined. As an example, the isempty agent (and its behaviour) is deined as an instance o the ListCase archetype. agents are used to explicitly erase the head and tail o the list, which are not used in the result. Instance ListCase isempty N iszero, N iszero, = True = False For a second example, take the agent de used in Section 5 or unction deinitions. We create an archetype or deined unctions, whose only mandatory rule is or interaction with de, with the right-hand side to be instantiated. Recursive archetypes are most interesting, and will be very useul in the rest o the paper (in Section 6 a recursive archetype will be given or the app agent). Although archetypes can be useul or programming with interaction nets in general, our examples o using them here concern eatures o unctional programming languages. The ListCase example shows that archetypes allow or a natural treatment o higher-order concepts: ListCase can be seen as a unction that takes certain arguments (the instantiated nets) and returns another unction (an agent with its own rules) as result. 5 Interaction Net Programming with Recursion Patterns Section 3 was about using Interaction Nets or encoding unctional programs, with the practical goal o producing eicient unctional compilers. From the point o view o visual programming, the drawbacks o this approach are that the introduction o explicit abstraction and application nodes complicates the visual representation o programs (the same is true o explicit case constructs), and also raises the matching duplicators problem. Solving this problem implies introducing in the system machinery that destroys the clean visual representation o terms. 7 / 12 Volume X (2007)

9 Visual Programming with Recursion Patterns in Interaction Nets Our goal in this paper is to propose a number o principles and extensions or direct visual programming with Interaction Nets, in a unctional style. To see what we mean by direct, consider again the interaction rules given in Figure 1. It is easy to see that both deine a behaviour or the agent app similar to the standard list concatenation unction, which can be written in Haskell as shown in Section 2. In both cases, a program consists o a collection o unction deinitions encoded directly as interaction rules in a particular interaction system, together with a closed unctional expression to be evaluated in the context o those deinitions, represented by a net with a single ree port. While in the second approach a unction deinition corresponds to interaction rules or a special agent de, in Figure 1 there is a direct correspondence between the clauses in the deinition o a unction and the interaction rules deining the behaviour o the agent. A comparison o both deinitions reveals that the irst approach is visually simpler, and thus more appropriate or representing programs, than the second, standard approach. Naturally, there are important limitations to the class o programs with which the simpliied representation can be used. The example above takes advantage o a undamental aspect o Interaction Nets, which is that pattern-matching on the outermost constructor is built-in through the rule selection mechanism (in the deinition o app in Figure 1, only the outermost constructor is matched). Matching deeper constructors, or matching more than one argument in the same clause, would orce us to use an explicit case agent. For a certain class o patterns (match-sequential systems [17]) there are known transormations which result in a system which examines arguments one at a time. We can use this transormation to obtain an explicit system. We reer the reader to [8] or a detailed presentation o one such transormation. It will now be shown that the use o a programming style based on recursion patterns allows precisely or the direct representation to be used, since these operators perorm pattern-matching on a single top-level constructor. Iteration: Fold Agents. The simplest orm o recursion is iteration, which substitutes the datatype constructors by some given unctions. Taking lists as an example, a old is a unction that combines the head o the list with the result o recursively applying the unction to the tail o the list, to produce the result (a given value is returned at the end o the list). Since this requires matching on the outermost constructor only, iteration neatly its the interaction paradigm. The ollowing is the deinition o the product old, which computes the product o all the numbers in a list (it uses an agent or multiplication o numbers; we assume the arithmetics to be correctly implemented in the current interaction system). prod S prod * 0 prod It is easy to see that other, more powerul recursion patterns on an inductive type can be captured in the same way. For instance, primitive recursion on a list would allow or the tail o the list itsel to be used as well. Proc. GT-VMT / 12

10 ECEASST Co-recursion Patterns: Unold Agents. Co-recursive unctions provide structured ways to construct values o recursive types. Taking lists as an example again, the unold co-recursion pattern, which is the dual o old, corresponds to unctions that construct lists by giving an element to be placed at the head position, together with a seed used as an argument to recursively construct the tail o the list. This is the simplest orm o co-recursion. Let us consider an unold agent downrom (d) which interacts with a natural number n to construct the list containing all the numbers rom n down to 1, in this order. Its rules are the ollowing d d * 0 S * S d 6 Fold Archetypes The rules that characterize the behaviour o a old agent (on a particular inductive type) can be described by a recursive archetype, in the sense that the parameterized agent occurs in the right-hand side o one o the rules. Taking the case o lists, interaction rules must be deined or to interact with both and. The archetype is Archetype oldr N, N, where interaction with results in an arbitrary net, and interaction with sends an agent along the tail o the argument list, and a net N, then combines the head o the list with the recursive result. As an example, the agent prod can be alternatively deined as the ollowing instance. Instance oldr prod N prod, = S 0 N prod, = * The principles developed above can be applied to olds over any regular inductive type. 9 / 12 Volume X (2007)

11 Visual Programming with Recursion Patterns in Interaction Nets Higher-order Folds. Our current deinition o a old agent is still not satisactory, and will now be generalized. ider again the list append unction. As seen in Section 2, this is a higher-order unction o two arguments, deined by recursion on its irst argument. This old can be deined with Interaction Nets as a binary agent (see Figure 1), which clearly does not match our current deinition o the old archetype. Functions o more than one argument deined as olds over one o the arguments lead us to the generalization o the oldr archetype, as shown in the ollowing igure. This is parameterized by the number o extra arguments o the old agent; our previous deinition is o course a particular case o this where k = 0. Archetype oldr (k) N, args args' k args N, k args head tail k args head rec. result k k The deinition o append as an instance o this archetype, or k = 1, can be seen below. The open wire in the net N app, corresponds to the act that the second argument o the old is preserved in the recursive call. Instance oldr app(1) N app, y N app, = = y y' y head rec. result head rec. result y y' 7 Unold Archetypes It is less obvious to deine an archetype or unolds. ider again the case o lists; it is clear that there must be two rules (to produce empty and non-empty lists respectively); the contents o the right-hand side o each interaction rule is also clear (with a parameter net appearing in the second rule). However, since the arguments o an unold are arbitrary, the two rules cannot correspond to interactions between the unold and its arguments. Instead, we will consider two special agents that interact with the unold. Archetype unold u Instance unold du u u c1 c2 u N du = g N u Proc. GT-VMT / 12

12 ECEASST Now observe that an instance o this archetype does not immediately behave as an unold; it must be connected to the net N u. To take downrom as an example again, this net is in this case simply an agent (see right o previous igure) whose behaviour is given by the rules on the let in the ollowing. Then the ollowing macro (on the right) can be deined: g 0 c1 g S S c2 d' = du g 8 Conclusions and Future Work One o our long-term goals is to develop a ull environment or interaction net programming a tool is currently being developed. We are currently working on the archetype deinition and instantiation mechanismsubsequently, we plan to incorporate in the programming environment a mechanism that generates the appropriate archetype or a given user-deined inductive type. This paper opens a number o other research questions at the theoretical level. One o the main reasons or using recursion patterns and datatype-generic programming is that this style o programming is good or reasoning about programs equationally. The work in this paper allows us to reason about unctional programs visually. In [11] we derive a usion law or the old archetype, that already makes it possible to transpose to the visual setting classic program transormation techniques such as the introduction o accumulators or tupling. A dierent approach that we intend to explore is to establish a ormal correspondence between a core unctional language with recursion patterns and an interaction system or that language. This will allows us to be more precise in the study o the calculation laws or visual programs. At the level o the programming environment, the graphical notation then becomes an alternative to writing unctional programs textually. The environment should be able to translate between visual programs and textual programs, and all operations perormed on programs at the visual level correspond closely to the same operations at the expression level. Acknowledgements: The work o Vilaça was granted by FCT (SFRH/BD/18874/2004). Bibliography [1] R. Bird. The Promotion and Accumulation Strategies in Transormational Programming, ACM Transactions on Programming Languages and Systems, 6(4), October 1984, [2] L. Dami and D. Vallet. Higher-order unctional composition in visual orm. Technical report, University o Geneva, [3] M. Fernández. Type assignment and termination o interaction nets. Mathematical Structures in Computer Science, 8(6): , / 12 Volume X (2007)

13 Visual Programming with Recursion Patterns in Interaction Nets [4] J. Gibbons. Calculating Functional Programs. In Proceedings o ISRG/SERG Research Colloquium. School o Computing and Mathematical Sciences, Oxord Brookes University, [5] J. Gibbons and G. Jones. The Under-appreciated Unold. In Proceedings o the 3rd ACM SIGPLAN International Conerence on Functional Programming (ICFP 98), pages ACM Press, [6] K. Hanna. Interactive Visual Functional Programming. In S. P. Jones, editor, Proc. Intnl Con. on Functional Programming, pages ACM, October [7] J. Kelso. A Visual Programming Environment or Functional Languages. PhD thesis, Murdoch University, [8] J.R. Kennaway. Implementing term rewrite languages in DACTL. Theoretical Computer Science, 72: , [9] Y. Laont. Interaction Nets. In Proceedings o the 17th ACM Symposium on Principles o Programming Languages (POPL 90), pages ACM Press, Jan [10] M. Fernández and I. Mackie. Coinductive techniques or operational equivalence o interaction nets. In Proceedings o the 13th Annual IEEE Symposium on Logic in Computer Science (LICS 98), pages IEEE Computer Society Press, June [11] I. Mackie, J. S. Pinto, and M. Vilaça. Functional programming and program transormation with interaction nets. Technical Report DI-PURe , Universidade do Minho, [12] I. Mackie. YALE: Yet another lambda evaluator based on interaction nets. In Proceedings o the 3rd ACM SIGPLAN International Conerence on Functional Programming (ICFP 98), pages ACM Press, September [13] I. Mackie. Eicient λ-evaluation with interaction nets. In V. van Oostrom, editor, Proceedings o Rewriting Techniques and Applications: 15th International Conerence (RTA 2004), volume 3091 o Lecture Notes in Computer Science. Springer-Verlag, [14] E. Meijer, M. Fokkinga, and R. Paterson. Functional programming with bananas, lenses, envelopes and barbed wire. In J. Hughes, editor, Proceedings o the 5th ACM Conerence on Functional Programming Languages and Computer Architecture (FPCA 91), volume 523 o LNCS. Springer-Verlag, [15] H. J. Reekie. Realtime Signal Processing Datalow, Visual, and Functional Programming. PhD thesis, University o Technology at Sydney, [16] F.-R. Sinot. Token-passing Nets: Call-by-need or Free. In Proceedings o the 1st. International Workshop on Developments in Computational Models (DCM 05), [17] S. Thatte. A reinement o strong sequentiality or term rewriting systems with constructors. Inormation and Computation, 72:46 65, Proc. GT-VMT / 12