Functional programming, APL and UNIX pipes

http://porg.es/blog/functional-programming-apl-and-unix-pipes

by philh • 16 years ago

32 22 16 years ago

jacquesm4• 16 years ago

I noticed the parallel between pipes and functions only a few weeks ago and it struck me that if you re-write lisp expressions left to right instead of 'inside out' I can suddenly understand much better what is going on.

so if I look at f(b(c(d(e))))) it is the same as 'cat e | d | c | b | f'

Where 'e' is the initial input data and the other letters are the functions transforming e in successive steps to the desired output.

The analogy probably breaks down pretty quickly, but for simple examples it seems to hold.

Is there a programming language that works in this left-to-right pipelined fashion?

mcav2• 16 years ago

In clojure, there's the thrush operators: -> and ->>

  user=> (->> 10 (+ 2) (* 5))
  60
  user=> (* 5 (+ 2 10))
  60

http://debasishg.blogspot.com/2010/04/thrush-in-clojure.html

jacquesm4• 16 years ago

That's exactly it!

Neat, never knew that was in there. I really should do more reading before diving in to using something. Bad habit.

It would be nice to see two fair sized chunks of code side by side, one in each style and then to ask a panel of programmers which is the more readable of the two.

I'm beginning to slowly 'grok' functional code, I can read it a bit easier now than two months ago (exposure), but I still feel like with olives that it is an acquired taste.

I hope I'll grow over that, it definitely doesn't feel natural yet, and it takes me much longer to understand a piece of functional code than it does when I look at 'imperative' code.

RiderOfGiraffes• 16 years ago

I recently asked here about an intermediate language to use for compiling a domain specific language I use.

http://news.ycombinator.com/item?id=1361382

The language I'm compiling does this, but with non-linear "pipe" systems. It's a bizarre mongrel of functional, dataflow, OO and declarative (as per Prolog), and revisits Alan Kay's idea that OO is about the messages, not the objects. On steroids.

It uses the left to right version, so function application is (args).(func) although that's not the syntax. In particular, using Lisp-like notation, addition is written similarly to (3 4 +) where 3 is sent to the tail of the list. the tail of the list is 4 sent to +, which creates a function that adds 4 to its argument. Thus (4 +) is a function in its own right.

There are interesting parallels with continuations and the like, but we've found some problems with the underlying theoretical basis and are re-working some of the ideas.

Of course it's probably isomorphic to an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp, but there you go.

dkersten4• 16 years ago

Yes, concatenative languages. Check out Factor[1] or Forth[2], for example.

[1] http://www.factorcode.org/

[2] http://thinking-forth.sourceforge.net/

jacquesm4• 16 years ago

Funny you should mention forth, I never even thought of forth that way (I did some forth long ago), but I can see the parallel, with the stack being the 'intermediate' that gets passed from function to function.

Never heard of 'factor' yet, I'll have a look at it.

Thanks!

sea6ear2• 16 years ago

I've played with using Factor in this fashion.

I went so far as defining | as a noop (I think it was SYNTAX: | ; )

That way I could do stuff like [1, 3, 4] | first | dup

gruseom2• 16 years ago

This idea is one of those perennials that makes for interesting discussion yet hasn't been done much with. It's come up on HN a few times (I remember touching on it here: http://news.ycombinator.com/item?id=236704). The closest thing to it that I've seen get widely adopted is the "fluent interface" or "chaining" style that has caught on in OO over the last few years; particularly, from what I've seen, in Java and JS.

The APL/J/K languages are built around a construct very similar to this, so the OP's reference to APL is apt. You really should check out J or K if you haven't yet. J comes with a marvelous set of tutorials. K comes with nothing. :)

(But K is a work of genius, in my opinion. A pinnacle.)

barrkel• 16 years ago

The monadic chaining style of LINQ from the .NET world is also relevant; it's even more pipe-like, in that it's creating a pipeline, rather than modifying the data en masse, one step at a time.

DannoHung• 16 years ago

It's pleasant enough for doing computations, but if your C/C++ is not up to snuff, you will find yourself very frustrated trying to integrate it into an existing ecosystem. Additionally, there are some REALLY annoying things you face due to the single threaded nature of the language if you're doing real time systems.

But if you go and learn K or Q and you've got good C chops, you can absolutely get a job in Manhattan or Chicago (must be willing to work long hours with little support, build almost all of your own tools, and handle the constant pressure of making everything work perfectly the first time).

yummyfajitas2• 16 years ago

Haskell does. Roughly the author's example using monads:

   [[10..20], [50..100]] >>= id >>= classify

The only thing you can't directly do with monads is the fold, since the fold breaks you out of the monad. Also, you could use arrows:

   myCounter = ( concat >>> (map classify) >>> (foldr getCounts (0,0,0)) )

Then myCounter [ [10..20], [50..60]] is the function you want.

yummyfajitas2• 16 years ago

Actually, just realized you can do everything with monads.

    (return [[10..20], [50..100]] >>= concat >>= classify >>= foldr getCount (0,0,0))

Just use the identity monad rather than the list monad.

elblanco• 16 years ago

In actuality, the pipe-style programming paradigm is like a data flow language. Similar to LabView (https://www.ni.com/labview/) or XEE (http://www.futurepointsystems.com/?page=products).

Output from one becomes the input to another component. Most takes on it that I've seen (like the two above) slap a graphical interface on top for flexibility.

dagheti• 16 years ago

The pipe operator in F# |> is used in this way. When combined with currying it is especially effective:

  let double_then_sum a_list =
      a_list
      |> List.map  ((*) 2)
      |> List.fold (+) 0

sea6ear2• 16 years ago

Method chaining in a fairly pure OO language (Ruby or Smalltalk or similar) can work like this. (where all operations are methods on objects rather than being functions in their own namespaces/utility classes)

In this case the "." is functioning sort of like the pipe.

something like [1, 2, 3].first().add(2)

Functional programming, APL and UNIX pipes

Related Stories