Euler 1 but pointless
Since this is supposed to be a practice in idiomatic haskell, point free seems to be the way to go


Ah, but point-free Haskell isn't idiomatic in general. Just compare both variants of divisible:

divisible x y = y `mod` x == 0
divisible = ((==) 0 .) . flip mod


The point-free variant is not only harder to read, but even longer, and I've already used infix-mod to increase the pointful version by two characters. The same holds for any, although the original variable names where a little bit long:

any' p m = any ($ m) p
any' = flip (any . flip id)


The point-free version of euler1 is perfectly fine. It's also the most natural one to do by hand, since \x -&gt; f $ g x is f . g, and euler1 follows exactly that style. Defining new functions by combinatiing old ones is great if you have that style of function, e.g.

foo x = bar $ quux $ fox $ tango $ x
foo = bar . quux . fox . tango 


But as soon as a second parameter gets involved, it gets a lot more trickier. And as always, the best code is not worth it, if you cannot understand it later on. Haskell's referential transparency makes that a lot easier, but if you need to sit down and check how flip (any . flip id) works, it's a good call to use \p m -&gt; any ($m) p.

In the end, it boils down to your personal choice. I would have used a list comprehension, because  it's still easy to read, but it's only a syntactic sugar variant of your filter:

euler1 xs = sum [x | x &lt;- xs, x `rem` 3 == 0 || x `rem` 5 == 0]



  I opted to describe how the answer is defined (as seems to be the way FP works) as opposed to find a faster solution


Just for completeness, have a look at the inclusion-exclusion principle, and try to solve Euler1 in Haskell (or another language).


  but I'd be fecetious in saying I fully understood the pointfree formulation of any'.


flip (any . flip id) p m
  = (any . flip id) m p
  = ((any . flip id) m) p
  = (any (flip id m)) p -- see remark below
  = (any ($ m)) p
  = any ($ m) p

id      :: (a -&gt; b) -&gt; a -&gt; b
flip id :: a -&gt; (a -&gt; b) -&gt; b 
($)     :: a -&gt; (a -&gt; b) -&gt; b


But the flipless version is easier to understand.


  That may effect the best solution for me, but I'm interested mostly in idiomatic, readable (to more veteran haskellers) code.


Any veteran will tell you that the first version is more readable. They will understand the latter, but after all, both versions do exactly the same.