Actual programs written in FP or FL?

I've become enamored with Backus's FP language (and the lesser known follow-up FL) as of late. Does anyone know of *any* programs written in either of these languages that are outside the 1-3 line toy variety? I've found nothing. Even 10+ line toy programs would be fine, but a larger program would be even better.

(For programs in a related style there's Iverson's J, but I'd still like to see some real FP programs.)

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

I wrote some longer toy progr

I wrote some longer toy programs for my own FP implementation long ago. But it's unreleased, I'm not sure where I put it, and the syntax was different from Backus's FP. (Notably, function composition was written like "f1 f2" instead of "f2 o f1".)

Maybe you could track down IFP (Illinois FP), which might come with examples. They messed with the syntax, too, to look more Algolish.

Illinois FP

I remember playing with IFP almost 15 years ago and really liking it. Unfortunately I haven’t been able to find a distribution of it online. If anyone knows of where I can find this, I would appreciate it if they would let me know.

Illinois FP source

I found the source here. I haven't tried compiling it yet, but it has an interesting collection of sample programs.

http://www.isc.org/index.pl?/sources/devel/lang/ifp.php

PLaSM

PLaSM is an FL dialect described as a "functional language for computing with geometry" (previously mentioned). The PLaSM site has some source code on the libraries page. There are also some examples if you download the system sources (although I haven't actually tried to build the system to test them out). Sadly, I've had no luck finding more than a few scattered papers about FL itself.

at least there is an interpreter to play with

I believe there aren't any ``real FP programs'' around at all, because FP was never a ``real'' language. I myself remember having some good time, around 1998, playing with an implementation of FP written by Andy Valencia. The interpreter is still alive somewhere in the net. There are some really small example programs accompanying it, but you can write your own ones. Plus, you can play with the implementation itself, if you are so inclined.

google is amazing...

I found this after a couple of minutes of googleing: (long url here). It's a c implementation, but the programs that it comes with as examples look like they may be what you are looking for. Look at the discrete fourier transforms example - it's a bit more than 3 lines ;)

Obviously I googled for it

and I found a few interpreters. I didn't realize that one of those interpreters came with an example of more than a few lines. That's great! But it's still quite sparse as far as fp programs go, especially considering the excitement that fp generated.

nothing to be surprised of

J. Backus did not invent FP as a programming language per se, and FP's limitations are well known. That there aren't really many programs written in FP is perhaps due to the fact that “the excitement that fp generated” took the form of creating other, complete with features, really usable functional languages that support the combinatorial (purely applicative) style of programming exemplified by FP.

fp-interpreter as hobby

in some free hours in week i work on a fp-interpreter (fpstefan.de or fpsolo.de) and i wrote some example programs. it is in german language. the interpreter uses infix notation for compose, constant or add.

Furry Paws

There's Furry Paws, an FP compiler written in FP:

http://www.call-with-current-continuation.org/fp/