HN Explorer

15 comments

[ 2.9 ms ] story [ 44.3 ms ] thread
uncletaco
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
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
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
> 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
In Clojure you're likely to use an arrow to do multiple compositions, eg. (-> foo foo->bar bar->baz)
mncharity
> bar<-foo

Or bar_from_foo , when identifier charsets prohibit <- .

nemoniac
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
But you can do composition, like this:

[Racket]

    (~> thing
        quux->baz
        baz->foo
        foo->bar)
wibblewobble124
Scheme also abbreviates:

call-with-current-continuation

To

call/cc

The forward slash serving the purpose of “with”.

djhaskin987
As I've been slowly learning Common Lisp, I'm fascinated by how much Rich Hickey took from the CL community in making Clojure. For example, the names in embedded languages starting with `?`. He uses this naming convention all the time in the datomic docs[1] showing how to query the database.

1: https://docs.datomic.com/on-prem/query/query.html

lispm
See for example the Prolog implementation in PAIP:

https://github.com/norvig/paip-lisp/blob/main/docs/chapter11...

But I would think the convention is quite a bit older than Common Lisp and earlier Lisp programs should have used something like that to notate variables in special sublanguages (especially in simple Prolog variants or in Rule-based systems).

nulbyte
> These will annoy people: ... hungarian-identifiers-pcsnsi

What does this mean? I have no idea what pcsnsi is, or why this is "Hungarian."

Jtsummers
It's a reference to Hungarian notation which had two forms, systems and apps. Systems notation would prefix variables with their primitive type:

  long lTime;
  bool bPrint;
Apps notation would prefix variables with something conveying a domain-specific semantic element:

  point ptPlayer;
You aren't supposed to know what pcsnsi means because it is just a nonsense string here, but presumably has some potential apps notation meaning if used in the real world.

https://en.wikipedia.org/wiki/Hungarian_notation

gibsonf1
For predicates, I’ve abandoned the p postfix as it’s then so hard to know which predicates you have. Instead we now use the ? as a prefix to any Boolean predicate, so in the repl you can just type ? Hit tab and see all available predicates.