1 General

Although combinatory logic has precursors, it was Moses Schönfinkel who first explored combinatory logic as such. Later the work was continued by Haskell B. Curry. Combinatory logic was developed as a theory for the foundation of mathematics [Bun:NatICL], and it has relevance in linguistics too.

Its goal was to understand paradoxes better, and to establish fundamental mathematical concepts on simpler and cleaner principles than the existing mathematical frameworks, especially to understand better the concept of substitution. Its “lack of (bound) variables” relates combinatory logic to the pointfree style of programming. (For contrast, see a very different approach which also enables full elimination of variables: recursive function theory)

Lojban is an artificial language (and, unlike the more a posteriori Esperanto, it is rather of an a priori taste). It is a human language, capable of expressing everything. Its grammar uses (among others) things taken from mathematical logic, e.g. predicate-like structures. Although its does not make use combinatory logic directly (even, from a category logic / functional programming point of view, it uses also rather imperative ideas), but it may give hints and analogies, how combinatry logic can be useful in linguistics.

CL++, a lazy-evaluating combinatory logic interpreter with some computer algebra service: e.g. it can reply the question with instead of a huge amount of parantheses and , combinators. Unfortunately I have not written it directly in English, so all documentations, source code and libraries are in Hungarian. I want to rewrite it using more advanced Haskell programming concepts (e.g. monads or attribute grammars) and directly in English.

4 Base

Some thoughts on base combinators and on the relatedness of their rules to other topics

Records in function: in set theory and database theory, we regard functions as consisting of more elementary parts, records: a function f can be regarded as the set of all its records. A record is a pair of a key and its value, and for functions we expect unicity (and sometimes stress this requirement by writing instead of ).Sometimes I think of as having a taste of record selection: selects a record determinated by key x in function f (as in a database), and returns the found record (i.e. corresponding key and value) contained in the c container (continuation). Is this thought just a toy or can it be brought further? Does it explain why and can constitute a base?

Also bracket abstraction gives us a natural way to understand the seemingly rather unintuitive and artificial combinator better

5 Programming in CL

I think many thoughts from John Hughes' Why Functional Programming Matters can be applied to programming in Combinatory Logic. And almost all concepts used in the Haskell world (catamorphisms etc.) help us a lot here too. Combinatory logic is a powerful and concise programming language. I wonder how functional logic programming could be done by using the concepts of Illative combinatory logic, too.

5.1 Datatypes

5.1.1 Continuation passing for polynomial datatypes

5.1.1.1 Direct product

Let us begin with a notion of the ordered pair and denote it by .
We know this construct well when defining operations for booleans

and Church numbers. I think, in generally, when defining datatypes in a continuation-passing way (e.g. Maybe or direct sum), then operations on so-defined datatypes often turn to be well-definable by some .

We define it with

in λ-calculus and

in combinatory logic.

A nice generalization scheme:

as the construct can be generalized to any natural number n (the concept of n-tuple, see Barendregt's λ Calculus)

and in this generalized scheme corresponds to the 0 case, to the 1 case, and the ordered pair construct to the 2 case, as though defining

so we can write definition

or the same

in a more interesting way:

Is this generalizable? I do not know.
I know an analogy in the case of , , , .

5.1.1.2 Direct sum

The notion of ordered pair mentioned above really enables us to deal with direct products. What about it dual concept? How to make direct sums in Combinatory Logic? And after we have implemented it, how can we see that it is really a dual concept of direct product?

A nice argument described in David Madore's Unlambda page gives us a continuation-passig style like solution.
We expect reductions like

Using the formulating combinators described in Haskell B. Curry's Combinatory Logic I, we can translate these definitions into combinatory logic without any pain:

Of course we could use the two parameters in the opposite order, but I am not sure yet that it would provide a more easy way.

A little practice: let us define concat.
In Haskell, we can do that by

concat=foldr(++)[]

which corresponds in cominatory logic to reducing

Let us use the ordered pair (direct product) construct:

and if I use that nasty (see later)

5.2 Monads in Combinatory Logic?

5.2.1 Concrete monads

5.2.1.1 Maybe as a monad

5.2.1.1.1 return

Implementing the

return

monadic method for the

Maybe

monad is rather straightforward, both in Haskell and CL:

instanceMonadMaybereturn= Just
...

in Haskell and

in combinatory logic.

5.2.1.1.2 map

Haskell:

instanceFunctorMaybewheremap f =maybe Nothing (Just . f)

λ-calculus:
Expected reductions:

Definition:

Combinatory logic: we expect the same reduction here too

let us get rid of one parameter:

now we have the definition:

5.2.1.1.3 bind

Haskell:

instanceMonadMaybe(>>=)where(>>=) f p =maybe Nothing f

λ-calculus: we expect

achieved by defintion

In combinatory logic the above expected reduction

getting rid of the outest parameter

yielding definition

and of course

But the other way (starting with a better chosen parameter order) is much better:

yielding the much simplier and more efficient definition:

We know already that can be seen as as a member of the scheme of tuples: for n = 1 case.
As the tupe construction is a usual guest at things like this (we shall meet it at list and other maybe-operations like ),
so us express the above definition with denoted as :

hoping that this will enable us some interesting generalization in the future.

But why we have not made a more brave generalization, and express monadic bind from monadic join and map? Later in the list monad, we shall see that it may be better to avoid this for sake of deforestation. Here a maybe similar problem will appear: the problem of superfluous .

5.2.1.1.4 join

We should think of changing the architecture if we suspect that we could avoid and solve the problem with a more simple construct.

5.2.1.2 The list as a monad

Let us think of our list-operations as implementing monadic methods of the list monad. We can express this by definitions too, e.g.

we could name

Now let us see mapping a list, concatenating a list, binding a list.
Mapping and binding have a common property: yielding nil for nil.
I shall say these operations are centred: their definition would contain a subexpression. Thus I shall give a name to this subexpression:

Now let us define map and bind for lists:

now we see it was worth of defining a common .
But to tell the truth, it may be a trap. breaks a symmetry: we should always define the cons and nil part of the foldr construct on the same level, always together. Modularization should be pointed towards this direction, and not to run forward into the T-street of .

Another remark: of course we can get the monadic bind for lists

But we used here. How do we define it? It is surprisingly simple. Let us think how we would define it in Haskell by

foldr

function, if it was not defined already as

++

defined in Prelude:

In defining

(++) list1 list2

we can do it by

foldr

:

(++)[] list2 = list2
(++)(a : as) list2 = a : (++)as list2

thus

(++) list1 list2 =foldr(:) list2 list1

let us se how we should reduce its corresponding expression in Combinatory Logic:

thus

Thus, we have defined monadic bind for lists. I shall call this the deforested bind for lists. Of course, we could define it another way too: by concat and map, which corresponds to defining monadic bind from monadic map and monadic join.
But I think this way forces my CL-interpreter to manage temporary lists, so I gave rather the deforested definition.

Defining the other monadic operation: return for lists is easy:

instanceMonad[]wherereturn=(: [])

in Haskell -- we know,

(: [])

translates to

return=flip(:)[]

so we can see how to do it in combinatory logic:

5.2.2 How to AOP with monads in Combinatory Logic?

We have defined monadic list in CL. Of course we can make monadic Maybe, binary tree, Error monad with direct sum constructs...

But separation of concerns by monads is more than having a bunch of special monads. It requires other possibilities too: e.g. being able to use monads generally, which can become any concrete mondads.

Of course my simple CL interpreter does not know anything on type classes, overloading. But there is a rather restricted andstatic possibility provided by the concept of definition itself:

and later we can change the binding mode named A e.g. from a failure-handling Maybe-like one to a more general indeterminism-handling list-like one, then we can do that simply by replacing definition

on The Tree of Knowledge (in Hungarian). To summarize this annotation by citing its main thought: The intelligence is not a mere map from the outer world: but it is a continuous world-creating, and there are as many worlds as many minds.

6.2 Self-replication

Quines: the idea of self-replication can be conveyed by the concept of a program, which is able to print its own list.
But pure λ-calculus and combinatory logic does not know any notion of printing! We should like the capture the essence of self-replication, without resorting to the imperative world.

6.2.1 Representation, qoutation -- the DNA

Let us introduce the concept of representing combinatory logic terms. How could we do that? For example, by binary trees. The leaves should represent the base combinators, and the branches mean application.

And how to represent combintory logic terms -- in combinatory logic itself? The first thought could be, that it is not a problem. Each combinatory logic term could be represented by itself.

Sometimes this idea works. The huge power of higher order functions is exactly in being able to treat datas programs and vice versa. Sometimes we are enabled to do things, which could be done in other languages only by carefully designing a representation, a specific language.

But sometimes, representing CL terms by themselves is not enough. Let us imagine a tutoring program! Let the topic be combinatory logic, the language of implementation -- combinatory logic, too. How should the tutoring program ask the pupil questions like:

Tell me if the following two expresions have the same normal form:

The problem is that our program is simply unable to distinguish between CL terms which have the same normal form (in fact, equivalence cannot be defined generally either). If we represent CL terms by themselves, we simply loose a lot of information, including loosing any possibility to make distinctions between equivalent terms.

We see that there is something that relates to make a distinction between target language and metalanguage (See Imre Ruzsa, or Haskell B. Curry)

In this example, the distinction is:

We deal with combinatory logic expressions because our program has to teach them: it is related to it just like a vocabulary program is related to English.

But we deal with programming logic expressions because our program is implemented in them. Just like VIM is related to C++.

We said CL terms are eventually trees. Let us represent them with trees then -- now let us think of trees not as of term trees, but as datatypes which we must construct by hand, in a similar way as we defined Maybes, direct sums, direct products, lists.

where let α denote the representation of a and β that of b

Let us make a distinction between term trees and datatype trees. A Haskell example:

many Haskell expressions can be regarded as term trees

but only special Haskell expressions can be seen as datatype trees: those who are constructed from

Branch

and

Leaf

in an appropriate way

Similarly,

all CL expressions can be regarded as term trees.

but CL expressions which can be revered as datatype trees must obey a huge amount of constraints: they may consist only of subexpressions , , , subexpressions in an approporiate way.

(In fact, all CL expressions can be regarded as datatype trees too: CL is a total thing, we can us each CL expression in a same way as a datatype tree: we can apply it leaf- and branch-continuation arguments. Something will always happen. At worst it will diverge -- but lazy trees can diverge too, amd they are inarguably datatype trees. But now let us ignore all these facts, and let us define the notion of quotations in the restictive way: let the definition require to be structured in a predefined way.)

We use datatype trees for representing other expressions. Let us call CL expressions which can represent (another CL expreesion) quotations.
Quotations are exactly the datatype trees, but

the world quotation refers to their function,

the world datatype tree refers to their implemetation, structure

This means a datatype tree

is not only a tree regarded only as a term tree,

but on a higher level: itself a recursive datatype implemented in CL, it is appropiately consisting of , and , subexpressions so that we can reason about it in CL itself

How do quotations relate to all CL expressions?

In one direction, informally, we could say, quotations make a very proper subset of all CL expressions (attention: cardinality is the same!). Not every CL expressions are datatype trees.

But the reverse is not true: all CL expressions can be quoted! Foreach CL expressionther is a (unique) CL expression who quotes it!

We can define a quote function on the set of all CL expressions.
But of it is an conceptually outside function, not a CL combinator itself!
(that is why I do not typest it boldface. Is it an example of what Curry called epitheory?).

After having solved the representation (quoting) problem, we can do many things. We can define meta-concepts, e.g.

(the notion of same terms)

by bool tree equality

= (equivalence made by reduction)

by building a metacircular interpreter

We can write our tutor program too. But let us discuss more clean and theoretical questions.

How can be the concept of quine transferred to combinatory logic?
In the bellow definition, let us think of

A's as actions, programs

and Q's as quotations, representations

A quine is a CL term A

this means quines are pure CL concepts, no imperative compromises

for whose normal form A0

this means quines are run

there exists an equivalent CL-term Q where

datatypes in CL arealmost never defined in their normal form (not even ordered pairs are!). They save us from loosing information, but they almost never do that literary. I faced this as problems in nice rewritings when I wanted to implement CL with computer algebra services

Q is a quotation,

which manifests itself in the fact that Q is a datatype tree (not only term tree) with boolean leafs,

Q quotes A

and Q is exactly the representation of A

So a quine is a program which is run, then rewrited as a quotation and so we get the representation of the original program.

Of course the first three requirements can be contracted in two.
Thus, a quine is a CL-term which is equivalent to its own representation (if we mean representation as treated here).

6.3 A metacircular interpeter

We have seen that we can represent CL expressions in CL itself, which enables us to do some meta things (see the into of this section, especially Reflective programming, e.g. Reflection '96).
The first idea could be: to implement CL in itself!

6.3.1 Implementing lazy evaluation

The most important subtask to achieve this goal is to implement the algorithm of lazy evaluation.
I confess I simply lack almost any knowledge on algorithms for implementing lazy evaluation. In my Haskell programs, when they must implement lazy evaluation, I use the following hand-made algorithm.

Functions of increasing number of arguments pass the term tree to each other during analyzing it deaper and deaper. The functions are

and it seems hard to me hard to implement in CL.
Almost all of these functions are mutual recursive definitions, and it looks hard for me to formulate the fixpont.
Of coure I could find another algorithm. The main problem is that reducing CL trees is not so simple: the rule requires lookahead in 2 levels. Maybe once I find another one with monads, arrows, or attribute grammars...

7 A lightweight CL implementation

I mean

instead of writing a CL interpreter (or compiler) with a huge amount of command-line arguments and colon-escaped prompt commands,

why not to write a lightweight library? (Lightweight in the sense as Parsec is lightweight in comparison to parser generators, or QuickCheck is lightweight).

This latter framework can contain the previous one e.g. by implementing

interpreter ::IO()
compiler :: Term -> Haskell

where

Haskell

can be a string, an appropriately designed abstract datatype, a rose tree or a Template Haskell term representation of Haskell expressions, thus any way used in Haskell metaprogramming (in the picture below, does it correspond to ?).

So, the latter can contain the former, but what are the new advantages?

So we can get compiler algebra and other useful services in a modular way.

Of course also an interpreter can yield useful services, but as the user interface grows, it develops to have a command language, which is in most cases imperative having less gluing possibilities than being able to use Haskell itself by this lightweight approach.

In fact, it the was the quines (mentioned above) that forced me to think of a lightweight CL library instead of an interpreter. Writing a CL quine (in the way I can do) requires a lot of : quoting CL terms in CL itself. But quoting CL cannot be done in CL (only : quoting-the-quotation-of-CL-further can be done in CL), so my CL quine plans needed a lot of work quoting CL terms by hand. A lightweight CL library could do this job by using the power of Haskell (quoting CL terms can be done in Haskell, or more generally said: in the ultimate implementating language of this CL-project).

The quotation stratification of subsequent series of meta- and object languages:

combinatory logic, its terms being represented by combinatory logic binary tree abstract datatype. We have already seen that we can define lists in combinatory logic by catamorhisms, so we can define binary trees too. And we can represent the base combinators by booleans which can be defined too in CL. So we can quote each CL term in CL itself.

Term2

...

Quoting:

Invoking:

-- Yet we do not require type safety in quotation stratification of CL terms:type Term1 = Term
type Term2 = Term
type Term3 = Term
-- ...
quote'0 :: Term1 -> Term2
quote'1_0 :: Term2 -> Term3
-- ...-- At or beyond the depth of quote'1-- these functions can be implemented in CL too-- more generally: everyhing can be made at a higher level too,-- but not vice versa. So everyhing has a grad-- We index things by this grad-- Ultimate implementing language (here:Haskell) is designed by grad 0-- Unavailable grad is designed by minus infinity-- (see the analogy of grad of polinomials)
quote'1 :: Term1
quote'2_1 :: Term1
quote'2 :: Term2

I think combinator can be thought of as something analogous to Dependent type:
it seems to me that the dependent type construct
of Epigram corresponds to
in Illative Combinatory Logic. I think e.g. the followings should correspond to each other:

My dream is making something in Illative Combinatory Logic. Maybe it could be theoretical base for a functional logic language?

9 References

[Bun:NatICL] Martin W. Bunder: The naturalness of Illative Combinatory Logic as a Basis for Mathematics, see in Dedicated to H.B.Curry on the occasion of his 80th birthday.