'Tis the season for gift-wrapping
The simplest implementation that comes to my mind would keep the list split into two parts: One the already traversed points in reverse order, so that we can easily backtrack, and rest of unvisited points:

giftWrap :: [Vector2] -&gt; [Vector2]
giftWrap (a:rest) = gw [] a rest
  where
    gw [] b (c:xs) = gw [b] c xs         -- beginning - just add the first point
    gw as@(a:as') b cs@(c:cs')
        | TurnRight &lt;- turn a b c   = gw as' a cs      -- backtrack
        | otherwise                 = gw (b:as) c cs'  -- advance
    gw as b [] = reverse (b : as)


At the end, we need to reverse the result (unless we don't mind having the points reversed).

There is no need to check the case of the first point in the list, as it's always chosen so that it's a left turn.

Using pattern guards simplifies the call to turn.

I also added a small snippet that uses Test.QuickCheck to test the algorithm:

vectors :: Gen [Vector2]
vectors = nub &lt;$&gt; (listOf1 $ Vector2 &lt;$&gt; r &lt;*&gt; r)
  where
    r = fromIntegral &lt;$&gt; choose (-2 :: Int, 2 :: Int)

gwconvex_property :: Property
gwconvex_property = forAllShrink vectors (shrinkList shrinkNothing) $ \xs -&gt; 
    let rotate (x:xs) = xs ++ [x]
        vs = hull xs
        vs' = rotate vs
        vs'' = rotate vs'
    in counterexample ("Input: " ++ show vs) $
       counterexample ("Chained: " ++ show (chain vs)) $
       conjoin $ zipWith3 (\a b c -&gt; turn a b c /= TurnRight) vs vs' vs''

main = quickCheck gwconvex_property


Note that the original implementation of giftWrap fails the test, either with 


  Non-exhaustive patterns in function giftWrap'


or producing non-convex result, but I didn't have time to explore the details.