We're going to use jQuery for the Javascript, though anything would work just fine. Also, the AJAX responses will be served as JSON. Let's get started.
-> {-# LANGUAGE TypeFamilies, QuasiQuotes, TemplateHaskell, MultiParamTypeClasses #-} +> {-# LANGUAGE TypeFamilies, QuasiQuotes, TemplateHaskell, MultiParamTypeClasses, OverloadedStrings #-} > import Yesod > import Yesod.Helpers.Static > import Data.Monoid (mempty) diff --git a/src/blog.lhs b/src/blog.lhs --- a/src/blog.lhs +++ b/src/blog.lhs @@ -2,7 +2,7 @@This file is literate Haskell, so we'll start off with our language pragmas and import statements. Basically every Yesod application will start off like this:
-> {-# LANGUAGE TypeFamilies, QuasiQuotes, TemplateHaskell, MultiParamTypeClasses #-} +> {-# LANGUAGE TypeFamilies, QuasiQuotes, TemplateHaskell, MultiParamTypeClasses, OverloadedStrings #-} > import Yesod Next, we'll define the blog entry information. Usually, we would want to store the data in a database and allow users to modify them, but we'll simplify for the moment. @@ -29,7 +29,7 @@ Now we use the first "magical" Yesod set of functions: mkYesod and parseRoutes. If you want to see *exactly* what they do, look at their Haddock docs. For now, we'll try to keep this tutorial simple: -> mkYesod "Blog" [$parseRoutes| +> mkYesod "Blog" [parseRoutes| > / HomeR GET > /entry/#String EntryR GET > |] @@ -68,7 +68,7 @@ And now the template itself: > entryTemplate :: TemplateArgs -> Hamlet (Route Blog) -> entryTemplate args = [$hamlet| +> entryTemplate args = [hamlet| > !!! > > @@ -97,8 +97,8 @@ > (entry:_) -> do > let nav = reverse $ map toNav entries > let tempArgs = TemplateArgs -> { templateTitle = string $ entryTitle entry -> , templateContent = string $ entryContent entry +> { templateTitle = toHtml $ entryTitle entry +> , templateContent = toHtml $ entryContent entry > , templateNavbar = nav > } > hamletToRepHtml $ entryTemplate tempArgs @@ -106,7 +106,7 @@ > toNav :: Entry -> Nav > toNav e = Nav > { navUrl = EntryR $ entrySlug e -> , navTitle = string $ entryTitle e +> , navTitle = toHtml $ entryTitle e > } All that's left now is the main function. Yesod is built on top of WAI, so you can use any WAI handler you wish. For the tutorials, we'll use the basicHandler that comes built-in with Yesod: it serves content via CGI if the appropriate environment variables are available, otherwise with simpleserver. diff --git a/src/chat.hs b/src/chat.hs --- a/src/chat.hs +++ b/src/chat.hs @@ -1,6 +1,7 @@ {-# LANGUAGE TemplateHaskell, QuasiQuotes, TypeFamilies #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE OverloadedStrings #-} module Main where @@ -12,9 +13,10 @@ import Control.Concurrent.STM.TVar import Control.Arrow ((***)) +import Data.Text (Text, unpack) -- speaker and content -data Message = Message String String +data Message = Message Text Text type Handler yesod = GHandler yesod yesod @@ -87,7 +89,7 @@ c <- lookupGetParam "client" case c of Nothing -> invalidArgs ["No client value in Check request"] - Just c' -> return $ read c' + Just c' -> return $ read $ unpack c' cs <- liftIO . atomically $ readTVar clients chan <- case lookup client cs of Nothing -> invalidArgs ["Bad client value"] @@ -97,7 +99,7 @@ let Message s c = first jsonToRepJson $ zipJson ["sender", "content"] [s,c] -zipJson x y = jsonMap $ map (id *** jsonScalar) $ zip x y +zipJson x y = jsonMap $ map (unpack *** jsonScalar . unpack) $ zip x y getPostR :: Handler Chat RepJson getPostR = do diff --git a/src/file-echo.lhs b/src/file-echo.lhs --- a/src/file-echo.lhs +++ b/src/file-echo.lhs @@ -1,8 +1,9 @@ -> {-# LANGUAGE TypeFamilies, QuasiQuotes, TemplateHaskell, MultiParamTypeClasses #-} +> {-# LANGUAGE TypeFamilies, QuasiQuotes, TemplateHaskell, MultiParamTypeClasses, OverloadedStrings #-} > import Yesod > import Data.Monoid (mempty) > import qualified Data.ByteString.Char8 as S8 +> import qualified Data.Text as T > data Echo = Echo @@ -24,6 +25,6 @@ > postHomepage = do > (_, files) <- runRequestBody > fi <- maybe notFound return $ lookup "file" files -> return [(S8.pack $ fileContentType fi, toContent $ fileContent fi)] +> return [(S8.pack $ T.unpack $ fileContentType fi, toContent $ fileContent fi)] > main = warpDebug 3000 Echo diff --git a/src/form.lhs b/src/form.lhs --- a/src/form.lhs +++ b/src/form.lhs @@ -1,9 +1,11 @@Forms can be a tedious part of web development since they require synchronization of code in many different areas: the HTML form declaration, parsing of the form and reconstructing a datatype from the raw values. The Yesod form library simplifies things greatly. We'll start off with a basic application.
-> {-# LANGUAGE TypeFamilies, QuasiQuotes, OverloadedStrings, MultiParamTypeClasses #-} +> {-# LANGUAGE TypeFamilies, QuasiQuotes, OverloadedStrings, MultiParamTypeClasses, TemplateHaskell #-} > import Yesod > import Control.Applicative +> import Data.Text (Text) + > data FormExample = FormExample > type Handler = GHandler FormExample FormExample > mkYesod "FormExample" [$parseRoutes| @@ -13,7 +15,7 @@ Next, we'll declare a Person datatype with a name and age. After that, we'll create a formlet. A formlet is a declarative approach to forms. It takes a Maybe value and constructs either a blank form, a form based on the original value, or a form based on the values submitted by the user. It also attempts to construct a datatype, failing on validation errors. -> data Person = Person { name :: String, age :: Int } +> data Person = Person { name :: Text, age :: Int } > deriving Show > personFormlet p = fieldsToTable $ Person > <$> stringField "Name" (fmap name p) diff --git a/src/generalized-hamlet.lhs b/src/generalized-hamlet.lhs --- a/src/generalized-hamlet.lhs +++ b/src/generalized-hamlet.lhs @@ -11,7 +11,7 @@ This example uses all three. You are of course free in your own code to make your own instances. -> {-# LANGUAGE QuasiQuotes, TypeFamilies, MultiParamTypeClasses #-} +> {-# LANGUAGE QuasiQuotes, TypeFamilies, MultiParamTypeClasses, OverloadedStrings, TemplateHaskell #-} > import Yesod > data NewHamlet = NewHamlet > mkYesod "NewHamlet" [$parseRoutes|/ RootR GET|] diff --git a/src/i18n.lhs b/src/i18n.lhs --- a/src/i18n.lhs +++ b/src/i18n.lhs @@ -2,16 +2,18 @@ > {-# LANGUAGE TemplateHaskell #-} > {-# LANGUAGE TypeFamilies #-} > {-# LANGUAGE MultiParamTypeClasses #-} +> {-# LANGUAGE OverloadedStrings #-} > import Yesod > import Data.Monoid (mempty) +> import Data.Text (Text) > data I18N = I18N > type Handler = GHandler I18N I18N > mkYesod "I18N" [$parseRoutes| > / HomepageR GET -> /set/#String SetLangR GET +> /set/#Text SetLangR GET > |] > instance Yesod I18N where @@ -22,12 +24,12 @@ > ls <- languages > let hello = chooseHello ls > let choices = -> [ ("en", "English") +> [ ("en", "English") :: (Text, Text) > , ("es", "Spanish") > , ("he", "Hebrew") > ] > defaultLayout $ do -> setTitle $ string "I18N Homepage" +> setTitle "I18N Homepage" > addHamlet [$hamlet| >In other languages:
@@ -37,13 +39,13 @@
> #{snd choice}
> |]
-> chooseHello :: [String] -> String
+> chooseHello :: [Text] -> Text
> chooseHello [] = "Hello"
-> chooseHello ("he":_) = "שלום"
+> chooseHello ("he":_) = "Shalom"
> chooseHello ("es":_) = "Hola"
> chooseHello (_:rest) = chooseHello rest
-> getSetLangR :: String -> Handler ()
+> getSetLangR :: Text -> Handler ()
> getSetLangR lang = do
> setLanguage lang
> redirect RedirectTemporary HomepageR
diff --git a/src/pretty-yaml.lhs b/src/pretty-yaml.lhs
--- a/src/pretty-yaml.lhs
+++ b/src/pretty-yaml.lhs
@@ -1,6 +1,6 @@
This example uses the data-object-yaml package to display YAML files as cleaned-up HTML. If you've read through the other tutorials, this one should be easy to follow.