Books Haskell

✓ Haskell's most popular database module is HDBC. HDBC provides an abstraction layer between Haskell programs and SQL relational databases. This lets you write database code once, in Haskell, and have it work with a number of backend SQL databases.

✓ HDBC is modeled loosely on Perl's DBI interface, though it has also been influenced by Python's DB-API v2, JDBC in Java, and HSQL in Haskell. As DBI requires DBD in Perl, HDBC requires a driver module beneath it to work. These HDBC backend drivers exist: PostgreSQL, SQLite, and ODBC (for Windows and Unix/Linux/Mac). MySQL is the most popular open-sourced database, and there are two drivers for MySQL: HDBC-mysql (native) and HDBC-odbc (ODBC). MySQL users can use the ODBC driver on any MySQL-supported platform, including Linux. An advantage of using ODBC is that the syntax of the SQL statement is insulated from the different kinds of database engines. This increases the portability of the application should you have to move from one database to another. The same argument for preferring ODBC applies for other commercial databases, such as Oracle and DB2

✓ Database
✓ Truth values
✓ Understanding monads/State
✓ Continuation passing style
✓ YAHT/Complexity
✓ Syntactic sugar
✓ RegExp
✓ Variables and functions
✓ YAHT/Io/Solutions
✓ Solutions/Control structures
✓ Monad transformers
✓ Recursion
✓ Debugging
✓ Beginning
✓ YAHT/Type advanced/Solutions
✓ Solutions/Laziness
✓ YAHT/Preamble
✓ Overview
✓ Type basics
✓ Indentation
✓ Performance Introduction
✓ YAHT/Modules/Solutions
✓ Solutions/Next steps
✓ Testing
✓ GUI
✓ Hierarchical libraries
✓ YAHT/Io advanced
✓ Preliminaries
✓ Solutions/Variables and functions
✓ List processing
✓ Time and space profiling
✓ List of topics
✓ Laziness
✓ YAHT/Recursion
✓ Hierarchical libraries/Arrays
✓ Polymorphism
✓ Style conventions
✓ Solutions/More on functions
✓ Solutions/Understanding arrows
✓ Using GHCi effectively
✓ Applications
✓ Hierarchical libraries/IO
✓ YAHT/Type basics/Solutions
✓ Performance Examples
✓ YAHT/Getting started
✓ YAHT/Language advanced
✓ Strictness
✓ Control structures
✓ Solutions/Indentation
✓ Mutable objects
✓ Understanding monads
✓ StephensArrowTutorial
✓ YAHT/Type basics
✓ Type basics II
✓ Type declarations
✓ Understanding monads/Maybe
✓ Modules
✓ Pattern matching
✓ YAHT/Language advanced/Solutions
✓ The Curry-Howard isomorphism
✓ Notes for contributors
✓ Graph reduction
✓ Understanding arrows
✓ Solutions/Lists and tuples
✓ Simple input and output
✓ Hierarchical libraries/Maybe
✓ Classes and types
✓ YAHT/Errata
✓ The Functor class
✓ Experimental Modules
✓ YAHT/Language basics
✓ Understanding monads/List
✓ YAHT/Monads/Solutions
✓ Recursion
✓ YAHT/Language basics/Solutions
✓ Monoids
✓ More on datatypes
✓ Category:Solutions
✓ Monadic parser combinators
✓ Applicative Functors
✓ Arrows
✓ Next steps
✓ YAHT/Introduction
✓ Zippers
✓ More about lists
✓ Category theory
✓ Modules
✓ SYB
✓ Solutions/Higher-order functions and Currying
✓ Solutions/Type basics
✓ To do
✓ Solutions/Understanding monads
✓ Other data structures
✓ Denotational semantics
✓ Hierarchical libraries/Randoms
✓ Getting set up
✓ YAHT/Io
✓ Continuation passing style
✓ GADT
✓ Graph reduction
✓ YAHT
✓ Fix and recursion
✓ Kinds
✓ do Notation
✓ Arrows
✓ YAHT/Modules
✓ XML
✓ More on functions
✓ Advanced type classes
✓ Applications
✓ Haskell
✓ Higher-order functions and Currying
✓ Web programming
✓ Lists and tuples
✓ Concurrency
✓ YAHT/Monads
✓ Solutions/Simple input and output
✓ Solutions/More about lists
✓ Denotational semantics
✓ FFI
✓ Algorithm complexity
✓ Experimental Modules/Cheat sheet prototype 1
✓ YAHT/Type advanced
✓ Polymorphism
✓ Solutions/Monad transformers
✓ Existentially quantified types
✓ Solutions/Denotational semantics
✓ Packaging
✓ Hierarchical libraries/Maps
✓ Hierarchical libraries
✓ Practical monads
✓ Solutions/Applicative Functors
✓ Haskell
✓ Phantom types
✓ Hierarchical libraries/Lists
✓ MonadPlus
✓ GUI
✓ Solutions/Pattern matching
✓ ParseExps