I've always wondered if there's more to FP than (more or less) point-free style with an associated algebra. TFA seems to stop just when it might get interesting. Did Backus ever develop (or aim for) a notion of semantic completeness, e.g. Cartesian closure or whatever works [0] for Hughes's Arrows? The last has the interesting property of being foundationally point-free but also supporting a syntax with variables (with non-standard scoping rules). Which perhaps refutes Backus's original concerns.
[...] At that time, John was interested in pure functional programming, with no side-effects on storage or the external world. I advocated extending the language to allow writing complete interactive applications. John conceded the importance of this, and came up with a scheme in which one would write a function to express the complete transformation of an application on the global state. I struggled with John’s variable free style, and suggested we allow lambda variables when defining a new functional form (higher-order function), but he stuck to his guns.
(In my project) I’ve reduced extensibility to the meta-composition rule, and I’m using an IO monad for interaction because I believe all functions should remain as simple as possible.
I have looked at the diagrams. If a side effect occurs between Program A and Program B, then referential transparency is violated. Referential transparency is the "sacred principle" of algebra; if it is violated, no algebraic transformation is possible—unless I am mistaken or we are talking about a monadic continuation.
Thanks very much; I in turn will add a link the Related Resources section. If you'd like to be recognized as other than metazip then let me know via email.
Comments
I've always wondered if there's more to FP than (more or less) point-free style with an associated algebra. TFA seems to stop just when it might get interesting. Did Backus ever develop (or aim for) a notion of semantic completeness, e.g. Cartesian closure or whatever works [0] for Hughes's Arrows? The last has the interesting property of being foundationally point-free but also supporting a syntax with variables (with non-standard scoping rules). Which perhaps refutes Backus's original concerns.
[0] https://en.wikipedia.org/wiki/Arrow_(computer_science)
Author here. This is work-in-progress, not linked from top level. I'll keep working.
Remembering John Backus:
(In my project) I’ve reduced extensibility to the meta-composition rule, and I’m using an IO monad for interaction because I believe all functions should remain as simple as possible.
Is this your project: https://github.com/metazip/pointfrip ?
I have looked at the diagrams. If a side effect occurs between Program A and Program B, then referential transparency is violated. Referential transparency is the "sacred principle" of algebra; if it is violated, no algebraic transformation is possible—unless I am mistaken or we are talking about a monadic continuation.
Can we move this conversation to email? I am not sure what diagrams you are referring to.
https://github.com/pointfreewiki/pointfreewiki.github.io/iss...
https://github.com/pointfreewiki/pointfreewiki.github.io/iss...
In that first diagram (https://softwarepreservation.computerhistory.org/FP/Composin...), A and B are supposed to be pure functional programs; side-effects are modeled by each one outputting a new version of each modified input. In the second diagram (https://softwarepreservation.computerhistory.org/FP/Strict_H...), as actually implemented in FL, they stick to strictly leftmost-innermost evaluation order so that side-effects are at consistent (but this presumably prevents parallel evaluation).
some Plasm files https://github.com/metazip/plasmfiles/blob/main/Function-Lev...
Yes, it started with https://esolangs.org/wiki/FP_trivia in Delphi, and the project using the Lazarus-IDE was Pointfrip.
Thanks for the extensive collection. Valuable work. I’ve included a reference to the link collection on https://github.com/function-level/function-level.github.io
Thanks very much; I in turn will add a link the Related Resources section. If you'd like to be recognized as other than metazip then let me know via email.
Videos to FL and FP: John Backus: Function Level Programming and the FL Language 1987 (https://www.youtube.com/watch?v=FxcT4vK01-w&t=15s), John Backus Group Meeting - IBM Research - 5 July 1989 (https://www.youtube.com/watch?v=KzBkb-bvNK4), Backus on functional programming (https://www.youtube.com/watch?v=OxuPZXXiwKk) from Original: Oral History of John Backus (https://www.youtube.com/watch?v=dDsWTyLEgbk)
The first video is the same as https://softwarepreservation.computerhistory.org/FP/#Backus1... .
I hadn't seen the Group Meeting video; I will add it (even though it's very rough).
I will change the entry for [Booch2007] to include the video as well as the transcript.
TFA contains a great number of links to downloadable interesting research papers.