# request

## stevan apter — 2004-09-10 23:31:51

    a concatenative programming language is one in which

    concatenation denotes the composition of functions.

    in XY, the elements of the language are binary functions,

    each of which takes the result stack and the input queue

    and returns a new result stack and a new input queue.

    XY does not have an application operator.  concatenation

    denotes the composition of *binary* functions.

    or does it?

    before i immerse myself (again) in manfred's paper on

    the mathematical foundations of joy,

    http://www.latrobe.edu.au/philosophy/phimvt/joy/j02maf.html

    in order to convince myself that i haven't uttered nonsense

    by making the claim that XY is concatenative, can someone

    opine on whether this is or is not the case?

    a further thought occurs to me:  is it better -- more

    accurate -- to say that the elements of XY denote *unary*

    functions of the pair (stack;queue), and return pairs

    of the form (stack';queue')?

## phimvt@lurac.latrobe.edu.au — 2004-09-17 04:10:41

    On Fri, 10 Sep 2004, stevan apter wrote:

     > a concatenative programming language is one in which

    > concatenation denotes the composition of functions.

    >

    > in XY, the elements of the language are binary functions,

    > each of which takes the result stack and the input queue

    > and returns a new result stack and a new input queue.

    >

    > XY does not have an application operator.  concatenation

    > denotes the composition of *binary* functions.

    >

    > or does it?

     The way I understand common usage is this: an n-ary function

    consumes n arguments and produces one result. Thus the addition

    function on number takes two numbers and produces one number.

    In ((a + b) + (c + d)) a total of four numbers are consumed

    and one result number is produced. Composition is normally

    defined only for unary functions - if you try to list the

    many possibilities for binary functions ( or n-ary in general),

    you would see why. For any function the arguments and the result

    can of course be arbitrarily complex (they can be records,

    or "structs" in C lingo). So your functions are unary functions

    which take pairs as argument and value. See your own remark

    below.

    [..]

     >

    > a further thought occurs to me:  is it better -- more

    > accurate -- to say that the elements of XY denote *unary*

    > functions of the pair (stack;queue), and return pairs

    > of the form (stack';queue')?

     Exactly right.

      - Manfred

## sa@dfa.com — 2004-09-17 14:18:45

    thanks - that helps as i try to prepare my contribution

    to the collection you're compiling.  unfortunately, it's

    slow going, since the implementation hasn't quite settled

    down (e.g. this morning i discovered how to derive a

    pair of functions which i had assumed must be primitive.)

    with any luck, i'll have a draft ready some time this

    weekend.

    phimvt@... wrote on 09/17/2004 12:10:41 AM:

     >

    > On Fri, 10 Sep 2004, stevan apter wrote:

    >

    > > a concatenative programming language is one in which

    > > concatenation denotes the composition of functions.

    > >

    > > in XY, the elements of the language are binary functions,

    > > each of which takes the result stack and the input queue

    > > and returns a new result stack and a new input queue.

    > >

    > > XY does not have an application operator.  concatenation

    > > denotes the composition of *binary* functions.

    > >

    > > or does it?

    >

    > The way I understand common usage is this: an n-ary function

    > consumes n arguments and produces one result. Thus the addition

    > function on number takes two numbers and produces one number.

    > In ((a + b) + (c + d)) a total of four numbers are consumed

    > and one result number is produced. Composition is normally

    > defined only for unary functions - if you try to list the

    > many possibilities for binary functions ( or n-ary in general),

    > you would see why. For any function the arguments and the result

    > can of course be arbitrarily complex (they can be records,

    > or "structs" in C lingo). So your functions are unary functions

    > which take pairs as argument and value. See your own remark

    > below.

    >

    > [..]

    > >

    > > a further thought occurs to me:  is it better -- more

    > > accurate -- to say that the elements of XY denote *unary*

    > > functions of the pair (stack;queue), and return pairs

    > > of the form (stack';queue')?

    >

    > Exactly right.

    >

    >   - Manfred

    >

    >

    >

    >

    >

    >

    > Yahoo! Groups Links

    >

    >

    >

    >

    >