content: This first example shows how to use polynomials.
  It should give you a taste of using categories for numerical applications.
  First, some preliminaries:
  
  > {-# LANGUAGE NoImplicitPrelude #-}
  > {-# LANGUAGE RebindableSyntax #-}
  > import SubHask
  > import SubHask.Category.Polynomial
  > import System.IO
  
  We'll do everything within the `main` function so we can print some output as we go.
  
  > main = do
  
  To start off, we'll just create an ordinary function and print it's output.
  The `Ring` class below corresponds very closely with the Prelude's `Num` class.
  
  >   let f :: Ring x => x -> x
  >       f x = x*x*x + x + 3
  >
  >   let a = 3 :: Integer
  >
  >   putStrLn $ "f a = " + show (f a)
  
  Now, we'll create a polynomial from our ordinary function.
  
  >   let g :: Polynomial Integer
  >       g = provePolynomial f
  >
  >   putStrLn ""
  >   putStrLn $ "g $ a = " + show ( g $ a )
  
  The function `provePolynomial` above gives us a safe way to convert an arrow in Hask into an arrow in the category of polynomials.
  The implementation uses a trick similar to automatic differentiation.
  In general, every `Concrete` category has at least one similar function.
  Finally, in order to apply our polynomial to a value, we must first convert it back into an arrow in Hask.
  The function application operator `$` performs this task for us.
  
  Polynomials support operations that other functions in Hask do not support.
  For example, we can show the value of a polynomial:
  
  >   putStrLn ""
  >   putStrLn $ "g     = " + show g
  >   putStrLn $ "g*g+g = " + show (g*g + g)
  
  Polynomials also support decidable equality:
  
  >   putStrLn ""
  >   putStrLn $ "g==g     = " + show (g==g)
  >   putStrLn $ "g==g*g+g = " + show (g==g*g+g)
  
  Finally, we can create polynomials of polynomials:
  
  >   let h :: Polynomial (Polynomial Integer)
  >       h = provePolynomial f
  >
  >   putStrLn ""
  >   putStrLn $ " h          = " + show h
  >   putStrLn $ " h $ g      = " + show ( h $ g )
  >   putStrLn $ "(h $ g) $ a = " + show (( h $ g ) $ a)
  
  **For advanced readers:**
  You may have noticed that function application on polynomials is equivalent to the join operation on monads.
  That's because polynomials form a monad on Hask.
  Sadly, we can't make `Polynomial` an instance of the new `Monad` class due to some limitatiions in GHC's type system.
  This isn't too big of a loss though because I don't know of a useful application for this particular monad.
  The monad described above is different than what category theorists call polynomial monads (see: http://ncatlab.org/nlab/show/polynomial+functor).
  
  