content: 
  > {-# LANGUAGE OverloadedStrings,LambdaCase #-}
  > module Database.HsSqlPpp.Tests.TypeChecking.TypeConversion
  >        (typeConversionTests) where
  
  > import Data.Text ()
  > --import Database.HsSqlPpp.Catalog
  > import Database.HsSqlPpp.Types
  > --import Database.HsSqlPpp.Ast
  > --import Database.HsSqlPpp.Dialect
  > import Database.HsSqlPpp.Tests.TestTypes
  > --import Database.HsSqlPpp.Internals.TypesInternal hiding (mkTypeExtra,mkTypeExtraNN)
  
  
  tests:
  numeric operators simulator
    choose each pair of number types with the plus operator
      and check the return type
    choose one type with unknown and plus op
    two unknowns and plus -> error
  
  > typeConversionTests :: Item
  > typeConversionTests = Group "typeConversionTests"
  >     [binaryOperators]
  
  
  > binaryOperators :: Item
  > binaryOperators = Group "binaryOperators"
  >     [{-MatchApp PostgreSQLDialect defaultTemplate1Catalog
  >      [Nmc "+"] [(intNotNull,Nothing),(intNotNull, Nothing)]
  >      (Right ([intNotNull,intNotNull],intNotNull))
  >     ,MatchApp PostgreSQLDialect defaultTemplate1Catalog
  >      [Nmc "+"] [(intNotNull,Nothing),(unk, Nothing)]
  >      (Right ([intNotNull,intNotNull],intNotNull))
  >     ,MatchApp PostgreSQLDialect defaultTemplate1Catalog
  >      [Nmc "+"] [(unk,Nothing),(unk, Nothing)]
  >      (Left [NoMatchingOperator "+" [UnknownType,UnknownType]])-}
  
  different types with implicit casts
  
  >     {-,MatchApp PostgreSQLDialect defaultTemplate1Catalog
  >      [Nmc "+"] [(intNotNull,Nothing),(te typeNumeric, Nothing)]
  >      (Right ([te typeNumeric,te typeNumeric],te typeNumeric))
  
  
  nullability
  
  >     ,MatchApp PostgreSQLDialect defaultTemplate1Catalog
  >      [Nmc "+"] [(intNull,Nothing),(intNotNull, Nothing)]
  >      (Right ([intNull,intNotNull],intNull))-}
  
  
  precision and scale
  not quite right
  
  >     {-,MatchApp PostgreSQLDialect defaultTemplate1Catalog
  >      [Nmc "+"] [(numeric,Nothing),(numeric, Nothing)]
  >      (Right ([numeric,numeric],numeric))-}
  
  
  >     ]
  >   where
  >     _intNotNull = TypeExtra typeInt Nothing Nothing False
  >     _intNull = TypeExtra typeInt Nothing Nothing True
  >     _unk = TypeExtra UnknownType Nothing Nothing False
  >     _te s = TypeExtra s Nothing Nothing False
  >     _numeric = TypeExtra typeNumeric (Just 15) (Just 2) False
  >     typeInt = ScalarType "int4"
  >     typeNumeric = ScalarType "numeric"
  
  text conversions
    do something similar to numeric with pairs of string types
    and the || op
  domains
    do a simple test for these
  function style cast: test some success and fails
  time types
    can do something similar to numeric ops?
  binary strings
    don't have these right now
  
  review each branch in the matchapp and fix it
  
  precision tests
  nullability tests
  
  what are all the special cases currently:
  special cases for precision
  special cases for result null
  in OldTypeConverion.findCallMatch:
     between, not between, greatest, least
     rowctor
     .
     comparisons for composite/set types
  more stuff in TypeConversion.matchApp
    sql server date stuff
    decode
    something to do with datetimes?
    string precisions?:
      ||, substring, replace
    some nullability special cases?
    more stuff
  SqlTypeConversions: special case for implicit casts from text types to
    numeric (see if can handle in rule system)
  ScalarExprs.ag
    needs implicit cast
    implicit cast type
    check the types (e.g. cast syntax should use this typeconversion
     machinery)
    tcAppLike: more mssql date stuff
  
    getmaybeintsfromliterals: also suggests only need to support int
      literals in the matchapp function here
  
  