### Lucius Runtime: Dynamic CSS Generation in Haskell

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Explains how to use `luciusRT` and `luciusRTMixin` for parsing and rendering Lucius templates at runtime. This allows for dynamic CSS generation with variable substitution and the inclusion of mixins, returning either the generated CSS or an error message.

```haskell
import Text.Lucius
import qualified Data.Text as T
import qualified Data.Text.Lazy as TL

-- Runtime template parsing
generateCSS :: T.Text -> T.Text -> Either String TL.Text
generateCSS primaryColor fontSize =
    luciusRT template variables
  where
    template = TL.pack "body { color: #{primary}; font-size: #{size}; }"
    variables =
        [ (T.pack "primary", primaryColor)
        , (T.pack "size", fontSize)
        ]

-- With mixins at runtime
generateWithMixin :: Mixin -> Either String TL.Text
generateWithMixin theMixin =
    luciusRTMixin
        (TL.pack ".styled { ^{mixin} }")
        True  -- minify output
        [(T.pack "mixin", RTVMixin theMixin)]

main :: IO ()
main = case generateCSS (T.pack "#333") (T.pack "16px") of
    Left err -> putStrLn $ "Error: " ++ err
    Right css -> TL.putStrLn css
-- Output: "body {\n    color: #333;\n    font-size: 16px;\n}\n"

```

--------------------------------

### Lucius: CSS with Variables and Nesting in Haskell

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Demonstrates the Lucius quasi-quoter for writing CSS with variable interpolation and nesting directly within Haskell code. It requires the QuasiQuotes language extension and imports from Text.Lucius. The output is rendered using renderCssUrl.

```haskell
{-# LANGUAGE QuasiQuotes #-}
import Text.Lucius
import Data.Text (Text, pack)
import qualified Data.Text.Lazy as TL

data MyRoute = StaticR String

renderUrl :: MyRoute -> [(Text, Text)] -> Text
renderUrl (StaticR path) _ = pack $ "/static/" ++ path

-- CSS with variables and nesting
styles :: CssUrl MyRoute
styles = [lucius|
    @primaryColor: #3498db;
    @secondaryColor: #2ecc71;

    body {
        font-family: sans-serif;
        background: #{colorBlack};
    }

    .container {
        max-width: 1200px;
        margin: 0 auto;

        .header {
            background: #{primaryColor};
            color: white;

            a {
                color: #{secondaryColor};
                &:hover {
                    text-decoration: underline;
                }
            }
        }
    }

    @media (max-width: 768px) {
        .container {
            padding: 10px;
        }
    }
|]

main :: IO ()
main = TL.putStrLn $ renderCssUrl renderUrl styles

```

--------------------------------

### Hamlet Maybe Handling: $maybe/$nothing

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Renders a welcome message for a logged-in user or a login prompt if the user is not present. It utilizes the $maybe and $nothing directives to handle `Maybe` types.

```haskell
-- Maybe handling with $maybe/$nothing
renderProfile :: Maybe User -> String
renderProfile muser = renderHtml [shamlet|
$maybe user <- muser
    <div>Welcome back, #{userName user}!
$nothing
    <div>Please log in.
|]
```

--------------------------------

### CSS Utilities with Lucius in Haskell

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Illustrates the use of Lucius for type-safe CSS generation in Haskell. It showcases built-in color types and functions for creating size-based CSS properties, ensuring type correctness and preventing common CSS errors at compile time.

```haskell
#!/usr/bin/env runhaskell
{-# LANGUAGE QuasiQuotes #-}
import Text.Lucius

-- Built-in Color type
-- Color constructor takes RGB values (0-255)
styles :: CssUrl url
styles = [lucius|
    .success {
        color: #{colorRed};           /* #F00 */
        background: #{colorBlack};     /* #000 */
        border-color: #{Color 127 100 5};  /* #7F6405 */
    }
|
]

-- Size utilities
sizedStyles :: CssUrl url
sizedStyles = [lucius|
    .box {
        width: #{mkSize 100 "px"};
        height: #{absoluteSize 50 Centimeter};
        padding: #{EmSize 2};
        margin: #{percentageSize 10};
        font-size: #{PixelSize 16};
    }
|
]

-- Available size types:
-- PixelSize Int        -> "16px"
-- EmSize Double        -> "1.5em"
-- ExSize Double        -> "2ex"
-- PercentageSize Int   -> "50%"
-- AbsoluteSize Double AbsoluteUnit -> "10cm"
-- AbsoluteUnit = Centimeter | Millimeter | Inch | Point | Pica

```

--------------------------------

### Hamlet Loops: $forall

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Generates an unordered list of user names and ages using the $forall directive for iteration. Each user in the input list is rendered as a list item.

```haskell
-- Looping with $forall
renderUsers :: [User] -> String
renderUsers users = renderHtml [shamlet|
<ul>
    $forall user <- users
        <li>#{userName user} (#{show $ userAge user} years old)
|]
```

--------------------------------

### Internationalization with RenderMessage in Haskell

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Demonstrates how to implement the RenderMessage type class for custom message types in Haskell for internationalization. It shows how to define instances for different languages and handle default messages, integrating with Hamlet templates for localized content.

```haskell
#!/usr/bin/env runhaskell
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
import Text.Shakespeare.I18N
import Data.Text (Text)

-- Custom message type with manual RenderMessage instance
data CustomMsg = Greeting | Farewell | UserCount Int

data MyApp = MyApp

instance RenderMessage MyApp CustomMsg where
    renderMessage _ ("de":_) Greeting = "Guten Tag"
    renderMessage _ ("de":_) Farewell = "Tschüss"
    renderMessage _ ("de":_) (UserCount n) = pack $ show n ++ " Benutzer"
    renderMessage _ ("fr":_) Greeting = "Bonjour"
    renderMessage _ ("fr":_) Farewell = "Au revoir"
    renderMessage _ ("fr":_) (UserCount n) = pack $ show n ++ " utilisateurs"
    -- Default to English
    renderMessage _ _ Greeting = "Hello"
    renderMessage _ _ Farewell = "Goodbye"
    renderMessage _ _ (UserCount n) = pack $ show n ++ " users"

-- Combining with ihamlet
page :: HtmlUrlI18n CustomMsg MyRoute
page = [ihamlet|
<h1>_{Greeting}
<p>_{UserCount 42}
<footer>_{Farewell}
|]

```

--------------------------------

### Lucius Mixins: Reusable CSS Blocks in Haskell

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Shows how to define and use reusable CSS blocks (mixins) with the `luciusMixin` quasi-quoter. Mixins can be parameterized and embedded into other CSS templates using the `^{mixin}` syntax. This enables modular CSS definition within Haskell.

```haskell
{-# LANGUAGE QuasiQuotes #-}
import Text.Lucius
import qualified Data.Text.Lazy as TL

-- Parameterized mixin for vendor prefixes
transition :: String -> Mixin
transition val = [luciusMixin|
    -webkit-transition: #{val};
    -moz-transition: #{val};
    -ms-transition: #{val};
    -o-transition: #{val};
    transition: #{val};
|]

-- Mixin with nested blocks
buttonStyles :: Mixin
buttonStyles = [luciusMixin|
    padding: 10px 20px;
    border: none;
    border-radius: 4px;
    cursor: pointer;

    &:hover {
        opacity: 0.8;
    }

    &:active {
        transform: scale(0.98);
    }
|]

-- Using mixins in templates
styles :: CssUrl url
styles = [lucius|
    .btn {
        ^{buttonStyles}
        ^{transition "all 0.3s ease"}
        background: blue;
        color: white;
    }

    .btn-secondary {
        ^{buttonStyles}
        ^{transition "all 0.2s ease"}
        background: gray;
    }
|]

main :: IO ()
main = TL.putStrLn $ renderCssUrl (\_ _ -> "") styles

```

--------------------------------

### Producing Text Directly with stextFile

Source: https://github.com/yesodweb/shakespeare/blob/master/ChangeLog.md

Introduces `stextFile` to `Text.Shakespeare.Text`. This function allows producing `Text` directly from a file, similar to how `shamletFile` produces `Html` directly. It simplifies the process of embedding text content within Haskell applications.

```haskell
import Text.Shakespeare.Text (stextFile)

-- Example usage:
-- myText :: Text
-- myText = stextFile "path/to/my/textfile.txt"
```

--------------------------------

### Load External Hamlet Templates in Haskell

Source: https://context7.com/yesodweb/shakespeare/llms.txt

The `hamletFile` quasi-quoter allows loading Hamlet templates from external `.hamlet` files. These templates are parsed at compile time. `hamletFileReload` provides automatic recompilation on file changes during development, though it incurs a performance cost.

```haskell
{-# LANGUAGE TemplateHaskell #-}
import Text.Hamlet

-- Load template from file at compile time
-- File: templates/page.hamlet
-- Contents:
-- <html>
--     <head>
--         <title>#{pageTitle}
--     <body>
--         <h1>#{pageTitle}
--         ^{pageContent}

pageTemplate :: String -> HtmlUrl url -> HtmlUrl url
pageTemplate pageTitle pageContent = $(hamletFile "templates/page.hamlet")

-- For development with auto-reload (slower, but reloads on file change)
pageTemplateReload :: String -> HtmlUrl url -> HtmlUrl url
pageTemplateReload pageTitle pageContent = $(hamletFileReload "templates/page.hamlet")
```

--------------------------------

### Cassius: Indentation-Based CSS Templates in Haskell

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Introduces the `cassius` quasi-quoter, which uses Python-like indentation instead of braces for CSS definition within Haskell. It compiles to the same output as Lucius and supports variable interpolation. Requires the QuasiQuotes language extension.

```haskell
{-# LANGUAGE QuasiQuotes #-}
import Text.Cassius
import qualified Data.Text.Lazy as TL

-- Indentation-based CSS
styles :: CssUrl url
styles = [cassius|
    body
        font-family: sans-serif
        margin: 0
        padding: 0

    .container
        max-width: 1200px
        margin: 0 auto

        .header
            background: #{colorBlack}
            padding: 20px

            h1
                color: white
                margin: 0

        .content
            padding: 20px

            p
                line-height: 1.6
|]

-- Variables work the same as Lucius
themedStyles :: String -> CssUrl url
themedStyles primaryColor = [cassius|
    @primary: #{primaryColor}

    .button
        background: #{primary}
        color: white
        padding: 10px 20px
        border: none

        &:hover
            opacity: 0.8
|]

main :: IO ()
main = TL.putStrLn $ renderCssUrl (\_ _ -> "") styles

```

--------------------------------

### External Text Templates with textFile

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Loads text templates from external files using the `textFile` and `textFileReload` Template Haskell functions. This is useful for managing larger or shared templates, and `textFileReload` provides hot-reloading capabilities during development.

```haskell
{-# LANGUAGE TemplateHaskell #-}
import Text.Shakespeare.Text
import qualified Data.Text.Lazy as TL

-- File: templates/welcome-email.txt
-- Contents:
-- Dear #{userName},
--
-- Welcome to #{siteName}! Your account has been created.
--
-- Username: #{userName}
-- Email: #{userEmail}
--
-- Get started at @{HomeR}

welcomeEmail :: String -> String -> String -> TextUrl MyRoute
welcomeEmail userName siteName userEmail = $(textFile "templates/welcome-email.txt")

-- With hot reload for development
welcomeEmailReload :: String -> String -> String -> TextUrl MyRoute
welcomeEmailReload userName siteName userEmail = $(textFileReload "templates/welcome-email.txt")
```

--------------------------------

### Generate Simple HTML with shamlet in Haskell

Source: https://context7.com/yesodweb/shakespeare/llms.txt

The `shamlet` quasi-quoter generates plain `Html` values. Variables are interpolated using `#{expr}` syntax and automatically HTML-escaped to prevent XSS attacks. This is useful for basic HTML generation without URL interpolation.

```haskell
{-# LANGUAGE QuasiQuotes #-}
import Text.Hamlet
import Text.Blaze.Html.Renderer.String (renderHtml)

-- Simple HTML generation with variable interpolation
renderGreeting :: String -> String
renderGreeting name = renderHtml [shamlet|
<div>
    <h1>Hello, #{name}!
    <p>Welcome to our site.
|]
-- Output: "<div><h1>Hello, world!</h1><p>Welcome to our site.</p></div>"

-- Variables are automatically HTML-escaped
renderSafe :: String -> String
renderSafe userInput = renderHtml [shamlet|<p>#{userInput}|]
-- renderSafe "<script>alert('xss')</script>"
-- Output: "<p>&lt;script&gt;alert('xss')&lt;/script&gt;</p>"
```

--------------------------------

### Ordered Cassius and Lucius Modules

Source: https://github.com/yesodweb/shakespeare/blob/master/ChangeLog.md

Introduces `Text.Cassius.Ordered` and `Text.Lucius.Ordered` modules. These modules provide parsers that maintain the order of attributes and mixin blocks in Cassius and Lucius stylesheets, which can be important for certain CSS properties and behaviors.

```haskell
import Text.Cassius.Ordered
import Text.Lucius.Ordered

-- Example usage:
-- cassius "my-style.cassius"
-- lucius "my-style.lucius"
```

--------------------------------

### ToJavascript Instance for Text Types

Source: https://github.com/yesodweb/shakespeare/blob/master/ChangeLog.md

Provides a `ToJavascript` instance for String, Strict Text, and Lazy Text. This enables seamless conversion of Haskell text types to JavaScript representations, facilitating data exchange between Haskell backends and JavaScript frontends.

```haskell
import Data.Text.Lazy (Text)
import Data.Text.Strict (Text)
import GHC.Generics (Generic)

-- Assuming a ToJavascript typeclass exists:
-- class ToJavascript a where
--   toJavascript :: a -> JSExpr

-- Example usage:
-- let myString = "Hello, world!"
-- let myLazyText = "<p>Some lazy text</p>"
-- toJavascript myString
-- toJavascript myLazyText
```

--------------------------------

### Cassius Mixin for CSS with Indentation

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Defines reusable CSS snippets using Cassius's indentation-based syntax. These mixins can be embedded within both Cassius and Lucius CSS definitions. They are useful for creating common styling patterns like centering elements.

```haskell
{-# LANGUAGE QuasiQuotes #-}
import Text.Cassius
import Text.Lucius (Mixin, lucius)
import qualified Data.Text.Lazy as TL

-- Cassius-style mixin
flexCenter :: Mixin
flexCenter = [cassiusMixin|
    display: flex
    justify-content: center
    align-items: center
|]

-- Can be used in either Cassius or Lucius templates
cassiusStyles :: CssUrl url
cassiusStyles = [cassius|
    .modal
        ^{flexCenter}
        position: fixed
        top: 0
        left: 0
        width: 100%
        height: 100%
|]

luciusStyles :: CssUrl url
luciusStyles = [lucius|
    .modal {
        ^{flexCenter}
        position: fixed;
        inset: 0;
    }
|]
```

--------------------------------

### Generate HTML with Type-Safe URLs using hamlet in Haskell

Source: https://context7.com/yesodweb/shakespeare/llms.txt

The `hamlet` quasi-quoter generates `HtmlUrl url` values, enabling type-safe URL interpolation. It requires a URL rendering function and uses `@{route}` syntax for embedding routes. This prevents broken links at compile time.

```haskell
{-# LANGUAGE QuasiQuotes #-}
import Text.Hamlet
import Text.Blaze.Html.Renderer.String (renderHtml)
import Data.Text (Text, pack)

data MyRoute = Home | UserProfile Int | Search

-- URL renderer function
render :: MyRoute -> [(Text, Text)] -> Text
render Home _ = pack "/"
render (UserProfile uid) _ = pack $ "/user/" ++ show uid
render Search params = pack $ "/search" ++ showParams params
  where showParams [] = ""
        showParams ps = "?" ++ intercalate "&" [unpack k ++ "=" ++ unpack v | (k,v) <- ps]

-- Template with type-safe URL interpolation
navigation :: HtmlUrl MyRoute
navigation = [hamlet|
<nav>
    <a href=@{Home}>Home
    <a href=@{UserProfile 123}>My Profile
    <a href=@?{(Search, [(pack "q", pack "haskell")])}>Search Haskell
|

-- Render with the URL function
main :: IO ()
main = putStrLn $ renderHtml $ navigation render
-- Output includes: <a href="/">Home</a><a href="/user/123">My Profile</a>
```

--------------------------------

### Simple Text Interpolation with stext

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Generates lazy Text values with support for variable interpolation using the `stext` quasi-quoter. This is ideal for dynamic content like emails, logs, or simple messages. It supports basic string formatting and multi-line templates.

```haskell
{-# LANGUAGE QuasiQuotes #-}
import Text.Shakespeare.Text
import qualified Data.Text.Lazy as TL
import qualified Data.Text.Lazy.IO as TL

-- Simple text interpolation
greeting :: String -> TL.Text
greeting name = [stext|Hello, #{name}! Welcome to our service.|]

-- Multi-line text
emailTemplate :: String -> String -> Int -> TL.Text
emailTemplate userName productName quantity = [stext|
Dear #{userName},

Thank you for your order of #{show quantity} x #{productName}.

Your order is being processed and will ship within 3-5 business days.

Best regards,
The Team
|]

-- Strict Text variant
greetingStrict :: String -> Text
greetingStrict name = [st|Hello, #{name}!|]

main :: IO ()
main = TL.putStrLn $ emailTemplate "Alice" "Widget Pro" 3
```

--------------------------------

### Hamlet Conditionals: $if, $elseif, $else

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Renders user information with conditional styling based on admin status, age, or membership. It uses the $if, $elseif, and $else directives for conditional logic within the Hamlet template.

```haskell
{-# LANGUAGE QuasiQuotes #-}
import Text.Hamlet
import Text.Blaze.Html.Renderer.String (renderHtml)

data User = User { userName :: String, userAge :: Int, userAdmin :: Bool }

-- Conditionals with $if/$elseif/$else
renderUser :: User -> String
renderUser user = renderHtml [shamlet|
<div .user>
    <h2>#{userName user}
    $if userAdmin user
        <span .badge>Administrator
    $elseif userAge user < 18
        <span .badge>Minor
    $else
        <span .badge>Member
|]
```

--------------------------------

### Internationalized HTML Templates with ihamlet in Haskell

Source: https://context7.com/yesodweb/shakespeare/llms.txt

The `ihamlet` quasi-quoter extends `hamlet` to support internationalization (i18n) through message interpolation using `_{msg}` syntax. It requires a message translation function and a URL rendering function, enabling localized content and type-safe URLs.

```haskell
{-# LANGUAGE QuasiQuotes #-}
import Text.Hamlet
import Text.Blaze.Html (Html, toHtml)
import Text.Blaze.Html.Renderer.String (renderHtml)
import Data.Text (Text, pack)

data AppMessage = MsgWelcome | MsgGoodbye | MsgUserCount Int

data MyRoute = Home

-- Message translator
translateEnglish :: AppMessage -> Html
translateEnglish MsgWelcome = toHtml ("Welcome!" :: String)
translateEnglish MsgGoodbye = toHtml ("Goodbye!" :: String)
translateEnglish (MsgUserCount n) = toHtml $ show n ++ " users online"

renderUrl :: MyRoute -> [(Text, Text)] -> Text
renderUrl Home _ = pack "/"

-- Template with i18n messages
welcomePage :: HtmlUrlI18n AppMessage MyRoute
welcomePage = [ihamlet|
<div>
    <h1>_{MsgWelcome}
    <p>_{MsgUserCount 42}
    <a href=@{Home}>_{MsgGoodbye}
|

main :: IO ()
main = putStrLn $ renderHtml $ welcomePage translateEnglish renderUrl
```

--------------------------------

### Record Access in Expressions (OverloadedRecordDot)

Source: https://github.com/yesodweb/shakespeare/blob/master/ChangeLog.md

Enables `OverloadedRecordDot`-style record access within expressions in shakespeare templates. This provides a more concise syntax for accessing record fields, similar to how it's done in standard Haskell.

```haskell
data User = User { name :: String, age :: Int }

user :: User
user = User "Alice" 30

-- Example usage with OverloadedRecordDot syntax:
-- user.name
-- user.age
```

--------------------------------

### Hamlet With Binding: $with

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Renders complex data structures by deconstructing a tuple using the $with directive. It allows for easier access to nested values within the template.

```haskell
-- With binding for complex expressions
renderComplex :: (Int, (String, Bool)) -> String
renderComplex tuple = renderHtml [shamlet|
$with (count, (name, active)) <- tuple
    <p>#{name}: #{show count} items
    $if active
        <span>Currently active
|]
```

--------------------------------

### Component Binding in Hamlet

Source: https://github.com/yesodweb/shakespeare/blob/master/ChangeLog.md

Introduces the $component directive in Hamlet for reusable blocks. It allows binding a component-producing function and reusing its sub-components within the same Hamlet block. This feature enhances modularity and code reuse in Hamlet templates.

```haskell
data Modal = Modal
  {
    modalHeader :: Widget -> Widget,
    modalBody :: Widget -> Widget
  }

modalWidget :: (Modal -> Widget) -> Widget
modalWidget = undefined

-- Example usage in Hamlet
-- $component modal <- modalWidget
--   $component modalHeader modal
--     <h1>This is the title

--   $component modalBody modal
--     <p>This is the content

-- Desugared Haskell equivalent:
-- ^{ modalWidget $ \modal ->
--      [whamlet|
--        ^{ modalHeader modal [whamlet| <h1>This is the title |] }
--        ^{ modalBody   modal [whamlet| <p>This is the content |] }
--      |]
-- }
-- <p>outside
```

```hamlet
$component modal <- modalWidget
  $component modalHeader modal
    <h1>This is the title

  $component modalBody modal
    <p>This is the content
```

```haskell
^{ modalWidget $ \modal ->
     [whamlet|
       ^{ modalHeader modal [whamlet| <h1>This is the title |] }
       ^{ modalBody   modal [whamlet| <p>This is the content |] }
     |]
 }
<p>outside
```

--------------------------------

### Generate Translation Types with mkMessage

Source: https://context7.com/yesodweb/shakespeare/llms.txt

The `mkMessage` Template Haskell function generates data types and `RenderMessage` instances from `.msg` translation files. It simplifies internationalization by automatically creating message structures and handling translations based on language codes.

```haskell
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
import Text.Shakespeare.I18N

data MyApp = MyApp

-- Generate message type from translation files
-- Directory structure:
-- messages/
--   en.msg       (default language)
--   de.msg
--   fr.msg

-- File: messages/en.msg
-- Hello: Hello!
-- Goodbye: Goodbye!
-- Welcome name@Text: Welcome, #{name}!
-- ItemCount count@Int: You have #{show count} items.

-- File: messages/de.msg
-- Hello: Hallo!
-- Goodbye: Auf Wiedersehen!
-- Welcome name@Text: Willkommen, #{name}!
-- ItemCount count@Int: Sie haben #{show count} Artikel.

mkMessage "MyApp" "messages" "en"

-- This generates:
-- data MyAppMessage = MsgHello | MsgGoodbye | MsgWelcome Text | MsgItemCount Int
-- instance RenderMessage MyApp MyAppMessage where ...

-- Using translations
renderMessage' :: [Lang] -> MyAppMessage -> Text
renderMessage' langs msg = renderMessage MyApp langs msg

main :: IO ()
main = do
    -- English (default)
    print $ renderMessage' ["en"] MsgHello           -- "Hello!"
    print $ renderMessage' ["en"] (MsgWelcome "Alice") -- "Welcome, Alice!"

    -- German
    print $ renderMessage' ["de"] MsgHello           -- "Hallo!"
    print $ renderMessage' ["de", "en"] (MsgItemCount 5)  -- "Sie haben 5 Artikel."

    -- Fallback to default
    print $ renderMessage' ["es", "en"] MsgGoodbye   -- "Goodbye!" (Spanish not available)
```

--------------------------------

### Multi-line Attributes in Hamlet

Source: https://github.com/yesodweb/shakespeare/blob/master/ChangeLog.md

Adds support for multi-line attributes within Hamlet templates. This allows for more readable and organized attribute definitions, especially when dealing with long lists of attributes or complex values.

```hamlet
a
  href "/some/long/url"
  title "This is a tooltip that spans
         multiple lines for better readability"
  "Click me"
```

--------------------------------

### Hamlet Case Expressions: $case/$of

Source: https://context7.com/yesodweb/shakespeare/llms.txt

Renders a status indicator with different styles based on the `Status` data type. It uses the $case and $of directives for pattern matching on the status.

```haskell
-- Case expressions with $case/$of
data Status = Active | Inactive | Pending

renderStatus :: Status -> String
renderStatus status = renderHtml [shamlet|
$case status
    $of Active
        <span .green>Active
    $of Inactive
        <span .red>Inactive
    $of Pending
        <span .yellow>Pending
|]
```

--------------------------------

### Handling Infix Operators with Trailing Spaces

Source: https://github.com/yesodweb/shakespeare/blob/master/ChangeLog.md

Fixes parsing issues related to expressions involving infix operators and trailing spaces. This ensures that such expressions are correctly interpreted and processed by the shakespeare parser.

```haskell
-- Example of an expression that might have caused issues:
-- let result = 5 +  3 
-- The parser should now correctly handle this.
```

--------------------------------

### Sub-blocks in Mixins

Source: https://github.com/yesodweb/shakespeare/blob/master/ChangeLog.md

Adds support for sub-blocks within mixins in shakespeare templates. This allows for more complex and nested structures within mixins, improving their reusability and flexibility.

```hamlet
%def mixin myMixin
  %-- content of the mixin
  div
    MyMixinContent

-- Example usage with sub-blocks:
-- div
--   MyContent
--   ^{myMixin}
--     div
--       NestedContent
```

--------------------------------

### Cassius and Lucius Reload Mode Fix

Source: https://github.com/yesodweb/shakespeare/blob/master/ChangeLog.md

Addresses a bug in the reload mode for Cassius and Lucius. This fix ensures that changes to Cassius and Lucius files are correctly detected and reloaded when the application is in development mode.

```haskell
-- This is a backend fix and does not typically involve direct code snippets for users.
-- It ensures that changes in .cassius or .lucius files are reflected without needing a full server restart.
```

--------------------------------

### Escaping Single Quotes in encodeToTextBuilder

Source: https://github.com/yesodweb/shakespeare/blob/master/ChangeLog.md

Updates `encodeToTextBuilder` to also escape single quotes. This ensures that generated output, particularly when dealing with JavaScript or other contexts where single quotes have special meaning, is properly escaped and avoids syntax errors.

```haskell
import Data.Text.Lazy.Builder (toLazyText)

-- Example usage:
-- let input = "It\'s a test"
-- let output = toLazyText $ encodeToTextBuilder input
-- -- The output will have the single quote escaped, e.g., "It\'s a test"
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.