5

I started with Haskell a few days ago and I found some solution for my problem online, but I started to notice that some function has a symbol at the end of the function name.

What is the meaning?

An example could be

map'            :: (a -> b) -> [a] -> [b]
map' f []       = []
map' f (x:xs)   = foldr (\y ys -> (f y):ys) [] xs

Source

HoRn
  • 1,458
  • 5
  • 20
  • 25
macros
  • 65
  • 8

2 Answers2

7

The ' is usually added to indicate that this is some variant of a function map. It's really just part of the name (it's a valid character).

In this example here map is already provided by Prelude so you'd have a name-conflict. So there is need for a different name and map' does the job without thinking too much.

Often ' indicates that the function is strict (for example foldl') too.

Random Dev
  • 51,810
  • 9
  • 92
  • 119
  • 2
    Thanks, so I can call this function as `map'`. thanks and sorry for the stupid question – macros Apr 22 '21 at 11:02
  • 3
    it's not a stupid question at all - some students associate this with some kind of derivative (especially students having a math background ;) ) - and most other languages don't allow the character for their identifiers so the confusion is very understandable – Random Dev Apr 22 '21 at 11:18
  • Yes agree, is a little bit different from the other language. Thanks to clarify this. – macros Apr 22 '21 at 11:37
5

The character ' can be added to any identifier in Haskell, so map' is an identifier. In this context, ' is also called "prime", so map' would be pronounciated "map prime" if you were to read it out loud.

The use stems from mathematics, where function variants (often their derivatives) have some kind of symbol attached to them, e.g.

Function Meaning
f Original function
f' Derivative of f
f'' Second derivative f
f* Some special variant of f (usually called "f star")
f̂ (f with ^) Some other special variant, usually the Fourier transform of f, called "f hat".

In Haskell, the prime usually indicates either a

  • strict variant (e.g. foldl'),
  • a custom implementation (e.g. map' in your own code, as it conflicts with Prelude.map),
  • a value derived from another one (e.g. x' = go x) or
  • an internal function (an implementation detail inside a library)

Especially the third variant can be found often in where or let clauses. Naming is hard after all, and a single prime allows you to both show the origin of the value and remove the need to come up with a better name:

-- | 'pow x n' calculates 'x' to the power of 'n'. 
--    It uses the double-and-add method internally
pow :: Int -> Int -> Int
pow x 0 = 1
pow x 1 = x
pow x n
  | even n    = x' * x'      -- usage of 'pow x (n/2)' here
  | otherwise = x' * x' * x  -- use of both x' and x
 where   
   x'    = pow x (n `div` 2) -- x' stems from the original x

Note that you may have arbitrary many ' in your identifier:

some'strange'example'don't'do'this :: Int
some'strange'example'don't'do'this = 12

foo'''''''''''''' = "please don't do this :)"

A single quote at the start of an identifier isn't allowed, as it would clash with a usual Char, though.

Zeta
  • 103,620
  • 13
  • 194
  • 236