Higher-order Shell | Hacker News Reader

Higher-order Shell

conway.rutgers.edu

58 pointsr11t13 comments

Zsh already has the first program built-in using the = expansion. For his example it would be:

  xdvi =(curl http://www.diku.dk/~andrzej/papers/RC.dvi)

Yet another reason why you should switch to zsh today :)

More about expansions in zsh: http://zsh.sourceforge.net/Doc/Release/zsh_13.html

Tom Duff's rc shell has the same construct

    xdvi <{curl http://www.diku.dk/~andrzej/papers/RC.dvi}

Another reason why you should have changed to rc shell 10 years ago

http://doc.cat-v.org/plan_9/4th_edition/papers/rc

I like the attempt to use Haskell type signatures as terse documentation. For 'tmp' it pretty nearly tells the whole story (especially rewritten flipping the first two arguments as below)

  tmp :: (FilePath -> IO ()) -> (Stream -> IO ())
  Transforms file-accepting function to work on an input stream.

'keep' is a bit more ambiguous, but I think it's more clear if you write it instead as

  keep :: IO a -> IO [()]

which has parallels to 'repeat :: a -> [a]' and suggests that the first action will be "kept" and repeated periodically, throwing away the output. At this point, you have to guess when it repeats, but since you provide 'keep' no further information, blocking until files update is a pretty logical guess.

I got the suspicion that Haskell notation was used because he'd written those commands in Haskell; could be wrong though.

They're written in Perl. Take a look at the sources:

tmp: http://conway.rutgers.edu/~ccshan/wiki/blog/posts/Higher-ord...

keep: http://conway.rutgers.edu/~ccshan/wiki/blog/posts/Higher-ord...

No, I thought so at first as well, but later realized that he was doing it totally for documentation's purposes (well, and impact).

I don't think some of the things he writes, like "MonadIO m => m () -> IO ()" are generally possible, for example. There are specific instances of MonadIO (ErrorT, etc.) that have a function that does that, but MonadIO itself only has the liftIO function, which is "MonadIO m => IO a -> m a".

Good call. I agree in disagreeing with his type for 'keep'. I think he was aiming at the idea of "any computation which is liftable to an IO computation" instead of "computation which can be evaluated within an IO context".

In my opinion, since 'keep' takes a function which is, in general, fully capable of any effectful action, it necessarily is of the type

  keep :: IO a -> ...

but since it's roughly ignoring any potential return 'a', yet still evaluating the function repeatedly, the best type is something like

  keep :: IO a -> IO [()]

I think he actually meant "MonadIO m => m a -> m a".

Anyway, if I were going to use Haskell-style type signatures in an article about shell scripts written in Perl, I would probably skip the whole typeclass and monad concept, and just say something like:

   keep :: Action -> Action

This doesn't say much about the infinite nature of the process, unfortunately, but modeling effects as though they are pure functions just gets you into trouble anyway. His textual description is much more natural and easier to understand.

Anyway, I like articles that combine both Perl and Haskell :) They make me feel less insane.

while not helpful for his examples, some programs that don't grok "-" as a shortcut to read data from stdin (or a pipe) are ok being passed "/dev/stdin" as the filename.

or /fd/0 or /dev/fd/0 (depending on OS)

"Surely I was not the first to write the following two higher-order programs..."

He's right. There is, for example, rc (the Plan 9 shell, made in 1989).

The following is from section 10, "Pipeline branching" of: http://plan9.bell-labs.com/sys/doc/rc.html

"< or > followed by a command in braces causes the command to be run with its standard output or input attached to a pipe. The parent command (cmp in the example) is started with the other end of the pipe attached to some file descriptor or other, and with an argument that will connect to the pipe when opened (e.g., /dev/fd/6)."

I believe the rc feature exemplified in the link is actually equivalent to that used in the this bash idiom:

$ cmp <(old) <(new)

(only the braces differ). The author of the article describes a case in which the command in question (unlike cmp) cannot read its input from a pipe such as this, namely xdvi. So for instance

$ cat file.dvi | xdvi

$ xdvi <(file.dvi)

would not work due to the nature of xdvi, but one could use

$ cat file.dvi | tmp xdvi

as a shorthand for

$ cat file.dvi > /tmp/blah $ xdvi /tmp/blah $ rm /tmp/blah

(of course using cat this way would be stupid, but suppose that the file data is going to stdout via a command such as curl, as in the article, and it becomes non-trivial).

I really like the characterization of these commands as sort of second-order and I like the 2 new ones offered here (although I try not to get too addicted to command line features that aren't going to be around when I'm hopping from server to server).

Reply on news.ycombinator.com