Example of view patterns + typeclasses for polymorphic "constructors"

ConsList.hs

{-# LANGUAGE ViewPatterns #-}

import Data.Vector (Vector)
import qualified Data.Vector as V

data ConsView a = Nil | Cons a (ConsView a)
  deriving (Eq, Ord, Show)

class ConsList l where
  viewCons :: l a -> ConsView a
  fromCons :: ConsView a -> l a

instance ConsList ConsView where
  viewCons = id
  fromCons = id

instance ConsList [] where
  viewCons []     = Nil
  viewCons (x:xs) = Cons x (viewCons xs)

  fromCons Nil         = []
  fromCons (Cons x xs) = x : fromCons xs

instance ConsList Vector where
  viewCons v | V.null v  = Nil
             | otherwise = Cons (V.head v) (viewCons (V.tail v))

  fromCons Nil         = V.empty
  fromCons (Cons x xs) = V.cons x (fromCons xs)

mapCons :: ConsList l => (a -> b) -> l a -> l b
mapCons f (viewCons -> Nil)         = fromCons Nil
mapCons f (viewCons -> (Cons x xs)) = fromCons (Cons (f x) (mapCons f xs))

xs = [1..10]
ys = V.fromList [1..10]

test1 = mapCons (+2) xs
test2 = mapCons (+2) ys