Pattern matching in concatenativeprogramming languages

Daniel EhrenbergCarleton Collegeehrenbed@carleton.eduFebruary 25, 2009

Abstract

Pattern matching is a useful, convenient tool for processing alge-braic data types in functional programming languages. This paperdiscusses a method for porting pattern matching to a family of pro-gramming languages called

concatenative

, which does not use namedvariables. The system is not ﬁxed, like a traditional pattern matchingsystem, but rather arbitrarily extensible: any function can be usedas a pattern if the right information is given to the pattern matcher.This generalization of pattern matching has been useful in librariesfor XML processing and unit conversion.

1 Introduction

The idea of pattern matching is that, to see the contents of an object, thesame syntax can be used as in creating the object, only on the left hand sideof a binding rather than the right. For example, a Haskell [2] function to getthe head of a list can be implemented declaratively, simply as

head (x:xs) = x

Here,

x:xs

signiﬁes a cons cell, where

is the head and

is the tail. The

head

function extracts the head of the list

x:xs

and returns it. Patternmatching can also be used to decide which branch of several to take. Forexample,

map

can be implemented as1

map f [] = [] map f (x:xs) = (f x):(map f xs)

In many functional programming languages, including Haskell, pattern match-ing is a fundamental built-in construct. Pattern matching systems have alsobeen constructed as macro libraries in languages like Common Lisp.Certain programming languages, termed concatenative programming lan-guages, express a program in terms of the composition of several smaller pro-grams, typically without the use of named variables. The ﬁrst language tobe called concatenative was Joy [8]. A more common one is Forth. Most con-catenative programming languages, including Joy and Factor, follow Forth’sstack-based model.It is not immediately obvious how to port pattern matching to such asystem, without the inclusion of named free variables on the left hand side.A fundamental rethink of pattern matching, from the deconstruction of sum-of-product data types to a partial inverse of a function, leads to a clearsolution to this problem.We have constructed an eﬃcient pattern matching library for the dynam-ically typed concatenative programming language Factor [3]. A compositionof functions, each of whose inverse is known, can easily be inverted using theformula (

◦

)

−

◦

−

. Functions that are used in pattern matchingare typically not surjective.For example,

cons

is not surjective onto the

list

type, as the empty listis not in its codomain. As a result, the inverse of

cons

is a partial function.In general, the inverse of the constructor for an algebraic data type wouldbe a partial function deﬁned on things from that constructor, returning thearguments of the constructor. From these partial functions we can create a

case

-like construct, which attempts each inverse on a given input until oneof them returns a result.This conception of pattern matching naturally leads to a signiﬁcant gen-eralization of existing systems. One simple thing that this new system cando is “pattern match” over certain simple bijective arithmetical formulas,inverting them. Inverting math formulas could be done in a constraint satis-faction system, but our system is much simpler. The system has been usedto construct a practical library for encoding numbers with units. With thislibrary, centimeters can be converted to inches by applying the centimeterconstructor and then inverting the inches constructor.2

2 Background

2.1 Pattern matching in Haskell

In this paper, we use Haskell as a model for the typical semantics of pat-tern matching. Haskell is a statically typed, non-strict, purely functionalprogramming language. Haskell pattern matching, like that of most func-tional languages, operates on algebraic data types. For example, we couldimplement a list of integers as

data List = Cons Int List | Nil

This statement declares that a list is either a

Nil

or a

Cons

, where the latterhas two slots, one for an integer and one for another list. To construct alist, we can write code which treats

Cons

and

Nil

as ordinary functions,where

Cons

takes two arguments and

Nil

takes none. For example, the list

’(1 2 3)

can be constructed as

Cons 1 (Cons 2 (Cons 3 Nil))

. To getinformation out of the slots, pattern matching is used. For example, to getthe head of the list, the

Cons

constructor can be used on the left hand sizeof

head (Cons x xs) = x

Pattern matching only succeeds if the argument to

head

is actually a

Cons

,rather than a

Nil

. This can be used to dispatch on what kind of argumentis given. For example, a function to sum a list can be implemented as

sum (Cons x xs) = x + (sum xs)sum Nil = 0

Conceptually, when

Cons

Nil

are put on the left hand side of the assign-ment, they’re used backwards. You try to undo

Cons

into the variables

and

, and if this fails, you go on to trying to undo

Nil

. This is not howpattern matching in Haskell is typically explained, but it is equivalent to thestandard deﬁnition, and this observation leads to a generalization which weuse.

2.2 The concatenative programming model

Factor is a stack-based programming language. This means that parametersare passed around on an implicit stack, rather than used as explicit arguments3