4 ms·

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.

• ruricolist 4y ago
  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.
  • lisper 4y ago
    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.
• vats 4y ago
  > 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 ...)).
  • nlitened 4y ago
    In Clojure you're likely to use an arrow to do multiple compositions, eg. (-> foo foo->bar bar->baz)
  • dunefox 4y ago
    That's quite nice.
  • mncharity 4y ago
    > bar<-foo Or bar_from_foo , when identifier charsets prohibit <- .
• nemoniac 4y ago
  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)))
  • narimiran 4y ago
    But you can do composition, like this: [Racket] (~> thing quux->baz baz->foo foo->bar)