I wrote a similar implementation a while back[1]. The major difference is that mine only allows rules of the form "n is divisible by m" whereas the one from the post allows arbitrary predicates over n. Wouldn't be that hard to update though.

[1] https://gist.github.com/lgastako/d4fa392cbe85cbfae7dfa5e18c1...

Code is a little too fancy though it's easy to fall into that temptation with Haskell. Particularly though, using the Monoid instance on strings ties you to concatenating the strings together. There was an example the other day where the strings had to be separated by spaces and terminated by an exclam point ("Fizz Buzz!"). My solution used lists straightforwardly instead of Monoids. It goes to 110 instead of 100 since 105 is 3*5*7.

    import           Data.List (intercalate)

    fizzle :: Int -> String
    fizzle n =
        let ws = [(3,"Fizz"),(5,"Buzz"),(7,"Bazz")]
            a = [s | (d,s) <- ws, n`rem`d == 0]
        in case a of []        -> show n
                     otherwise -> intercalate " " a ++ "!"

    main = mapM_ (putStrLn . fizzle) [1..110]

    newtype Words = Words { getWords :: String }

    instance Semigroup Words where
      Words a <> Words b = Words (a <> " " <> b)

    instance Monoid Words where
      mempty = Words mempty

    fizzbuzz i =
      maybe (show i) (<> "!") . fmap getWords . mconcat $
        [ Words "fizz" <$ guard (rem i 3 == 0)
        , Words "buzz" <$ guard (rem i 5 == 0)
        ]

it always amazes me how Haskell uses the very complex approaches for a very simple problem. Do you want a design that generalizes to zork? Here it is:

    def fizzbuzz(i):
        return "".join((["fizz"] if (i % 3) == 0 else []) + 
                       (["buzz"] if (i % 5) == 0 else [])
                      ) or str(i)
 
    for i in range(1, 101):
        print(fizzbuzz(i))

here is "indication of good modularity" with no monoid in sight, and we did not have to import 3 extra libraries either.