Seems like a necroposting but it still does not account for edge cases.
https://www.codewars.com/kata/reviews/5de92cff10dfae00012aa8ff/groups/5e083ebf8c89df0001c5b680

They do not conflict, the second function is simply more general then the first one. Try to squeeze in one more type variable into your definition.

I guess for now.

I can constraint type signature of scanl and check inside what exactly is passed to it, the only thing is it will break almost all solutions, is it fine?

ghci> leafTree
LeafNode 
  (LeafNode 
    (LeafNode 
      (LeafLeaf 1) 
      (LeafLeaf 2)) 
    (LeafLeaf 3)) 
  (LeafLeaf 4)
  
ghci> appEndo (foldMap (Endo . LeafNode) (fmap LeafLeaf leafTree)) (LeafLeaf 10) -- some random base case
LeafNode 
  (LeafLeaf 1) 
  (LeafNode 
    (LeafLeaf 2) 
    (LeafNode 
      (LeafLeaf 3) 
      (LeafNode 
        (LeafLeaf 4) 
        (LeafLeaf 10))))

Oh, nice, thank you! Your solution only passed because of my poorly written tests (which I hope I fixed by now). The thing is you get a bunch of Endo . LeafNode combined one after another (as if we had a list), instead of our previous proper structure.

Here what base says about it:

For a general Foldable structure this should be semantically identical to,
foldr f z = foldr f z . toList

Updated.

Oh, this kata is deeply flawed then. I even tried to unsafeCoerce everything to Int (even though it is UB) and compare them inside scanl, it even rejected your solution (both of them, actually), but there are still bogus ones. I'll delete this kata if I don't come up with anything sane then.

Oh, that was a blunder. I should have mentioned that Tribonacci sequence should require only one scanl. You can't reduce it twice, the second sequence can't be rewritten in terms of itself. At least I didn't see the solution.

Fixed.

You can use listToMaybe instead of headMay.

I should have known about filterMap or mapMaybe before, it's such a nice function.

Powerful Tom cat can catch a lot of mice every day, in order to show his naughtiness and generosity, let mouse number off, first batch eats the numbers of single. Then re-queue, The second batch still eats the numbers of single. The third batch is the same, until there's only one left, and it can survive.

Can be changed to:

Powerful Tom catches a lot of mice every day. But in order to show his naughtiness and generosity he always lets one mouse go. First he eats each mouse in the odd positions, rounds up the remaining mice and repeats the process, until there is just one mouse left.

Still clunky but I didn't want to change the structure.