haskelldb 2.0.1.1 → 2.1.0

raw patch · 2 files changed

+42/−5 lines, 2 filesdep ~mtlPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: mtl

API changes (from Hackage documentation)

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N1) => Less a N2

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N10) => Less a N11

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N100) => Less a N101

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N101) => Less a N102

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N102) => Less a N103

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N103) => Less a N104

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N104) => Less a N105

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N105) => Less a N106

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N106) => Less a N107

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N107) => Less a N108

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N108) => Less a N109

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N109) => Less a N110

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N11) => Less a N12

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N110) => Less a N111

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N111) => Less a N112

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N112) => Less a N113

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N113) => Less a N114

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N114) => Less a N115

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N115) => Less a N116

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N116) => Less a N117

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N117) => Less a N118

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N118) => Less a N119

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N119) => Less a N120

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N12) => Less a N13

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N120) => Less a N121

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N121) => Less a N122

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N122) => Less a N123

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N123) => Less a N124

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N124) => Less a N125

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N125) => Less a N126

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N126) => Less a N127

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N127) => Less a N128

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N128) => Less a N129

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N129) => Less a N130

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N13) => Less a N14

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N130) => Less a N131

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N131) => Less a N132

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N132) => Less a N133

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N133) => Less a N134

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N134) => Less a N135

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N135) => Less a N136

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N136) => Less a N137

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N137) => Less a N138

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N138) => Less a N139

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N139) => Less a N140

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N14) => Less a N15

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N140) => Less a N141

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N141) => Less a N142

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N142) => Less a N143

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N143) => Less a N144

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N144) => Less a N145

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N145) => Less a N146

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N146) => Less a N147

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N147) => Less a N148

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N148) => Less a N149

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N149) => Less a N150

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N15) => Less a N16

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N150) => Less a N151

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N151) => Less a N152

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N152) => Less a N153

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N153) => Less a N154

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N154) => Less a N155

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N155) => Less a N156

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N156) => Less a N157

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N157) => Less a N158

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N158) => Less a N159

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N159) => Less a N160

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N16) => Less a N17

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N160) => Less a N161

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N161) => Less a N162

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N162) => Less a N163

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N163) => Less a N164

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N164) => Less a N165

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N165) => Less a N166

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N166) => Less a N167

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N167) => Less a N168

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N168) => Less a N169

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N169) => Less a N170

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N17) => Less a N18

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N170) => Less a N171

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N171) => Less a N172

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N172) => Less a N173

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N173) => Less a N174

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N174) => Less a N175

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N175) => Less a N176

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N176) => Less a N177

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N177) => Less a N178

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N178) => Less a N179

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N179) => Less a N180

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N18) => Less a N19

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N180) => Less a N181

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N181) => Less a N182

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N182) => Less a N183

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N183) => Less a N184

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N184) => Less a N185

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N185) => Less a N186

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N186) => Less a N187

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N187) => Less a N188

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N188) => Less a N189

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N189) => Less a N190

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N19) => Less a N20

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N190) => Less a N191

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N191) => Less a N192

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N192) => Less a N193

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N193) => Less a N194

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N194) => Less a N195

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N195) => Less a N196

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N196) => Less a N197

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N197) => Less a N198

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N198) => Less a N199

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N199) => Less a N200

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N2) => Less a N3

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N20) => Less a N21

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N200) => Less a N201

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N201) => Less a N202

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N202) => Less a N203

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N203) => Less a N204

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N204) => Less a N205

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N205) => Less a N206

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N206) => Less a N207

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N207) => Less a N208

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N208) => Less a N209

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N209) => Less a N210

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N21) => Less a N22

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N210) => Less a N211

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N211) => Less a N212

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N212) => Less a N213

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N213) => Less a N214

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N214) => Less a N215

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N215) => Less a N216

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N216) => Less a N217

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N217) => Less a N218

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N218) => Less a N219

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N219) => Less a N220

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N22) => Less a N23

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N220) => Less a N221

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N221) => Less a N222

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N222) => Less a N223

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N223) => Less a N224

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N224) => Less a N225

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N225) => Less a N226

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N226) => Less a N227

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N227) => Less a N228

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N228) => Less a N229

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N229) => Less a N230

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N23) => Less a N24

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N230) => Less a N231

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N231) => Less a N232

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N232) => Less a N233

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N233) => Less a N234

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N234) => Less a N235

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N235) => Less a N236

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N236) => Less a N237

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N237) => Less a N238

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N238) => Less a N239

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N239) => Less a N240

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N24) => Less a N25

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N240) => Less a N241

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N241) => Less a N242

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N242) => Less a N243

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N243) => Less a N244

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N244) => Less a N245

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N245) => Less a N246

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N246) => Less a N247

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N247) => Less a N248

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N248) => Less a N249

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N249) => Less a N250

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N25) => Less a N26

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N250) => Less a N251

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N251) => Less a N252

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N252) => Less a N253

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N253) => Less a N254

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N254) => Less a N255

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N255) => Less a N65535

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N26) => Less a N27

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N27) => Less a N28

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N28) => Less a N29

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N29) => Less a N30

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N3) => Less a N4

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N30) => Less a N31

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N31) => Less a N32

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N32) => Less a N33

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N33) => Less a N34

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N34) => Less a N35

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N35) => Less a N36

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N36) => Less a N37

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N37) => Less a N38

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N38) => Less a N39

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N39) => Less a N40

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N4) => Less a N5

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N40) => Less a N41

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N41) => Less a N42

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N42) => Less a N43

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N43) => Less a N44

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N44) => Less a N45

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N45) => Less a N46

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N46) => Less a N47

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N47) => Less a N48

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N48) => Less a N49

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N49) => Less a N50

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N5) => Less a N6

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N50) => Less a N51

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N51) => Less a N52

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N52) => Less a N53

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N53) => Less a N54

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N54) => Less a N55

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N55) => Less a N56

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N56) => Less a N57

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N57) => Less a N58

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N58) => Less a N59

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N59) => Less a N60

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N6) => Less a N7

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N60) => Less a N61

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N61) => Less a N62

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N62) => Less a N63

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N63) => Less a N64

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N64) => Less a N65

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N65) => Less a N66

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N66) => Less a N67

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N67) => Less a N68

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N68) => Less a N69

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N69) => Less a N70

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N7) => Less a N8

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N70) => Less a N71

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N71) => Less a N72

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N72) => Less a N73

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N73) => Less a N74

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N74) => Less a N75

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N75) => Less a N76

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N76) => Less a N77

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N77) => Less a N78

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N78) => Less a N79

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N79) => Less a N80

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N8) => Less a N9

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N80) => Less a N81

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N81) => Less a N82

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N82) => Less a N83

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N83) => Less a N84

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N84) => Less a N85

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N85) => Less a N86

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N86) => Less a N87

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N87) => Less a N88

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N88) => Less a N89

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N89) => Less a N90

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N9) => Less a N10

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N90) => Less a N91

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N91) => Less a N92

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N92) => Less a N93

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N93) => Less a N94

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N94) => Less a N95

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N95) => Less a N96

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N96) => Less a N97

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N97) => Less a N98

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N98) => Less a N99

- Database.HaskellDB.BoundedList: instance [overlap ok] (Less a N99) => Less a N100

- Database.HaskellDB.BoundedList: instance [overlap ok] (Size a) => LessEq a a

- Database.HaskellDB.Database: instance [overlap ok] (Size n) => GetValue (BoundedString n)

- Database.HaskellDB.Database: instance [overlap ok] (Size n) => GetValue (Maybe (BoundedString n))

- Database.HaskellDB.FieldType: instance [overlap ok] (ExprType a) => ExprType (Expr a)

- Database.HaskellDB.FieldType: instance [overlap ok] (ExprType a) => ExprType (Maybe a)

- Database.HaskellDB.FieldType: instance [overlap ok] (ExprType a) => ExprType (Rel a)

- Database.HaskellDB.FieldType: instance [overlap ok] (ExprTypes r) => ExprTypes (Record r)

- Database.HaskellDB.FieldType: instance [overlap ok] (ExprTypes r) => ExprTypes (Rel r)

- Database.HaskellDB.FieldType: instance [overlap ok] (Size n) => ExprType (BoundedString n)

- Database.HaskellDB.HDBRec: instance [overlap ok] (Eq r) => Eq (Record r)

- Database.HaskellDB.HDBRec: instance [overlap ok] (HasField f r) => HasField f (RecCons g a r)

- Database.HaskellDB.HDBRec: instance [overlap ok] (HasField f r) => HasField f (Record r)

- Database.HaskellDB.HDBRec: instance [overlap ok] (Ord r) => Ord (Record r)

- Database.HaskellDB.HDBRec: instance [overlap ok] (ReadRecRow r) => Read (Record r)

- Database.HaskellDB.HDBRec: instance [overlap ok] (RecCat r1 r2 r3) => RecCat (RecCons f a r1) r2 (RecCons f a r3)

- Database.HaskellDB.HDBRec: instance [overlap ok] (RecCat r1 r2 r3) => RecCat (Record r1) (Record r2) (Record r3)

- Database.HaskellDB.HDBRec: instance [overlap ok] (SelectField f r a) => Select (l f a) (Record r) a

- Database.HaskellDB.HDBRec: instance [overlap ok] (SelectField f r a) => SelectField f (RecCons g b r) a

- Database.HaskellDB.HDBRec: instance [overlap ok] (SelectField f r a) => SelectField f (Record r) a

- Database.HaskellDB.HDBRec: instance [overlap ok] (SetField f r a) => SetField f (RecCons g b r) a

- Database.HaskellDB.HDBRec: instance [overlap ok] (SetField f r a) => SetField f (Record r) a

- Database.HaskellDB.HDBRec: instance [overlap ok] (Show r) => Show (Record r)

- Database.HaskellDB.HDBRec: instance [overlap ok] (ShowLabels r) => ShowLabels (Record r)

- Database.HaskellDB.HDBRec: instance [overlap ok] (ShowRecRow r) => ShowRecRow (Record r)

- Database.HaskellDB.Query: instance [overlap ok] (ConstantRecord r cr) => ConstantRecord (Record r) (Record cr)

- Database.HaskellDB.Query: instance [overlap ok] (HasField f r) => Select (Attr f a) (Rel r) (Expr a)

- Database.HaskellDB.Query: instance [overlap ok] (IsExpr tail) => IsExpr (Expr a -> tail)

- Database.HaskellDB.Query: instance [overlap ok] (ShowConstant a) => ShowConstant (Maybe a)

- Database.HaskellDB.Query: instance [overlap ok] (Size n) => BStrToStr (Expr (BoundedString n)) (Expr String)

- Database.HaskellDB.Query: instance [overlap ok] (Size n) => BStrToStr (Expr (Maybe (BoundedString n))) (Expr (Maybe String))

- Database.HaskellDB.Query: instance [overlap ok] (Size n) => ShowConstant (BoundedString n)

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N1 => Less a N2

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N10 => Less a N11

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N100 => Less a N101

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N101 => Less a N102

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N102 => Less a N103

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N103 => Less a N104

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N104 => Less a N105

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N105 => Less a N106

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N106 => Less a N107

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N107 => Less a N108

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N108 => Less a N109

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N109 => Less a N110

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N11 => Less a N12

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N110 => Less a N111

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N111 => Less a N112

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N112 => Less a N113

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N113 => Less a N114

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N114 => Less a N115

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N115 => Less a N116

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N116 => Less a N117

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N117 => Less a N118

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N118 => Less a N119

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N119 => Less a N120

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N12 => Less a N13

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N120 => Less a N121

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N121 => Less a N122

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N122 => Less a N123

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N123 => Less a N124

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N124 => Less a N125

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N125 => Less a N126

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N126 => Less a N127

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N127 => Less a N128

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N128 => Less a N129

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N129 => Less a N130

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N13 => Less a N14

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N130 => Less a N131

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N131 => Less a N132

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N132 => Less a N133

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N133 => Less a N134

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N134 => Less a N135

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N135 => Less a N136

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N136 => Less a N137

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N137 => Less a N138

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N138 => Less a N139

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N139 => Less a N140

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N14 => Less a N15

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N140 => Less a N141

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N141 => Less a N142

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N142 => Less a N143

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N143 => Less a N144

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N144 => Less a N145

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N145 => Less a N146

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N146 => Less a N147

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N147 => Less a N148

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N148 => Less a N149

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N149 => Less a N150

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N15 => Less a N16

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N150 => Less a N151

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N151 => Less a N152

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N152 => Less a N153

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N153 => Less a N154

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N154 => Less a N155

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N155 => Less a N156

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N156 => Less a N157

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N157 => Less a N158

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N158 => Less a N159

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N159 => Less a N160

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N16 => Less a N17

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N160 => Less a N161

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N161 => Less a N162

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N162 => Less a N163

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N163 => Less a N164

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N164 => Less a N165

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N165 => Less a N166

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N166 => Less a N167

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N167 => Less a N168

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N168 => Less a N169

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N169 => Less a N170

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N17 => Less a N18

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N170 => Less a N171

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N171 => Less a N172

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N172 => Less a N173

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N173 => Less a N174

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N174 => Less a N175

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N175 => Less a N176

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N176 => Less a N177

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N177 => Less a N178

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N178 => Less a N179

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N179 => Less a N180

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N18 => Less a N19

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N180 => Less a N181

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N181 => Less a N182

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N182 => Less a N183

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N183 => Less a N184

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N184 => Less a N185

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N185 => Less a N186

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N186 => Less a N187

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N187 => Less a N188

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N188 => Less a N189

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N189 => Less a N190

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N19 => Less a N20

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N190 => Less a N191

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N191 => Less a N192

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N192 => Less a N193

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N193 => Less a N194

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N194 => Less a N195

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N195 => Less a N196

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N196 => Less a N197

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N197 => Less a N198

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N198 => Less a N199

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N199 => Less a N200

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N2 => Less a N3

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N20 => Less a N21

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N200 => Less a N201

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N201 => Less a N202

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N202 => Less a N203

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N203 => Less a N204

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N204 => Less a N205

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N205 => Less a N206

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N206 => Less a N207

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N207 => Less a N208

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N208 => Less a N209

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N209 => Less a N210

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N21 => Less a N22

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N210 => Less a N211

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N211 => Less a N212

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N212 => Less a N213

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N213 => Less a N214

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N214 => Less a N215

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N215 => Less a N216

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N216 => Less a N217

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N217 => Less a N218

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N218 => Less a N219

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N219 => Less a N220

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N22 => Less a N23

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N220 => Less a N221

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N221 => Less a N222

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N222 => Less a N223

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N223 => Less a N224

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N224 => Less a N225

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N225 => Less a N226

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N226 => Less a N227

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N227 => Less a N228

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N228 => Less a N229

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N229 => Less a N230

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N23 => Less a N24

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N230 => Less a N231

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N231 => Less a N232

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N232 => Less a N233

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N233 => Less a N234

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N234 => Less a N235

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N235 => Less a N236

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N236 => Less a N237

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N237 => Less a N238

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N238 => Less a N239

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N239 => Less a N240

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N24 => Less a N25

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N240 => Less a N241

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N241 => Less a N242

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N242 => Less a N243

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N243 => Less a N244

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N244 => Less a N245

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N245 => Less a N246

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N246 => Less a N247

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N247 => Less a N248

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N248 => Less a N249

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N249 => Less a N250

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N25 => Less a N26

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N250 => Less a N251

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N251 => Less a N252

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N252 => Less a N253

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N253 => Less a N254

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N254 => Less a N255

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N255 => Less a N65535

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N26 => Less a N27

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N27 => Less a N28

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N28 => Less a N29

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N29 => Less a N30

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N3 => Less a N4

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N30 => Less a N31

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N31 => Less a N32

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N32 => Less a N33

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N33 => Less a N34

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N34 => Less a N35

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N35 => Less a N36

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N36 => Less a N37

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N37 => Less a N38

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N38 => Less a N39

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N39 => Less a N40

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N4 => Less a N5

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N40 => Less a N41

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N41 => Less a N42

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N42 => Less a N43

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N43 => Less a N44

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N44 => Less a N45

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N45 => Less a N46

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N46 => Less a N47

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N47 => Less a N48

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N48 => Less a N49

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N49 => Less a N50

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N5 => Less a N6

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N50 => Less a N51

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N51 => Less a N52

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N52 => Less a N53

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N53 => Less a N54

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N54 => Less a N55

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N55 => Less a N56

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N56 => Less a N57

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N57 => Less a N58

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N58 => Less a N59

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N59 => Less a N60

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N6 => Less a N7

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N60 => Less a N61

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N61 => Less a N62

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N62 => Less a N63

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N63 => Less a N64

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N64 => Less a N65

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N65 => Less a N66

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N66 => Less a N67

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N67 => Less a N68

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N68 => Less a N69

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N69 => Less a N70

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N7 => Less a N8

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N70 => Less a N71

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N71 => Less a N72

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N72 => Less a N73

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N73 => Less a N74

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N74 => Less a N75

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N75 => Less a N76

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N76 => Less a N77

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N77 => Less a N78

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N78 => Less a N79

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N79 => Less a N80

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N8 => Less a N9

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N80 => Less a N81

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N81 => Less a N82

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N82 => Less a N83

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N83 => Less a N84

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N84 => Less a N85

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N85 => Less a N86

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N86 => Less a N87

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N87 => Less a N88

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N88 => Less a N89

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N89 => Less a N90

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N9 => Less a N10

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N90 => Less a N91

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N91 => Less a N92

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N92 => Less a N93

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N93 => Less a N94

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N94 => Less a N95

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N95 => Less a N96

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N96 => Less a N97

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N97 => Less a N98

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N98 => Less a N99

+ Database.HaskellDB.BoundedList: instance [overlap ok] Less a N99 => Less a N100

+ Database.HaskellDB.BoundedList: instance [overlap ok] Size a => LessEq a a

+ Database.HaskellDB.Database: instance [overlap ok] Size n => GetValue (BoundedString n)

+ Database.HaskellDB.Database: instance [overlap ok] Size n => GetValue (Maybe (BoundedString n))

+ Database.HaskellDB.FieldType: instance [overlap ok] ExprType a => ExprType (Expr a)

+ Database.HaskellDB.FieldType: instance [overlap ok] ExprType a => ExprType (Maybe a)

+ Database.HaskellDB.FieldType: instance [overlap ok] ExprType a => ExprType (Rel a)

+ Database.HaskellDB.FieldType: instance [overlap ok] ExprTypes r => ExprTypes (Record r)

+ Database.HaskellDB.FieldType: instance [overlap ok] ExprTypes r => ExprTypes (Rel r)

+ Database.HaskellDB.FieldType: instance [overlap ok] Size n => ExprType (BoundedString n)

+ Database.HaskellDB.HDBRec: instance [overlap ok] Eq r => Eq (Record r)

+ Database.HaskellDB.HDBRec: instance [overlap ok] HasField f r => HasField f (RecCons g a r)

+ Database.HaskellDB.HDBRec: instance [overlap ok] HasField f r => HasField f (Record r)

+ Database.HaskellDB.HDBRec: instance [overlap ok] Ord r => Ord (Record r)

+ Database.HaskellDB.HDBRec: instance [overlap ok] ReadRecRow r => Read (Record r)

+ Database.HaskellDB.HDBRec: instance [overlap ok] RecCat r1 r2 r3 => RecCat (RecCons f a r1) r2 (RecCons f a r3)

+ Database.HaskellDB.HDBRec: instance [overlap ok] RecCat r1 r2 r3 => RecCat (Record r1) (Record r2) (Record r3)

+ Database.HaskellDB.HDBRec: instance [overlap ok] SelectField f r a => Select (l f a) (Record r) a

+ Database.HaskellDB.HDBRec: instance [overlap ok] SelectField f r a => SelectField f (RecCons g b r) a

+ Database.HaskellDB.HDBRec: instance [overlap ok] SelectField f r a => SelectField f (Record r) a

+ Database.HaskellDB.HDBRec: instance [overlap ok] SetField f r a => SetField f (RecCons g b r) a

+ Database.HaskellDB.HDBRec: instance [overlap ok] SetField f r a => SetField f (Record r) a

+ Database.HaskellDB.HDBRec: instance [overlap ok] Show r => Show (Record r)

+ Database.HaskellDB.HDBRec: instance [overlap ok] ShowLabels r => ShowLabels (Record r)

+ Database.HaskellDB.HDBRec: instance [overlap ok] ShowRecRow r => ShowRecRow (Record r)

+ Database.HaskellDB.Query: instance [overlap ok] ConstantRecord r cr => ConstantRecord (Record r) (Record cr)

+ Database.HaskellDB.Query: instance [overlap ok] HasField f r => Select (Attr f a) (Rel r) (Expr a)

+ Database.HaskellDB.Query: instance [overlap ok] IsExpr tail => IsExpr (Expr a -> tail)

+ Database.HaskellDB.Query: instance [overlap ok] ShowConstant a => ShowConstant (Maybe a)

+ Database.HaskellDB.Query: instance [overlap ok] Size n => BStrToStr (Expr (BoundedString n)) (Expr String)

+ Database.HaskellDB.Query: instance [overlap ok] Size n => BStrToStr (Expr (Maybe (BoundedString n))) (Expr (Maybe String))

+ Database.HaskellDB.Query: instance [overlap ok] Size n => ShowConstant (BoundedString n)

- Database.HaskellDB: (!) :: (Select f r a) => r -> f -> a

+ Database.HaskellDB: (!) :: Select f r a => r -> f -> a

- Database.HaskellDB: (!.) :: (Select f r a) => r -> f -> a

+ Database.HaskellDB: (!.) :: Select f r a => r -> f -> a

- Database.HaskellDB: (.%.) :: (Num a) => Expr a -> Expr a -> Expr a

+ Database.HaskellDB: (.%.) :: Num a => Expr a -> Expr a -> Expr a

- Database.HaskellDB: (.*.) :: (Num a) => Expr a -> Expr a -> Expr a

+ Database.HaskellDB: (.*.) :: Num a => Expr a -> Expr a -> Expr a

- Database.HaskellDB: (.+.) :: (Num a) => Expr a -> Expr a -> Expr a

+ Database.HaskellDB: (.+.) :: Num a => Expr a -> Expr a -> Expr a

- Database.HaskellDB: (.-.) :: (Num a) => Expr a -> Expr a -> Expr a

+ Database.HaskellDB: (.-.) :: Num a => Expr a -> Expr a -> Expr a

- Database.HaskellDB: (./.) :: (Num a) => Expr a -> Expr a -> Expr a

+ Database.HaskellDB: (./.) :: Num a => Expr a -> Expr a -> Expr a

- Database.HaskellDB: (.<.) :: (Ord a) => Expr a -> Expr a -> Expr Bool

+ Database.HaskellDB: (.<.) :: Ord a => Expr a -> Expr a -> Expr Bool

- Database.HaskellDB: (.<=.) :: (Ord a) => Expr a -> Expr a -> Expr Bool

+ Database.HaskellDB: (.<=.) :: Ord a => Expr a -> Expr a -> Expr Bool

- Database.HaskellDB: (.<>.) :: (Eq a) => Expr a -> Expr a -> Expr Bool

+ Database.HaskellDB: (.<>.) :: Eq a => Expr a -> Expr a -> Expr Bool

- Database.HaskellDB: (.==.) :: (Eq a) => Expr a -> Expr a -> Expr Bool

+ Database.HaskellDB: (.==.) :: Eq a => Expr a -> Expr a -> Expr Bool

- Database.HaskellDB: (.>.) :: (Ord a) => Expr a -> Expr a -> Expr Bool

+ Database.HaskellDB: (.>.) :: Ord a => Expr a -> Expr a -> Expr Bool

- Database.HaskellDB: (.>=.) :: (Ord a) => Expr a -> Expr a -> Expr Bool

+ Database.HaskellDB: (.>=.) :: Ord a => Expr a -> Expr a -> Expr Bool

- Database.HaskellDB: (<<-) :: (ShowConstant a) => Attr f a -> a -> Record (RecCons f (Expr a) RecNil)

+ Database.HaskellDB: (<<-) :: ShowConstant a => Attr f a -> a -> Record (RecCons f (Expr a) RecNil)

- Database.HaskellDB: _in :: (Eq a) => Expr a -> [Expr a] -> Expr Bool

+ Database.HaskellDB: _in :: Eq a => Expr a -> [Expr a] -> Expr Bool

- Database.HaskellDB: _max :: (Ord a) => Expr a -> ExprAggr a

+ Database.HaskellDB: _max :: Ord a => Expr a -> ExprAggr a

- Database.HaskellDB: _min :: (Ord a) => Expr a -> ExprAggr a

+ Database.HaskellDB: _min :: Ord a => Expr a -> ExprAggr a

- Database.HaskellDB: _sum :: (Num a) => Expr a -> ExprAggr a

+ Database.HaskellDB: _sum :: Num a => Expr a -> ExprAggr a

- Database.HaskellDB: asc :: (HasField f r) => Rel r -> Attr f a -> OrderExpr

+ Database.HaskellDB: asc :: HasField f r => Rel r -> Attr f a -> OrderExpr

- Database.HaskellDB: avg :: (Num a) => Expr a -> ExprAggr a

+ Database.HaskellDB: avg :: Num a => Expr a -> ExprAggr a

- Database.HaskellDB: constVal :: (ShowConstant a) => a -> Expr (Maybe a)

+ Database.HaskellDB: constVal :: ShowConstant a => a -> Expr (Maybe a)

- Database.HaskellDB: constant :: (ShowConstant a) => a -> Expr a

+ Database.HaskellDB: constant :: ShowConstant a => a -> Expr a

- Database.HaskellDB: copy :: (HasField f r) => Attr f a -> Rel r -> Record (RecCons f (Expr a) RecNil)

+ Database.HaskellDB: copy :: HasField f r => Attr f a -> Rel r -> Record (RecCons f (Expr a) RecNil)

- Database.HaskellDB: copyAll :: (RelToRec r) => Rel r -> Record r

+ Database.HaskellDB: copyAll :: RelToRec r => Rel r -> Record r

- Database.HaskellDB: delete :: (ShowRecRow r) => Database -> Table r -> (Rel r -> Expr Bool) -> IO ()

+ Database.HaskellDB: delete :: ShowRecRow r => Database -> Table r -> (Rel r -> Expr Bool) -> IO ()

- Database.HaskellDB: desc :: (HasField f r) => Rel r -> Attr f a -> OrderExpr

+ Database.HaskellDB: desc :: HasField f r => Rel r -> Attr f a -> OrderExpr

- Database.HaskellDB: fromVal :: (ShowConstant a) => a -> Expr (Maybe a) -> Expr a

+ Database.HaskellDB: fromVal :: ShowConstant a => a -> Expr (Maybe a) -> Expr a

- Database.HaskellDB: func :: (Args a) => String -> a

+ Database.HaskellDB: func :: Args a => String -> a

- Database.HaskellDB: insertQuery :: (ShowRecRow r) => Database -> Table r -> Query (Rel r) -> IO ()

+ Database.HaskellDB: insertQuery :: ShowRecRow r => Database -> Table r -> Query (Rel r) -> IO ()

- Database.HaskellDB: query :: (GetRec er vr) => Database -> Query (Rel er) -> IO [Record vr]

+ Database.HaskellDB: query :: GetRec er vr => Database -> Query (Rel er) -> IO [Record vr]

- Database.HaskellDB: recCat :: (RecCat r1 r2 r3) => r1 -> r2 -> r3

+ Database.HaskellDB: recCat :: RecCat r1 r2 r3 => r1 -> r2 -> r3

- Database.HaskellDB: stddev :: (Num a) => Expr a -> ExprAggr a

+ Database.HaskellDB: stddev :: Num a => Expr a -> ExprAggr a

- Database.HaskellDB: stddevP :: (Num a) => Expr a -> ExprAggr a

+ Database.HaskellDB: stddevP :: Num a => Expr a -> ExprAggr a

- Database.HaskellDB: table :: (ShowRecRow r) => Table r -> Query (Rel r)

+ Database.HaskellDB: table :: ShowRecRow r => Table r -> Query (Rel r)

- Database.HaskellDB: toStr :: (BStrToStr s d) => s -> d

+ Database.HaskellDB: toStr :: BStrToStr s d => s -> d

- Database.HaskellDB: variance :: (Num a) => Expr a -> ExprAggr a

+ Database.HaskellDB: variance :: Num a => Expr a -> ExprAggr a

- Database.HaskellDB: varianceP :: (Num a) => Expr a -> ExprAggr a

+ Database.HaskellDB: varianceP :: Num a => Expr a -> ExprAggr a

- Database.HaskellDB.BoundedList: fromBounded :: (Size n) => BoundedList a n -> [a]

+ Database.HaskellDB.BoundedList: fromBounded :: Size n => BoundedList a n -> [a]

- Database.HaskellDB.BoundedList: grow :: (LessEq n m) => BoundedList a n -> BoundedList a m

+ Database.HaskellDB.BoundedList: grow :: LessEq n m => BoundedList a n -> BoundedList a m

- Database.HaskellDB.BoundedList: listBound :: (Size n) => BoundedList a n -> Int

+ Database.HaskellDB.BoundedList: listBound :: Size n => BoundedList a n -> Int

- Database.HaskellDB.BoundedList: toBounded :: (Size n) => [a] -> Maybe (BoundedList a n)

+ Database.HaskellDB.BoundedList: toBounded :: Size n => [a] -> Maybe (BoundedList a n)

- Database.HaskellDB.BoundedList: trunc :: (Size n) => [a] -> BoundedList a n

+ Database.HaskellDB.BoundedList: trunc :: Size n => [a] -> BoundedList a n

- Database.HaskellDB.DBLayout: fieldName :: (FieldTag f) => f -> String

+ Database.HaskellDB.DBLayout: fieldName :: FieldTag f => f -> String

- Database.HaskellDB.DBLayout: hdbMakeEntry :: (FieldTag f) => f -> Record (RecCons f (Expr a) RecNil)

+ Database.HaskellDB.DBLayout: hdbMakeEntry :: FieldTag f => f -> Record (RecCons f (Expr a) RecNil)

- Database.HaskellDB.DBLayout: mkAttr :: (FieldTag f) => f -> Attr f a

+ Database.HaskellDB.DBLayout: mkAttr :: FieldTag f => f -> Attr f a

- Database.HaskellDB.DBSpec.PPHelpers: split :: (Eq a) => (a -> Bool) -> [a] -> [[a]]

+ Database.HaskellDB.DBSpec.PPHelpers: split :: Eq a => (a -> Bool) -> [a] -> [[a]]

- Database.HaskellDB.Database: (!.) :: (Select f r a) => r -> f -> a

+ Database.HaskellDB.Database: (!.) :: Select f r a => r -> f -> a

- Database.HaskellDB.Database: Database :: (forall er vr. (GetRec er vr) => PrimQuery -> Rel er -> IO [Record vr]) -> (TableName -> Assoc -> IO ()) -> (TableName -> PrimQuery -> IO ()) -> (TableName -> [PrimExpr] -> IO ()) -> (TableName -> [PrimExpr] -> Assoc -> IO ()) -> IO [TableName] -> (TableName -> IO [(Attribute, FieldDesc)]) -> (forall a. IO a -> IO a) -> (String -> IO ()) -> (TableName -> [(Attribute, FieldDesc)] -> IO ()) -> (String -> IO ()) -> (TableName -> IO ()) -> Database

+ Database.HaskellDB.Database: Database :: (forall er vr. GetRec er vr => PrimQuery -> Rel er -> IO [Record vr]) -> (TableName -> Assoc -> IO ()) -> (TableName -> PrimQuery -> IO ()) -> (TableName -> [PrimExpr] -> IO ()) -> (TableName -> [PrimExpr] -> Assoc -> IO ()) -> IO [TableName] -> (TableName -> IO [(Attribute, FieldDesc)]) -> (forall a. IO a -> IO a) -> (String -> IO ()) -> (TableName -> [(Attribute, FieldDesc)] -> IO ()) -> (String -> IO ()) -> (TableName -> IO ()) -> Database

- Database.HaskellDB.Database: dbQuery :: Database -> forall er vr. (GetRec er vr) => PrimQuery -> Rel er -> IO [Record vr]

+ Database.HaskellDB.Database: dbQuery :: Database -> forall er vr. GetRec er vr => PrimQuery -> Rel er -> IO [Record vr]

- Database.HaskellDB.Database: delete :: (ShowRecRow r) => Database -> Table r -> (Rel r -> Expr Bool) -> IO ()

+ Database.HaskellDB.Database: delete :: ShowRecRow r => Database -> Table r -> (Rel r -> Expr Bool) -> IO ()

- Database.HaskellDB.Database: getRec :: (GetRec er vr) => GetInstances s -> Rel er -> Scheme -> s -> IO (Record vr)

+ Database.HaskellDB.Database: getRec :: GetRec er vr => GetInstances s -> Rel er -> Scheme -> s -> IO (Record vr)

- Database.HaskellDB.Database: insertQuery :: (ShowRecRow r) => Database -> Table r -> Query (Rel r) -> IO ()

+ Database.HaskellDB.Database: insertQuery :: ShowRecRow r => Database -> Table r -> Query (Rel r) -> IO ()

- Database.HaskellDB.Database: query :: (GetRec er vr) => Database -> Query (Rel er) -> IO [Record vr]

+ Database.HaskellDB.Database: query :: GetRec er vr => Database -> Query (Rel er) -> IO [Record vr]

- Database.HaskellDB.DriverAPI: DriverInterface :: (forall m a. (MonadIO m) => [(String, String)] -> (Database -> m a) -> m a) -> [(String, String)] -> DriverInterface

+ Database.HaskellDB.DriverAPI: DriverInterface :: (forall m a. MonadIO m => [(String, String)] -> (Database -> m a) -> m a) -> [(String, String)] -> DriverInterface

- Database.HaskellDB.DriverAPI: class (Monad m) => MonadIO m :: (* -> *)

+ Database.HaskellDB.DriverAPI: class Monad m => MonadIO m :: (* -> *)

- Database.HaskellDB.DriverAPI: connect :: DriverInterface -> forall m a. (MonadIO m) => [(String, String)] -> (Database -> m a) -> m a

+ Database.HaskellDB.DriverAPI: connect :: DriverInterface -> forall m a. MonadIO m => [(String, String)] -> (Database -> m a) -> m a

- Database.HaskellDB.DriverAPI: getAnnotatedOptions :: (Monad m) => [(String, String)] -> [(String, String)] -> m [String]

+ Database.HaskellDB.DriverAPI: getAnnotatedOptions :: Monad m => [(String, String)] -> [(String, String)] -> m [String]

- Database.HaskellDB.DriverAPI: getGenerator :: (Monad m) => [(String, String)] -> m SqlGenerator

+ Database.HaskellDB.DriverAPI: getGenerator :: Monad m => [(String, String)] -> m SqlGenerator

- Database.HaskellDB.DriverAPI: getOptions :: (Monad m) => [String] -> [(String, String)] -> m [String]

+ Database.HaskellDB.DriverAPI: getOptions :: Monad m => [String] -> [(String, String)] -> m [String]

- Database.HaskellDB.FieldType: fromHaskellType :: (ExprType e) => e -> FieldDesc

+ Database.HaskellDB.FieldType: fromHaskellType :: ExprType e => e -> FieldDesc

- Database.HaskellDB.FieldType: fromHaskellTypes :: (ExprTypes r) => r -> [FieldDesc]

+ Database.HaskellDB.FieldType: fromHaskellTypes :: ExprTypes r => r -> [FieldDesc]

- Database.HaskellDB.HDBRec: (!) :: (Select f r a) => r -> f -> a

+ Database.HaskellDB.HDBRec: (!) :: Select f r a => r -> f -> a

- Database.HaskellDB.HDBRec: fieldName :: (FieldTag f) => f -> String

+ Database.HaskellDB.HDBRec: fieldName :: FieldTag f => f -> String

- Database.HaskellDB.HDBRec: readRecRow :: (ReadRecRow r) => [(String, String)] -> [(r, [(String, String)])]

+ Database.HaskellDB.HDBRec: readRecRow :: ReadRecRow r => [(String, String)] -> [(r, [(String, String)])]

- Database.HaskellDB.HDBRec: recCat :: (RecCat r1 r2 r3) => r1 -> r2 -> r3

+ Database.HaskellDB.HDBRec: recCat :: RecCat r1 r2 r3 => r1 -> r2 -> r3

- Database.HaskellDB.HDBRec: recordLabels :: (ShowLabels r) => r -> [String]

+ Database.HaskellDB.HDBRec: recordLabels :: ShowLabels r => r -> [String]

- Database.HaskellDB.HDBRec: setField :: (SetField f r a) => l f a -> a -> r -> r

+ Database.HaskellDB.HDBRec: setField :: SetField f r a => l f a -> a -> r -> r

- Database.HaskellDB.HDBRec: showRecRow :: (ShowRecRow r) => r -> [(String, ShowS)]

+ Database.HaskellDB.HDBRec: showRecRow :: ShowRecRow r => r -> [(String, ShowS)]

- Database.HaskellDB.Query: (.%.) :: (Num a) => Expr a -> Expr a -> Expr a

+ Database.HaskellDB.Query: (.%.) :: Num a => Expr a -> Expr a -> Expr a

- Database.HaskellDB.Query: (.*.) :: (Num a) => Expr a -> Expr a -> Expr a

+ Database.HaskellDB.Query: (.*.) :: Num a => Expr a -> Expr a -> Expr a

- Database.HaskellDB.Query: (.+.) :: (Num a) => Expr a -> Expr a -> Expr a

+ Database.HaskellDB.Query: (.+.) :: Num a => Expr a -> Expr a -> Expr a

- Database.HaskellDB.Query: (.-.) :: (Num a) => Expr a -> Expr a -> Expr a

+ Database.HaskellDB.Query: (.-.) :: Num a => Expr a -> Expr a -> Expr a

- Database.HaskellDB.Query: (./.) :: (Num a) => Expr a -> Expr a -> Expr a

+ Database.HaskellDB.Query: (./.) :: Num a => Expr a -> Expr a -> Expr a

- Database.HaskellDB.Query: (.<.) :: (Ord a) => Expr a -> Expr a -> Expr Bool

+ Database.HaskellDB.Query: (.<.) :: Ord a => Expr a -> Expr a -> Expr Bool

- Database.HaskellDB.Query: (.<=.) :: (Ord a) => Expr a -> Expr a -> Expr Bool

+ Database.HaskellDB.Query: (.<=.) :: Ord a => Expr a -> Expr a -> Expr Bool

- Database.HaskellDB.Query: (.<>.) :: (Eq a) => Expr a -> Expr a -> Expr Bool

+ Database.HaskellDB.Query: (.<>.) :: Eq a => Expr a -> Expr a -> Expr Bool

- Database.HaskellDB.Query: (.==.) :: (Eq a) => Expr a -> Expr a -> Expr Bool

+ Database.HaskellDB.Query: (.==.) :: Eq a => Expr a -> Expr a -> Expr Bool

- Database.HaskellDB.Query: (.>.) :: (Ord a) => Expr a -> Expr a -> Expr Bool

+ Database.HaskellDB.Query: (.>.) :: Ord a => Expr a -> Expr a -> Expr Bool

- Database.HaskellDB.Query: (.>=.) :: (Ord a) => Expr a -> Expr a -> Expr Bool

+ Database.HaskellDB.Query: (.>=.) :: Ord a => Expr a -> Expr a -> Expr Bool

- Database.HaskellDB.Query: (<<-) :: (ShowConstant a) => Attr f a -> a -> Record (RecCons f (Expr a) RecNil)

+ Database.HaskellDB.Query: (<<-) :: ShowConstant a => Attr f a -> a -> Record (RecCons f (Expr a) RecNil)

- Database.HaskellDB.Query: _in :: (Eq a) => Expr a -> [Expr a] -> Expr Bool

+ Database.HaskellDB.Query: _in :: Eq a => Expr a -> [Expr a] -> Expr Bool

- Database.HaskellDB.Query: _max :: (Ord a) => Expr a -> ExprAggr a

+ Database.HaskellDB.Query: _max :: Ord a => Expr a -> ExprAggr a

- Database.HaskellDB.Query: _min :: (Ord a) => Expr a -> ExprAggr a

+ Database.HaskellDB.Query: _min :: Ord a => Expr a -> ExprAggr a

- Database.HaskellDB.Query: _sum :: (Num a) => Expr a -> ExprAggr a

+ Database.HaskellDB.Query: _sum :: Num a => Expr a -> ExprAggr a

- Database.HaskellDB.Query: asc :: (HasField f r) => Rel r -> Attr f a -> OrderExpr

+ Database.HaskellDB.Query: asc :: HasField f r => Rel r -> Attr f a -> OrderExpr

- Database.HaskellDB.Query: avg :: (Num a) => Expr a -> ExprAggr a

+ Database.HaskellDB.Query: avg :: Num a => Expr a -> ExprAggr a

- Database.HaskellDB.Query: class (ExprC e) => ProjectExpr e

+ Database.HaskellDB.Query: class ExprC e => ProjectExpr e

- Database.HaskellDB.Query: constVal :: (ShowConstant a) => a -> Expr (Maybe a)

+ Database.HaskellDB.Query: constVal :: ShowConstant a => a -> Expr (Maybe a)

- Database.HaskellDB.Query: constant :: (ShowConstant a) => a -> Expr a

+ Database.HaskellDB.Query: constant :: ShowConstant a => a -> Expr a

- Database.HaskellDB.Query: constantRecord :: (ConstantRecord r cr) => r -> cr

+ Database.HaskellDB.Query: constantRecord :: ConstantRecord r cr => r -> cr

- Database.HaskellDB.Query: copy :: (HasField f r) => Attr f a -> Rel r -> Record (RecCons f (Expr a) RecNil)

+ Database.HaskellDB.Query: copy :: HasField f r => Attr f a -> Rel r -> Record (RecCons f (Expr a) RecNil)

- Database.HaskellDB.Query: copyAll :: (RelToRec r) => Rel r -> Record r

+ Database.HaskellDB.Query: copyAll :: RelToRec r => Rel r -> Record r

- Database.HaskellDB.Query: desc :: (HasField f r) => Rel r -> Attr f a -> OrderExpr

+ Database.HaskellDB.Query: desc :: HasField f r => Rel r -> Attr f a -> OrderExpr

- Database.HaskellDB.Query: exprs :: (ToPrimExprs r) => Record r -> [PrimExpr]

+ Database.HaskellDB.Query: exprs :: ToPrimExprs r => Record r -> [PrimExpr]

- Database.HaskellDB.Query: fromVal :: (ShowConstant a) => a -> Expr (Maybe a) -> Expr a

+ Database.HaskellDB.Query: fromVal :: ShowConstant a => a -> Expr (Maybe a) -> Expr a

- Database.HaskellDB.Query: func :: (Args a) => String -> a

+ Database.HaskellDB.Query: func :: Args a => String -> a

- Database.HaskellDB.Query: labels :: (ShowLabels r) => r -> [String]

+ Database.HaskellDB.Query: labels :: ShowLabels r => r -> [String]

- Database.HaskellDB.Query: select :: (HasField f r) => Attr f a -> Rel r -> Expr a

+ Database.HaskellDB.Query: select :: HasField f r => Attr f a -> Rel r -> Expr a

- Database.HaskellDB.Query: stddev :: (Num a) => Expr a -> ExprAggr a

+ Database.HaskellDB.Query: stddev :: Num a => Expr a -> ExprAggr a

- Database.HaskellDB.Query: stddevP :: (Num a) => Expr a -> ExprAggr a

+ Database.HaskellDB.Query: stddevP :: Num a => Expr a -> ExprAggr a

- Database.HaskellDB.Query: table :: (ShowRecRow r) => Table r -> Query (Rel r)

+ Database.HaskellDB.Query: table :: ShowRecRow r => Table r -> Query (Rel r)

- Database.HaskellDB.Query: toStr :: (BStrToStr s d) => s -> d

+ Database.HaskellDB.Query: toStr :: BStrToStr s d => s -> d

- Database.HaskellDB.Query: variance :: (Num a) => Expr a -> ExprAggr a

+ Database.HaskellDB.Query: variance :: Num a => Expr a -> ExprAggr a

- Database.HaskellDB.Query: varianceP :: (Num a) => Expr a -> ExprAggr a

+ Database.HaskellDB.Query: varianceP :: Num a => Expr a -> ExprAggr a

Files

LICENSE +31/−0
haskelldb.cabal +11/−5

+ LICENSE view

@@ -0,0 +1,31 @@+Copyright (c) 1999 Daan Leijen, daan@cs.uu.nl+Copyright (c) 2003-2004 The HaskellDB development team+All rights reserved.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are+met:++    * Redistributions of source code must retain the above copyright+      notice, this list of conditions and the following disclaimer.++    * Redistributions in binary form must reproduce the above+      copyright notice, this list of conditions and the following+      disclaimer in the documentation and/or other materials provided+      with the distribution.++    * Neither the names of the copyright holders nor the names of the+      contributors may be used to endorse or promote products derived+      from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

haskelldb.cabal view

@@ -1,5 +1,5 @@ Name: haskelldb-Version: 2.0.1.1+Version: 2.1.0 Cabal-version: >= 1.6 Build-type: Simple Homepage: http://trac.haskell.org/haskelldb@@ -7,13 +7,19 @@ Maintainer: "Justin Bailey" <jgbailey@gmail.com> Author: Daan Leijen, Conny Andersson, Martin Andersson, Mary Bergman, Victor Blomqvist, Bjorn Bringert, Anders Hockersten, Torbjorn Martin, Jeremy Shaw, Justin Bailey License: BSD3+License-file: LICENSE Synopsis: A library of combinators for generating and executing SQL statements.--Flag split-base+Description: This library allows you to build SQL SELECT, INSERT, UPDATE, and DELETE +             statements using operations based on the relational algebra. +Category: Database  Library-  Build-depends: mtl >= 1.1 && < 2-  Build-depends: base >= 3 && < 5, pretty >= 1 && < 2, old-time >= 1 && < 2, old-locale >= 1 && < 2, directory >= 1 && < 2,+  Build-depends: mtl >= 1.1 && < 2.1, +                 base >= 3 && < 5, +                 pretty >= 1 && < 2, +                 old-time >= 1 && < 2, +                 old-locale >= 1 && < 2, +                 directory >= 1 && < 2,                  containers >= 0.3 && < 1   Extensions:     EmptyDataDecls,