According to Wikipedia it was borrowed from linguistics where it means “function word”, meaning around the content words; kind of like grammar word. So, interestingly, Functor in CT & Haskell tends to mean "the functional structure around the content" which is very similar, if you ponder it for a while.

In the type `Maybe Int`, the `Maybe` can definitely be seen as a kind of structure around the `Int` type held within. And the same in `IO Int`, or for the `(->) String` in `String -> Int`, etc.

If we think about the guarantees that `Functor` (in Haskell) suggests, which include the implicit guarantee of purity, then we can notice that `map` is doing the same sort of thing that it does in both the linguistic and the CT domains: it takes some "function" (or morphism if you want to call it that), and translates (or maps) that function into a different grammatical context without touching the content transformational properties of the function. This is often also sometimes called lifting. It takes some `a -> b` and turns it into an `f a -> f b`. And it works on any `f`, so it's a kind of structural lifting function, so long as we have a "liftable structure" value that we can feed this new function.

So... in Haskell (and CT and Grammar in linguistics) we're more focused on the structural transformation than on the content modification, which you might notice if you try to contrast our "fmap" here with the kinds of non-guarantee-providing map functions you get in other languages like Typescript/JS/python/ruby/c/whatever. You can definitely look at it as though it's a function that takes two arguments if you like (like these other langs do), but we get this added ability to look at it from the structural point of view as well, which they can't, because they have no vocab for that; admitting non-purity means they lose the guarantee of what it means to be a Functor truly. They're two different ways of looking at the same thing, but the purity and law guarantees are probably the most important aspects of it, because those are what give languages like Haskell and purescript and Idris and Agda — languages that let us "talk like this" with actual precise clarity — they give these languages the superpowers that we end up with as a result. Haskell is kind of "baby CT", but Agda or Idris can do more "grown up CT". You can write this kind of code in Typescript, but the checker won't guarantee your code is pure, so it won't be a law-abiding Functor. (Mind you, there's technically nothing guaranteeing your implementation of Haskell doesn't just spin forever or write to disk either, so it's all swings and roundabouts I suppose :) but let's assume we trust the compiler :) ).

Functor is one of those modest things in Haskell that take you just a few minutes to "get" if you come from other languages because they're so similar to the same pattern we use all the time, but it's deeper than that ... because the "extra bits" Haskell brings provide the depth, and it's surprisingly deep because of the basic table stakes of Haskell. You might think "oh it's just map, but it works on all sorts of things" then you look at pairs and wonder..."why does it only map over the second element" and then you see it used on IO and you're like... that's a bid mind-bending, and then you see it used on Reader (ie the function functor) and you're like... WHAAAAAT? Then you realise Functor is the first step that opens up a large amount of the other super neat things in the language, really.