What are hashes (#) used for in the library's source?

Question

I was trying to figure out how mVars work, and I came across this bit of code:

-- |Create an 'MVar' which is initially empty.
newEmptyMVar  :: IO (MVar a)
newEmptyMVar = IO $ \ s# ->
    case newMVar# s# of
         (# s2#, svar# #) -> (# s2#, MVar svar# #)

Besides being confusingly mutually recursive with newMVar, it's also littered with hashs (#).

Between the two, I can't figure out how it works. I know that this is basically just a pseudo-constructor for mVar, but the rest of the module (most of the library actually) contains them, and I can't find anything on them. Googling "Haskell hashs" didn't yield anything relevant.

Answer 1

They're (literally) magic hashes. They distinguish GHC's primitive's like addition, unboxed types, and unboxed tuples. You can enable writing them with

{-# LANGUAGE MagicHash #-}

Now you can import the stubs that let you use them with

import GHC.Exts

unboxed :: Int# -> Int# -> Int#
unboxed a# b# = a# +# b#

boxed :: Int -> Int -> Int
boxed (I# a#) (I# b#) = I# (unboxed a# b#)

This actually is kinda nifty when you think about it, by wrapping the magical and strict primitives like this, we can handle lazy Ints and Chars uniformly at the runtime system level.

Because primitives are not boxed, they're segregated at the kind level. This means that Int# doesn't have the kind * like normal types, which also means something like

kindClash :: Int# -> Int#
kindClash = id -- id expects boxed types

Won't compile.

To further elaborate on your code, newMVar includes a call to a compiler primitive in GHC to allocate a new mutable variable. It's not mutually recursive so much as a thin wrapper over a compiler call. There's also some darkness gathering at the corners of this function since we're treating IO as a perverse state monad, but let's not look to closely at that. I like my sanity too much.

I don't use primitives in everyday code, nor should you. They come up when implementing crazy optimized hotspots, or near primitive abstractions like what you're looking at.