A Programming Idiom You've Never Heard Of

Mathematicians call it conjugation, and it can be usefully thought of as a temporary change of coordinates or change in vantage point. Problems often become simpler, even trivial, when working in the right coordinates.

In practical programming, it is commonplace that the "inverse" that occurs in conjugation idioms is a genuine right-inverse but only partially a left-inverse. This is true for his example of squares and square roots. For another instance, consider

    reverseWords = unwords . reverse . words

    normalizeWhitespace = unwords . words

That's cool and all, but the effect on reverseWords is that it normalizes interword whitespace in the process of reversing words, whether you like it or not.

Incidentally, it's not too hard to abstract out this pattern with invertible functions:

    data Invertible a b = Invertible (a -> b) (b -> a)

    invertible = Invertible
    apply (Invertible f f') = f
    unapply (Invertible f f') = f'
    inverse (Invertible f f') = Invertible f' f
    compose (Invertible f f') (Invertible g g') = Invertible (f . g) (g' . f')
    conjugate i f = unapply i . f . apply i
    on = flip conjugate

    import Data.String as S
    words = invertible S.words S.unwords

    reverseWords = reverse `on` words

instead of

  f = open "test.txt"
  print f.read
  f.close

  open "text.txt" do |f|
    print f.read
  end

I believe Python also added something similar via the 'with' syntax. Not sure about other languages.

It sure makes it easy to be sure you're closing your file handles/database connections/mutexes, though.

Any time you have an element, y, of a group, the action of pre-composing with any other element, x, and post-composing with x's inverse to get xyx^{-1} is called conjugating, and the result is a called a conjugate of y.

http://en.wikipedia.org/wiki/Conjugation_(group_theory)

Given the jmp-iness of exception handling in C++, this is the recommended (i.e. the only safe) way to clean up after yourself.

How about a computer architecture where every instruction has an inverse, and therefore all functions and even programs are invertible? (Quantum computing, for example.)

http://en.wikipedia.org/wiki/Reversible_computing

"Go's defer statement schedules a function call (the deferred function) to be run immediately before the function executing the defer returns. It's an unusual but effective way to deal with situations such as resources that must be released regardless of which path a function takes to return. The canonical examples are unlocking a mutex or closing a file." http://golang.org/doc/effective_go.html#defer

http://www.cis.upenn.edu/~bcpierce/papers/lenses-etapsslides...

e.g. read a file, parse it into an AST, modify AST (i.e. rename a variable), unparse the new AST, close the file.

Set origin draw Reset Origin

is

    (let ((origin (move 50 50)))
      (draw something))

    (defmethod draw :before () (move 50 50))

    (defmethod draw () (draw-something))

    (defmethod draw :after () (move -50 -50))

When you need to wrap up a common block of code, you use a function. This lets you call the same block in a number of different contexts. When you need to fix the context in place and let the block in the middle vary, you write a function that takes another function as a parameter. An example in JavaScript (might be a little off):

    var withFile = function (path, action) {
        var f;
        try {
            f = File.open(path);
            action(f);
        } finally {
            File.close(f);
        }
    };
    
    withFile('foo.txt', function (f) { ... });

    var context = function (prolog, epilog) {
        return function (action, ...args) {
            var o;
            try {
                o = prolog.apply(args);
                action(o);
            } finally {
                epilog(o);
            }
        };
    };
    
    var withFile = context(File.open, File.close);

(Other comments have mentioned the author conflates context management with applying reversible functions. I've only dealt with one of those things here, but similar techniques apply in solving both problems.)

Context managers in Python:

  with fly('Seattle'):
      see_sights()

  with cd('/to/path'):
      do_stuff()

However you can use the ``contextlib`` module to make really simple ``contextmanger``'s with the yield statement

e.g.:

    from contextlib import contextmanager
    
    @contextmanager
    def glcontext():
      glBegin()
      yield
      glEnd()
  

The first is amply covered by the RAII/unwind-protect etc idioms than most languages do have.

The second is not, as most programming languages don't have the concept. The closest I can think of is the ability to use a predicate in either direction in Prolog (or logical programming in general)

Unfortunately, I don't think he found it particularly useful and gave up on it after the hackathon. Still, it was a cool project.

    using (var file = File.Open("foo.txt"))
    {
        ...
    }

(with-open-file (output "foo.txt" :direction :output :if-exists :supersede) (print-foo output))

    twixt (expression1, expression2)
           statement1

For (stupid) example:

    def reverse(x) as inversible with(reverse): #special case - reverse is itself inverse function
        x = x.reversed() #I'm too lazy to code this by hand

    def lastFive(x) as pure: #let's say language checks if pure function only uses pure and inversable functions
        return x[:5] under reverse

This assumes everybody sticks to one definition of reversing something, in this case functions f and g are inverse of each other, when after invoking f(x), doing only pure or reversable things to x, and invoking g(x), x is unchanged.

And I don't know if this will be useful for anything - the only point seems to be avoiding making copies and still making pure functions. But resulting code, while semanticaly pure, is not threadsafe. So I don't know if it's worth anything.

For instance, when we have x+y=z and know only x and z, we need to reverse the equation to have y=z-x. The system was built on nodes which would propagate change (a-la events).

IMO, python's with statement with __enter__ and __exit__ looks mostly like this.

Make the headline informative instead, if you have great content people will read and share it anyway.

Better version of this headline:

XXXX: A programming idiom that helps you do YYYY

CL and Clojure could easily support a generic with macro requiring that there be an open and close method for the resource in question.

Typically this idiom is the function call itself. The act of sipping coffee is the point of the function, and picking up the cup and putting the cup back down are the whole point of the function call.

I was never convinced this was a great idiom. BETA didn't become very popular, in any event.

During my dark past as a VB programmer (early-mid 90's) I even indented the code for pairs like this.

File.open(name, mode) receives a block, executes it, and then closes the file.