Суммировать положительные элементы, расположенные между минимумом и максимумом

-- Рекурсия ("за один проход")
 
sum' :: [Int] -> [Int] -> Int -> Int -> Int -> Int -> Int -> Int
sum' [] s i xmin imin xmax imax = (s !! w)-(s !! k)-u-v
                                where k = min imin imax
                                      w = max imin imax
                                      u = if ((imax > imin) && (xmax > 0)) then xmax else 0
                                      v = if ((imin > imax) && (xmin > 0)) then xmin else 0
sum' (x:xs) s i xmin imin xmax imax | (x < xmin) = sum' xs ns (i+1) x i xmax imax
                                    | (x > xmax) = sum' xs ns (i+1) xmin imin x i                                      
                                    | otherwise = sum' xs ns (i+1) xmin imin xmax imax
                                     where ns |(s == []) = if (x > 0) then [x] else [0] 
                                              |(x > 0)   = s++[x + last s] 
                                              | otherwise = s++[last s]
                
solve1 :: [Int] -> Int
solve1 x = sum' x [] 0 w 0 w 0
           where w = head x
 
-- Функционалы
 
pos :: Int -> Int -> [Int] -> Int
pos _ _ [] = -1
pos n k (x:xs) | (n == x) = k
               | otherwise = pos n (k+1) xs
                    
pMax :: [Int] -> Int
pMax x = pos ma 0 x
         where ma = foldl max (head x) x
 
pMin :: [Int] -> Int
pMin x = pos mi 0 x
         where mi = foldl min (head x) x
                    
solve2 :: [Int] -> Int
solve2 x = sum $ map (\ u -> if (u >= 0) then x !! u else 0) z
           where z  = map (\ y -> if ((y <= mi) || (y >= ma)) then -1 else y) [0..(length x)]
                 ma = max pmax pmin
                 mi = min pmax pmin
                 pmax = pMax x
                 pmin = pMin x

import Data.List(findIndex)
import Data.Maybe(fromJust)
 
index :: [Int] -> Int -> Int
index l e = fromJust $ findIndex (e==) l
 
solve :: [Int] -> Int
solve x = let
  mn = minimum x
  mx = maximum x
  sum1 = sum . takeWhile (<mx) . dropWhile (>mn) $ x
  sum2 = sum . takeWhile (>mn) . dropWhile (<mx) $ x
  in if index x mn < index x mx then sum1 - mn else sum2 - mx

import Control.Monad
import Control.Monad.Reader
 
minmax xs@( x : _ ) = foldl ( \( a, b ) n -> ( if n < a then n else a, if n > b then n else b ) ) ( x, x ) xs
 
calcSum xs = sum $ takeWhile pred $ tail $ dropWhile pred xs
    where ( min, max ) = minmax xs
          pred = (liftM2 (&&) (/= min) (/= max) )