Given that the author hasn't logged in for 2 years, and first I reported this 4 years ago I decided to fix the types myself.

Use the signature int32ToIP :: (Show a, Integral a) => a -> IPString

Please fix the data type as @phaul has noted. Both of the test case, eg 2149583361 are > maxBound :: Int32. Word32 is the correct type for unsigned Ints. Otherwise the test cases fail as it is trying to parse a negative number. This kata is currently unsolvable as is. Thanks.

For reference, maxBound :: Int32 == 2147483647 and minBound :: Int32 == -2147483648 while maxBound :: Word32 == 4294967295 and minBound :: Word32 == 0

Empty list is not a solution. A valid solution should be a number not a sequence of number.

Explicitly mentioning that the empty list has a zero sum just reinforces the natural assumption that the empty sequence is a valid solution.

I'd suggest either allowing the empty sequence as a solution, which allows for more natural and elegant solutions since the empty list doesn't need to be special cased, or explicitly stating you're asking for the maximum NONEMPTY subsequence sum.

Empty list is considered to has zero sum.
Fixed description and related test case added.

The description should specify that this expects a maximum over nonempty subsequences. My natural assumption was to treat empty subsequences as having a sum of 0 (which makes for a particularly nice solution). With this specified, you also have to require that the input list be nonempty, so you should also specify whether solutions have to care about that case or not.

Fixed

The fixes look good. There is one final issue in the first test case.

    describe (show input3) $ do
      it (printf "Should return %s" (show expected3) ) 
      $ do maxSequence input2 `shouldBe` expected2

This test case should be against input3 and expecte3

Also, I'm not marking this as spoiler because it is one of the given test cases to the problem. Let me know if I should change this.

Everything should be ok now. (could you double-check please?)
Thanks!

A few issues with this kata:

1. the module name doesn't match between the kata and the test cases. Not big deal, but I couldn't verify if the test runner worked properly because of number 2.

2. The type of maximumSum and the expected output don't match. I don't understand what the comment above the function means,but [a] -> [a] will never == [a] -> a

If the problem was clearer that we were to implement 2 functions or if the test cases were going to call sum on the returned list, that would help a lot.