> I am and forever will be a fan of the scheme (and now clojure) convention of saying foo->bar to say foo to bar. I just think that's swell.

In his book—Lisp in Small Pieces—Christian Quienec suggests using a reversed arrow (ie. bar<-foo) so the direction of the arrow agrees with the evaluation order in a function composition. eg. (foo<-bar (bar<-foo ...)), which would have otherwise been (bar->foo (foo->bar ...)).

In Clojure you're likely to use an arrow to do multiple compositions, eg. (-> foo foo->bar bar->baz)

> bar<-foo

Or bar_from_foo , when identifier charsets prohibit <- .

That's quite nice.

The CL convention would be to have a function called bar that converts whatever its argument into an instance of bar. Make it generic and new libraries can easily add their own conversions for their own data types.

My personal convention is to call such a generic function ->bar to make it clear that what it does is coerce its argument to a different type.

Actually I'm more of a fan of bar<-foo because you can line them up like:

    (bar<-foo (foo<-baz (baz<-quux thing)))

instead of:

    (foo->bar (baz->foo (quux->baz thing)))

But you can do composition, like this:

[Racket]

    (~> thing
        quux->baz
        baz->foo
        foo->bar)