[semigroupoid]

The definition of functor in category theory is from 1945 while most of today's mainstream programming languages are much younger than that. The people who wrote those definitions for C++, C#... simply ignored the existing terminology.

[AnimalMuppet]

Fair enough. And yet, at the time (and even today, outside of the FP crowd), category theory is really far outside the scope of what most people consider programming, so it's hard to blame them for not looking there for terms.

For that matter, category theory borrowed the word from linguistics, and most definitely did not keep the same meaning.

[sordina]

I certainly wouldn't blame anyone for not being familiar with the terms. What I would blame people for is attacking Haskell's choice of terminology due to it not 'being like c++'. A generous interpretation of intent goes a long way, and if that is out of reach, at least do enough research to make sure you're not pointing out weaknesses based on a false premiss. Instead I commonly see people starting from "I don't find Haskell intuitive" and extrapolating to "Haskell's contributors are indoctrinated and people who defend its use of established terminology are arrogant". Maybe I should just ignore such points of view but they seem to be infectious.

[AnimalMuppet]

Well, let me see if I can meet you partway. Haskell is grounded in abstract algebra and category theory; using words like functor to mean what they mean in category theory is therefore a reasonable choice for Haskell.

But Haskell is a programming language. Using words like functor to mean something different from what other programming languages mean by the term creates a barrier to understanding for (non-FP) programmers. (The other definition is rather well established in non-FP circles, which is by far the majority of programming.) And when Haskell proponents state that their definition is right because it's the one from category theory, non-FP programmers find that rather arrogant.

[sordina]

According to http://en.wikipedia.org/wiki/Function_object, many languages implement the "Function Object" pattern:

  * C
  * C++
  * C#
  * D
  * Eiffel
  * Java
  * JavaScript
  * Lisp
  * Scheme
  * Objective-C
  * Perl
  * PHP
  * PowerShell
  * Python
  * Ruby

Although many of the languages listed here implement the pattern, it's not clear that many of them use the "Functor" terminology. I've certainly never heard of it referred to as such in Javascript or Ruby, and most-often referred to as "Callable" in Java.

That being said, I think anyone would agree that terminology choices in Haskell can only fairly be accused of ignoring PL parlance that was in existence before the terms were adopted in Haskell...

With that being said, the "Functor" terminology timeline:

  ~ 1942 - Category Theory - http://en.wikipedia.org/wiki/Category_theory
  < 1991 - Haskell         - Notions of computation and monads (Moggi)
  > 1994 - C++ STL         - http://en.wikipedia.org/wiki/Standard_Template_Library
  > 1995 - Gang of Four    - http://en.wikipedia.org/wiki/Design_Patterns
  > 2000 - C#              - http://en.wikipedia.org/wiki/C_Sharp_(programming_language)
  > 2004 - Java Generics   - http://en.wikipedia.org/wiki/Java_version_history

(correct me if I'm wrong here)

Now clearly we can't accuse Moggi of arrogantly ignoring existing PL terminology, because it didn't exist at the time. So, should we then say that Haskell users should have abandoned the term once it started being used differently?... This seems unfair too, as it was already in use in the Haskell ecosystem by then. I really can't accept that Haskell users are arrogant simply for using a term they adopted very early on consistently and in line with its original definition. Maybe they are arrogant, but certainly not for that reason.

So maybe they are arrogant because they don't play well with others? How do they react to other people using the term in a different fashion? I have never seen a Haskell user complain about someone calling a C++ function-object a functor. Maybe it has happened, but I just don't see it coming up very often.

> And when Haskell proponents state that their definition is right because it's the one from category theory, non-FP programmers find that rather arrogant.

I've never seen a Haskell user bust up a conversation and chastise a bunch of C++ users for talking amongst themselves about function-object "Functors". That would be arrogant, but does that ever happen? Why would they do that? The only time I can see Haskell users forcing definitions down people's throat is in situations like this, where they are being berated for using their own terminology and decide to set the record straight. That being said, who's forcing? The replies could really only be accused of being informative.

What do you suggest Haskell users should do? Stop calling functors functors? Sheepishly demure and say "okay you're right, we're wrong" when someone says that functors are how C++ does them?

Really I couldn't care less about the terminology point as I don't believe it has ever caused any significant issues in terms of ambiguity. And I'd be surprised if anyone earnestly attempting to learn Haskell was slowed down because of these terms (slowed down more than if Haskell invented totally new terms). The only reason why I'm getting worked up is because of the "arrogant" label.

Now how did this thread of conversation start?

  > I really like the author's suggestion of
  > mentally translating Functor to Mappable.
  > Are there any other synonyms for other Haskell terms of art?
  > ...
  > What I'd really like, I suppose, is a complete overhaul of Haskell syntax

  >> As others pointed out, the way Haskell uses
  >> the term "functor" is related to the way mathematicians
  >> had been using it for at least a decade before cfront.

Is that arrogant? Surely it's more arrogant to come in as a beginner of a language and suggest that it change its terminology without attempting to understand why it uses it? Still, none of the Haskell users here accused david-given of being arrogant, they simply informed him of the provenance of the term. Because we love to help.

I guess I just wished that people would make sure that they are at least justified when using inflammatory language.

Sorry about the rant.

[AnimalMuppet]

I was at that same Wikipedia article, but I got there from the "Functor" disambiguation page. I assumed that "function object" was a synonym for "functor" within the context of those listed languages. Perhaps that assumption was wrong on my part...

Your point about chronology is noted. I have no rebuttal.

> What do you suggest Haskell users should do? Stop calling functors functors? Sheepishly demure and say "okay you're right, we're wrong" when someone says that functors are how C++ does them?

Stop saying "we're right, you're wrong" when someone says functors are how C++ does them. Accept that C++, C#, Java, and the Gang of Four can use the term to mean what they mean without them being wrong. Ideally, recognize that, within the wider world of programming, the FP use of the term is the minority, and so some effort at translation to the majority terms may be appropriate.

That said, I'm well aware that I'm talking to the wrong person. Comments of the type that I'm complaining about occur on HN, but I don't think they come from you.

The only quarrel I could pick with what you said was your original comment, when you faulted C++ for not adapting the term from category theory. I had my timeline wrong in my first reply to you, but I still think that, since the roots of C++ are very far from category theory, expecting it to go there to find its terminology is a bit unfair.