content: -- These are the examples from the Higher Order Patterns in Rewrite Rules proposal
  
  module RewriteHigherOrderPatterns where
  
  foo :: (Int -> Int) -> Bool
  {-# NOINLINE foo #-}
  foo _ = False
  
  {-# RULES "foo" forall f. foo (\x -> f x) = True #-}
  
  bar :: (Int -> Int -> Int -> Int) -> Bool
  {-# NOINLINE bar #-}
  bar _ = False
  
  {-# RULES "bar" forall f. bar (\x y z -> f x y z) = True #-}
  
  baz :: (Int -> Int) -> Bool
  {-# NOINLINE baz #-}
  baz _ = False
  
  {-# RULES "baz" forall f. baz (\x -> f x x) = True #-}
  
  qux :: (Int -> Int -> Int) -> Bool
  {-# NOINLINE qux #-}
  qux _ = False
  
  {-# RULES "qux" forall f. qux (\x y -> f x (2 :: Int) y) = True #-}
  
  -- instead of + and * we use 'two' and 'three' to avoid cluttering
  -- the rule rewrites dump.
  
  two :: Int -> Int -> Int
  {-# NOINLINE two #-}
  two _ _ = 2
  
  three :: Int -> Int -> Int -> Int
  {-# NOINLINE three #-}
  three _ _ _ = 3
  
  ex1 = foo (\x -> two (two x 2) x)
  ex2 = bar (\x y z -> two (two x y) z)
  ex3 = bar (\x y z -> two (two x 2) z)
  ex4 = baz (\x -> two x (two x 2))
  ex5 = baz (\x -> three (two x 1) 2 x)
  ex6 = qux (\x y -> two (two x 2) y)
  ex7 = qux (\x y -> three (two x 1) 2 y)
  