Standard undeterministic list monad with quickcheck properties for the 3 monad laws

ListMonad.hs

{-# LANGUAGE FlexibleInstances #-}
import Test.QuickCheck

newtype List a = List { unList :: [a] }
    deriving (Show, Read, Eq, Ord)
    
data ListBind a = ListBind (a -> List a) String

instance Show (ListBind a) where
    show (ListBind _ name) = name

instance Arbitrary a => Arbitrary (List a) where
  arbitrary = fmap List arbitrary
  
instance Arbitrary (ListBind Int) where
  arbitrary = elements $ zipWith ListBind [f1, f2, f2] ["f1","f2","f3"]
    where f1 x = List $ replicate (min 13 x) x
          f2 x = List [x+5]
          f3 x = f2 x

instance Monad List where
  return a        = List $ return a
  (List xs) >>= f = List $ concat $ map (unList . f) xs

prop_right_identity :: List Int -> Bool
prop_right_identity xs = (xs >>= return) == xs

prop_left_identity :: Int -> ListBind Int -> Bool
prop_left_identity x (ListBind f _)= (return x >>= f) == f x

prop_associativity :: List Int -> ListBind Int -> ListBind Int -> Bool
prop_associativity m (ListBind f _) (ListBind g _) =
    (m >>= (\x -> f x >>= g)) == ((m >>= f) >>= g)


myList :: List Int
myList = do
    f <- List [(+1), (*3)]
    x <- List [1..3]
    return (f x)