# Factor on Win32

## Slava Pestov — 2004-12-11 20:14:49

    Hi everybody,

    Thanks to Mackenzie Straight (eiz on #concatenative), Factor now runs on

    32-bit Windows platforms. A few things are missing, such as asynchronous

    I/O, the compiler and the FFI, however these will come soon.

    You can download it and test it at

    http://factor.sf.net/factor-win32.zip. It will be part of the next

    release, of course, but that won't be out for a week or so yet.

    Feedback appreciated!

    Slava

## Mackenzie Straight — 2004-12-12 01:01:18

    This needs to be run like so: factor factor.image -no-ansi

    -no-compile. If you don't use the -no-compile switch, it will crash,

    and if you don't use -no-ansi, you'll get escape codes everywhere.

    There are some bugs, and the IO code is really slow (the plan is to

    rewrite the IO using FFI once the compiler is ported anyway, so it's

    not a priority).

     On Sat, 11 Dec 2004 15:14:49 -0500, Slava Pestov <slava@...> wrote:

    >  Hi everybody,

    >

    >  Thanks to Mackenzie Straight (eiz on #concatenative), Factor now runs on

    >  32-bit Windows platforms. A few things are missing, such as asynchronous

    >  I/O, the compiler and the FFI, however these will come soon.

    >

    >  You can download it and test it at

    >  http://factor.sf.net/factor-win32.zip. It will be part of the next

    >  release, of course, but that won't be out for a week or so yet.

    >

    >  Feedback appreciated!

    >

    >  Slava

    >

## phimvt@lurac.latrobe.edu.au — 2004-12-17 05:09:58

    Some months ago we discussed composition of functions

    other than unay functions. I said that it is a messy

    subject, because there are always so many different

    ways of doing it. In the meantime I found out that

    it is not as bad, and that there are indeed obvious

    and perfectly clean compositions of n-ary functions.

    For n=1 we have unary functions, the composition (f.g)

    of two unaries is defined thus:  (f.g)(x) = f(g(x))

    For n=2 we have binary functions, the composition of

    three binaries might be written as(f.(g h)) and defined

    thus:  (f.(g h))(x,y) = f(g(x,y),h(x,y))

    In general, any (positive n), the composition of (n+1)

    n-ary functions would be defined as

           (f.(g1 g2 .. gn))(x1,x2..xn) =

              f(g1(x1,x2..xn),g2(x1,x2..xn)..gn(x1,x2..xn))

    This is just a special case of what in recursive function

    theory is function composition, specialised to the case

    where the colleccting f function has the same number as

    arguments as each of the g functions.

    It would be of some interest to see whether in the simplest

    case for n > 1, the binary case, there is a language waiting

    to be invented. The x and y would presumably be complex

    structures (stacks?), and the notation might well be the

    reverse of what I used above.

    Food for thought? Well, maybe a bellyache. Sorry.

      - Manfred

## phimvt@lurac.latrobe.edu.au — 2004-12-17 05:40:30

    For quite some time I have been trying to give a definition

    of what it means for a language to be concatenative,but I have

    not been able to come up with anything really right.

    We have been using the term "concatenative" with some mutual

    understanding, just as many kinds of specialising terms in

    all sorts of fields are understood by the practitioners. In

    computer science we have "high/low level", "procedural",

    "object oriented" and many others. Often one has to be satisfied

    with a broad understanding, but a rigorous definition is

    often preferred. Can we give one for "concatenative"?

    Of  course what one wants is a definition that covers those

    cases that are agreed upon, and excludes others. So the

    definition should be neither too narrow (exclude too much)

    nor too wide (include too much). Any offers?

    I take it that the definition should leave various matters

    as irrelevant:

    1. the exact style in which definitions/declarations

       are written,

          DEFINE f == body     or   "body" f define  or similar

       But what makes a language concatenative is the style

       of bodies.

    2. Whether concatenation is written with or without an infix

       operator:

           pop; dup    or    pop dup

    3. What datatypes it has, whether it is compiled or interpreted,

       whether it uses linked lists or consecutive allocation, and so on.

       Probably the definition should leave it open whether the

       implementation uses a stack of some kind, or even whether

       conceptually the language operates on a stack.

    So, here is something to dwell on in the many idle moments that

    I hope you are able to have during the Christmas break. And also

    my best wishes for the new year.

      - Manfred

## sa@dfa.com — 2004-12-17 13:29:14

    http://www.vector.org.uk/index.php?area=kei

    essays on ken by friends and colleagues over the years, which might

    prove interesting to members of the concatenative community.