Recommend Next Note Purchase
Order of arguments

As a convention, arguments in functions are always ordered from most likely to change to less likely to change.

Because this allows...

Simplification (Currying)

Haskell is like Math. 

Look at 

2x + x = 1 + x


You would like the simplify the x, so:

2x = 1


The same applies to your code:

percentize inList = map (/ sum inList) inList


You can omit inList as it is just repeated on both sides:

count x inList =  length $ filter (x==) inList


Becomes:

count x = length . filter (x==)


Now the focus is not on the transformation of the argument, but on the definition of a function as the successive application of two (or more) known ones.

Another example is:

getDistribution inList = percentize $ map fromIntegral (getNoteCount inList)


That becomes:

getDistribution = percentize . map fromIntegral . getNoteCount


This is, left to right, a description of what the function does.

Conventional names

I see that inList goes inside the function, and I can see that it is a List from the type signature, such long names are not needed.

Just use the conventional xs for general lists: 

percentize xs = map (/ sum xs) xs


Use where not let

It is more natural to read from general to specific than the opposite:

recommendNote notes targetDist = let y = zip (subtractLists targetDist (getDistribution notes)) noteTypes
                                in snd (maximumBy (comparing fst) y)                            


Becomes:

recommendNote notes targetDist = snd (maximumBy (comparing fst) y)
  where
    y = zip (subtractLists targetDist (getDistribution notes)) noteTypes 


Where you also avoid overly long lines.

Generality

Be optimistic and general with your types:

count :: String -&gt; [String] -&gt; Int


Becomes:

count :: a -&gt; [a] -&gt; Int


Where a stands for anything.

Not everything is get

get is a specific OO technical term, prefixing it before the function names is confusing, just drop it.

Make tiny functions local

Things like:

subtractLists = zipWith (-)


May be local and without a type declaration, like:

recommendNote notes targetDist = snd (maximumBy (comparing fst) y)
  where
    y = zip (subtractLists targetDist (getDistribution notes)) noteTypes 
    subtractLists = zipWith (-)