How can I make this Euler/RK4 implementation more elegant?
I feel ... that I should be able to use more inbuilt functions (that
  I'm not aware of)


Let me introduce you to your new best friend... Hoogle. Seriously, it's the best thing since sliced... monad analogies. Install a local copy as well.

We're producing a sequence of values by repeated application of a function, so let's search Hoogle for

(a -&gt; a) -&gt; a -&gt; [a]


The first hit is iterate :: (a -&gt; a) -&gt; a -&gt; [a], which looks like a good candidate. But a little further down the page, we see


  until :: (a -&gt; Bool) -&gt; (a -&gt; a) -&gt; a -&gt; a
  
  until p f yields the result of applying f until p holds.


Bingo. So we know that euler is going to look like

euler :: Fractional a =&gt; [[a] -&gt; a] -&gt; ([a] -&gt; Bool) -&gt; a -&gt; [a] -&gt; [a]
euler fs target h = until target step
    where step x = ???


And we fill in the blanks

euler :: Fractional a =&gt; [[a] -&gt; a] -&gt; ([a] -&gt; Bool) -&gt; a -&gt; [a] -&gt; [a]
euler fs target h = until target step
    where step x = zipWith (+) x (map (h *) (pam fs x))


A similar transformation can be applied to rk4:

rk4step fs h x = x +. dx
    where k1 = pam fs x
          k2 = pam fs $ x +. map (h / 2 *) k1
          k3 = pam fs $ x +. map (h / 2 *) k2
          k4 = pam fs $ x +. map (h *) k3
          dx = map (h / 6 *) $ k1 +. k2 +. k2 +. k3 +. k3 +. k4
          (+.) = zipWith (+)

rk4 :: Fractional a =&gt; [[a] -&gt; a] -&gt; ([a] -&gt; Bool) -&gt; a -&gt; [a] -&gt; [a]
rk4 fs target h = until target (rk4step fs h)


I'm not sure if I'd actually suggest this, but you could also introduce another function, *.:

rk4step fs h x = x +. dx
    where k1 = pam fs x
          k2 = pam fs $ x +. ((h / 2) *. k1)
          k3 = pam fs $ x +. ((h / 2) *. k2)
          k4 = pam fs $ x +. (h *. k3)
          dx = (h / 6) *. (k1 +. (2 *. k2) +. (2 *. k3) +. k4)
          (+.) = zipWith (+)
          (*.) n = map (n *)


Finally, I think that pam would be more readable as a list comprehension

pam :: [a -&gt; b] -&gt; a -&gt; [b]
pam fs x = [ f x | f &lt;- fs ]