### Fuller Lucid Example with Attributes

Source: https://github.com/chrisdone/lucid/blob/master/lucid2/README.md

A comprehensive example demonstrating nested elements with various attributes, including colspan and style.

```haskell
table_ [rows_ "2"]
       (tr_ (do td_ [class_ "top",colspan_ "2",style_ "color:red"]
                    (p_ "Hello, attributes!")
                td_ "yay!"))

```

```html
<table rows="2">
  <tr>
    <td style="color:red" colspan="2" class="top">
      <p>Hello, attributes!</p>
    </td>
    <td>yay!</td>
  </tr>
</table>

```

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

### Simple Void Element Example

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/complete-element-attribute-list.md

Demonstrates creating a void element like `<img>` with attributes.

```haskell
img_ [src_ "photo.jpg", alt_ "Photo"]
```

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

### HTML Form Example

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/quick-start.md

Demonstrates creating an HTML form with input fields and labels using Lucid.

```Haskell
import Lucid

loginForm :: Html ()
loginForm = form_ [method_ "post", action_ "/login"] (do
  label_ [for_ "username"] "Username:"
  input_ [id_ "username", name_ "username", type_ "text"]
  label_ [for_ "password"] "Password:"
  input_ [id_ "password", name_ "password", type_ "password"]
  button_ [type_ "submit"] "Login")
```

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

### Nested Elements Example

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/complete-element-attribute-list.md

Demonstrates how to create nested elements, such as an unordered list with list items.

```haskell
ul_ (do
  li_ "Item 1"
  li_ "Item 2"
  li_ "Item 3")
```

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

### Example: Text → Attribute

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Demonstrates using a Text value as an Attribute, specifically for a class attribute.

```haskell
import Lucid

-- Used as attribute
attr = class_ "intro"
element = p_ [attr] "Hello"

```

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

### Unordered List Example

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/quick-start.md

Shows how to create an unordered HTML list (ul) with list items (li) using Lucid.

```Haskell
import Lucid

shoppingList :: Html ()
shoppingList = ul_ (do
  li_ "Milk"
  li_ "Eggs"
  li_ "Bread"
  li_ "Cheese")
```

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

### HTML Table Example

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/quick-start.md

Demonstrates creating an HTML table with a header (thead) and body (tbody) using Lucid.

```Haskell
import Lucid

scoreTable :: Html ()
scoreTable = table_ (do
  thead_ (tr_ (do
    th_ "Name"
    th_ "Score"))
  tbody_ (do
    tr_ (do
      td_ "Alice"
      td_ "95")
    tr_ (do
      td_ "Bob"
      td_ "87")))
```

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

### GHCi Setup for Lucid

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/configuration.md

Configures the GHCi environment with necessary language extensions and imports for interactive Lucid use.

```haskell
:set -XOverloadedStrings -XExtendedDefaultRules
import Lucid
```

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

### Attribute Creation and Usage Example

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/types.md

Shows how to create an Attribute using makeAttribute and then use it to define an HTML element. Requires importing Lucid.

```haskell
import Lucid

attr = makeAttribute "id" "main"
element = div_ [attr] "Content"
```

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

### Example: Attributes → Children → Element

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Constructs a paragraph element with specified attributes and content.

```haskell
import Lucid

-- First argument: list of attributes
-- Return value: function accepting children
element = p_ [class_ "intro", id_ "p1"] "Hello"

```

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

### Simple HTML Document Structure

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/quick-start.md

An example of creating a complete HTML document with head and body sections using Lucid.

```Haskell
import Lucid

document :: Html ()
document = doctypehtml_ (do
  head_ (do
    meta_ [charset_ "utf-8"]
    title_ "My Page")
  body_ (do
    h1_ "Welcome"
    p_ "Content goes here"))

main = renderToFile "index.html" document
```

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

### Write Your First Lucid Page

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/quick-start.md

A simple example of creating an HTML page using Lucid, including a main function to display it.

```Haskell
page :: Html ()
page = do
  h1_ "Hello, World!"
  p_ "This is my first Lucid page"

main :: IO ()
main = putStrLn $ show page
```

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

### Bootstrap Grid Layout

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/quick-start.md

An example of using Lucid with the Lucid.Bootstrap library to create a basic Bootstrap grid layout.

```Haskell
import Lucid
import Lucid.Bootstrap

layout :: Html ()
layout = containerFluid_ (do
  row_ (do
    span3_ (p_ "Sidebar")
    span9_ (p_ "Main Content")))
```

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

### Example: Adding Attributes to Content-less Elements

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Shows how to use the 'with' function to add attributes to void elements.

```haskell
import Lucid

element = br_ `with` [class_ "spacer"]
```

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

### Example: Constructing HTML Lists with Lucid

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Demonstrates how to use Lucid functions to create an unordered list with two items and an ordered list with two steps. Requires importing Lucid.

```haskell
import Lucid

page = do
  ul_ (do
    li_ "First item"
    li_ "Second item")
  ol_ (do
    li_ "First step"
    li_ "Second step")
```

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

### Example: Constructing an HTML Table with Lucid

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Shows how to build an HTML table with a header row and two data rows using Lucid functions. Requires importing Lucid.

```haskell
import Lucid

table_ (do
  thead_ (tr_ (do
    th_ "Name"
    th_ "Age"))
  tbody_ (do
    tr_ (do
      td_ "Alice"
      td_ "30")
    tr_ (do
      td_ "Bob"
      td_ "25")))
```

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

### Interactive Lucid HTML Generation in GHCi

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/configuration.md

Demonstrates using Lucid to generate HTML directly in the GHCi prompt after setup.

```haskell
λ> p_ "Hello"
<p>Hello</p>
```

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

### Example: Adding Attributes to Content-ful Elements

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Demonstrates using the 'with' function to add attributes to elements that contain content.

```haskell
import Lucid

element = div_ `with` [id_ "main"] (p_ "Content")
```

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

### HtmlT Example with Reader Monad

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/types.md

Demonstrates using HtmlT with the Reader monad to generate HTML that incorporates environment data. Requires importing Lucid and Control.Monad.Reader.

```haskell
import Lucid
import Control.Monad.Reader

html :: HtmlT (Reader String) ()
html = do
  name <- lift ask
  p_ (toHtml name)

result = runReader (renderTextT html) "Alice"
```

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

### Overload Resolution Examples

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Demonstrates how the compiler resolves the correct Term instance based on the provided arguments and expected type.

```haskell
import Lucid

-- Instance 2: Children only
p_ "text"                    -- HtmlT m () -> HtmlT m ()

-- Instance 1: Attributes, then children
p_ [class_ "c"] "text"       -- HtmlT m () -> HtmlT m ()

-- Instance 3: As attribute
[p_ "intro"]                 -- [Attribute] because attribute list is expected

-- Chained: first creates element function, then applies content
div_ [id_ "x"] (p_ "hello")  -- Attributes → Children → HtmlT m ()

```

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

### Data Attributes Example

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/complete-element-attribute-list.md

Illustrates how to add custom data attributes to an element using the `data_` prefix.

```haskell
div_ [data_ "user-id" "123", data_ "section" "profile"] "Content"
```

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

### Using MonadState with HtmlT

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Shows how to use the MonadState instance within HtmlT to manage and update state, demonstrated with a counter example.

```haskell
import Lucid
import Control.Monad.State

counter :: HtmlT (State Int) ()
counter = do
  n <- get          -- MonadState
  put (n + 1)
  li_ (toHtml $ show n)
```

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

### Lucid HTML5 Sectioning Elements Example

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Demonstrates the usage of sectioning elements like header, nav, article, and footer in a basic page structure.

```haskell
import Lucid

page = body_ (do
  header_ (h1_ "Site Title")
  nav_ (ul_ (li_ (a_ [href_ "/"] "Home")))
  article_ (p_ "Content")
  footer_ "© 2024")
```

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

### Basic Html Usage Example

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-base.md

Demonstrates the basic usage of the `Html` type for creating simple HTML structures like a div containing a paragraph.

```haskell
import Lucid

page :: Html ()
page = div_ (p_ "Hello, World!")
```

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

### Lucid HTML5 Heading Elements Example

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Shows how to use heading elements from h1_ to h6_ to structure content with different levels of importance.

```haskell
import Lucid

page = do
  h1_ "Main Heading"
  h2_ "Subheading"
  h3_ "Sub-subheading"
```

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

### Example of Creating a Form with Lucid

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Demonstrates how to construct an HTML form using Lucid, including labels, input fields, a textarea, and a submit button. Attributes like `method`, `action`, `for`, `id`, `name`, and `type` are shown.

```haskell
import Lucid

form_ [method_ "post", action_ "/submit"] (do
  label_ [for_ "name"] "Name:"
  input_ [id_ "name", name_ "name", type_ "text"]
  label_ [for_ "message"] "Message:"
  textarea_ [id_ "message", name_ "message"] ""
  button_ [type_ "submit"] "Submit")
```

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

### Example: Children Only → Element

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Constructs paragraph elements with only text content, including multi-line content.

```haskell
import Lucid

-- No attributes, just children
element1 = p_ "Hello"
element2 = p_ (do
  "First"
  "Second")

```

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

### ToHtml Examples: Escaped and Raw Output

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/types.md

Demonstrates the difference between toHtml (which escapes special characters) and toHtmlRaw (which outputs content as-is).

```haskell
import Lucid

escaped = toHtml ("<script>alert(1)</script>" :: String)
-- Output: &lt;script&gt;alert(1)&lt;/script&gt;

raw = toHtmlRaw "<b>Bold</b>"
-- Output: <b>Bold</b>
```

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

### toHtml Method Example (Escaping)

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Demonstrates converting a string with special HTML characters to HTML using `toHtml`, which automatically escapes them.

```haskell
import Lucid

p_ (toHtml ("<script>alert('xss')</script>" :: String))
-- Output: <p>&lt;script&gt;alert(&#39;xss&#39;)&lt;/script&gt;</p>
```

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

### Lucid HTML5 Text Content Elements Example

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Illustrates the use of paragraph, preformatted text, and blockquote elements for text content.

```haskell
import Lucid

page = do
  p_ "Normal paragraph"
  pre_ "Code example with\nspecific formatting"
  blockquote_ "A famous quote"
```

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

### Defining Custom ToHtml Instance for User Type

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Provides an example of defining a custom ToHtml instance for a User data type, specifying how it should be rendered as HTML.

```haskell
import Lucid

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

instance ToHtml User where
  toHtml user = do
    p_ (toHtml $ name user)
    p_ (toHtml $ "Age: " ++ show (age user))
  
  toHtmlRaw = toHtml  -- Use escaping version
```

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

### toHtmlRaw Method Example (No Escaping)

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Demonstrates converting a string to HTML using `toHtmlRaw`, which outputs the content without any character escaping.

```haskell
import Lucid

p_ (toHtmlRaw "<b>Bold</b>")
-- Output: <p><b>Bold</b></p>
```

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

### HTML Generation with Logging using Writer

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/patterns-and-advanced.md

Integrate the Writer monad to log messages during HTML generation. This example logs section rendering events.

```haskell
import Lucid
import Control.Monad.Writer

renderSection :: String -> Html () -> HtmlT (Writer [String]) ()
renderSection title content = do
  tell ["Rendering section: " ++ title]
  section_ (do
    h2_ (toHtml title)
    toHtml content)

page :: HtmlT (Writer [String]) ()
page = do
  renderSection "Intro" (p_ "Hello")
  renderSection "Content" (p_ "Body")
  renderSection "Footer" (p_ "Bye")

-- Usage:
main = do
  let (html, logs) = runWriter (renderBST page)
  mapM_ putStrLn logs
  putStrLn $ show html
```

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

### HTML with IO Monad

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/configuration.md

This snippet shows how to generate HTML that interacts with the IO monad, for example, reading input. Import Control.Monad.IO.Class.

```haskell
import Control.Monad.IO.Class

page :: HtmlT IO ()
page = do
  msg <- liftIO getLine
  p_ (toHtml msg)

output = renderTextT page
```

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

### Explicit Type Annotations in Lucid

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/quick-start.md

Provides examples of explicit type annotations for Lucid HTML generation, both for simple and monadic structures.

```haskell
import Lucid

-- Explicit type annotation
myPage :: Html ()
myPage = div_ "Content"

-- Monadic version
myPage' :: Html ()
myPage' = do
  h1_ "Title"
  p_ "Text"
```

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

### Example of Using Inline Text Elements in Lucid

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Demonstrates how to combine various inline text elements like `strong_` and `em_` within a paragraph (`p_`) using Lucid's monadic syntax.

```haskell
import Lucid

page = p_ (do
  "This is "
  strong_ "important"
  " and this is "
  em_ "emphasized"
  ".")
```

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

### Bootstrap Span Element with Classes

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-bootstrap.md

Example of creating a Bootstrap span element with custom CSS classes and data attributes using Lucid.Bootstrap.

```haskell
import Lucid
import Lucid.Bootstrap

page = container_ (
  row_ (
    span6_ [class_ "highlighted", data_ "section" "main"] (
      p_ "Content with additional classes")))
```

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

### makeElement

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-base.md

Creates an HTML element with specified start and end tags, serving as a base for other element combinators. It takes the element's tag name and its children content.

```APIDOC
## makeElement

### Description
Creates an HTML element with start and end tags. This is the foundation for element combinators like `p_` and `div_`.

### Method
```haskell
makeElement :: Functor m => Text -> HtmlT m a -> HtmlT m a
```

### Parameters
#### Path Parameters
- **name** (Text) - Required - Element tag name
- **children** (HtmlT m a) - Required - Child content

### Response
#### Success Response
- **HtmlT m a** - The rendered element

### Request Example
```haskell
import Lucid

customElement = makeElement "section" (p_ "Content")
-- Produces: <section><p>Content</p></section>
```
```

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

### Generating DOCTYPE and HTML Element

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Combines the HTML5 DOCTYPE declaration with the root html_ element. This is a common way to start an HTML5 document.

```haskell
import Lucid

page = doctypehtml_ (body_ (p_ "Content"))
```

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

### Create HTML Element with makeElement

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-base.md

Use makeElement to create standard HTML elements with start and end tags. It takes the element name and its children as arguments. This is the base for common combinators like p_ and div_.

```haskell
makeElement :: Functor m => Text -> HtmlT m a -> HtmlT m a
```

```haskell
import Lucid

customElement = makeElement "section" (p_ "Content")
-- Produces: <section><p>Content</p></section>
```

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

### Boolean Attributes Example

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/complete-element-attribute-list.md

Demonstrates the use of boolean attributes like `checked_` and `disabled_` on elements.

```haskell
input_ [type_ "checkbox", checked_]
button_ [disabled_] "Click me"
```

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

### Execute HtmlT and Extract Builder

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-base.md

Use execHtmlT to run an HtmlT computation and get the resulting Blaze Builder. The return value of the computation is discarded. This is analogous to execState.

```haskell
execHtmlT :: Monad m => HtmlT m a -> m Builder
```

```haskell
import Lucid
import qualified Blaze.ByteString.Builder as Blaze

html = p_ "Test"
builder <- execHtmlT html
let bs = Blaze.toLazyByteString builder
```

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

### Enable Compiler Optimizations (Command Line)

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/configuration.md

Build your project with GHC optimizations enabled directly from the command line.

```bash
cabal build --ghc-options="-O2"
```

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

### Accessing Low-Level Builder for Control

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/patterns-and-advanced.md

Illustrates how to access Lucid's underlying Blaze Builder for maximum control over HTML generation and efficient writing to files.

```haskell
import Lucid
import Lucid.Base
import qualified Blaze.ByteString.Builder as Blaze
import qualified Data.ByteString.Lazy as BL

html = div_ "Content"

-- Get the Builder
builder <- execHtmlT html

-- Write to file efficiently
BL.writeFile "out.html" $ Blaze.toLazyByteString builder
```

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

### doctypehtml_

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Combines the DOCTYPE declaration with the root `<html>` element wrapper. It simplifies the initial setup of an HTML document.

```APIDOC
## doctypehtml_

### Description
Combines DOCTYPE and `html_` element wrapper. Simplifies the initial setup of an HTML document.

### Method
N/A (Function call)

### Endpoint
N/A (Function call)

### Parameters
- `arg` (HtmlT m a): The content to be placed within the `<html>` tags.

### Response
Outputs `<!DOCTYPE HTML>` followed by the wrapped HTML content.

### Example
```haskell
import Lucid

page = doctypehtml_ (body_ (p_ "Content"))
-- Produces: <!DOCTYPE HTML><html><body><p>Content</p></body></html>
```
```

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

### Render HTML to a File

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/quick-start.md

Shows how to render a Lucid Html structure directly to an HTML file.

```Haskell
import Lucid

page :: Html ()
page = h1_ "Hello"

-- To file
main = renderToFile "output.html" page
```

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

### container_

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-bootstrap.md

Creates a fixed-width grid container by applying the `container` class.

```APIDOC
## container_

### Description
A fixed-width grid container. Applies the `container` class.

### Returns
Container div with `class="container"`

### Example
```haskell
import Lucid
import Lucid.Bootstrap

page = container_ (do
  row_ (do
    span6_ "Left column"
    span6_ "Right column"))
```
```

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

### Element with Attributes and Content

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Demonstrates how to apply global attributes like id, class, and data attributes to an element. Ensure the Lucid library is imported.

```haskell
import Lucid

element = div_ [id_ "main", class_ "container active", data_ "custom" "value"] "Content"
```

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

### Get Blaze Builder from HtmlT

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/configuration.md

This snippet shows how to obtain a Blaze ByteString Builder from an HtmlT computation for advanced rendering scenarios.

```haskell
import Lucid.Base (execHtmlT)
import qualified Blaze.ByteString.Builder as Blaze

html = div_ "Content"
builder <- execHtmlT html
```

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

### Basic Elements

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/quick-start.md

Demonstrates the basic syntax for creating HTML elements in Lucid using a postfix underscore.

```Haskell
p_ "Hello"
div_ "Content"
h1_ "Title"
```

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

### Responsive Grid Layout with Lucid Bootstrap

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-bootstrap.md

Demonstrates a responsive grid layout using span6_ for half-width columns on larger screens and full-width on mobile, and span12_ for a full-width row.

```haskell
import Lucid
import Lucid.Bootstrap

responsive = containerFluid_ (do
  row_ (do
    span6_ "Mobile: full width / Desktop: half"
    span6_ "Mobile: full width / Desktop: half")
  row_ (do
    span12_ "Full width on all sizes"))
```

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

### Basic Lucid.Html5 Usage Patterns

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Demonstrates various ways to use Lucid.Html5 combinators for elements and attributes, including elements with children, attributes, or both, as well as monadic composition.

```haskell
p_ "Hello"
```

```haskell
p_ [class_ "intro"] "Hello"
```

```haskell
br_ [class_ "spacer"]
```

```haskell
class_ "intro"
```

```haskell
div_ (do
  p_ "First"
  p_ "Second")
```

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

### Creating the Body Element

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Generates the <body> element, which contains all the visible content of an HTML page. This example shows a simple body with an H1 heading.

```haskell
import Lucid

page = body_ (h1_ "Title")
```

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

### Modular Page Composition with Lucid

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/patterns-and-advanced.md

Demonstrates breaking down a page into reusable components like headers, sidebars, main content, and footers for modularity.

```haskell
import Lucid

header :: Html ()
header = header_ (do
  nav_ (ul_ (li_ (a_ [href_ "/"] "Home")))
  h1_ "Site Title")

sidebar :: Html ()
sidebar = aside_ (do
  h2_ "Categories"
  ul_ (li_ "News"))

mainContent :: Html ()
mainContent = main_ (p_ "Page content")

footer :: Html ()
footer = footer_ (p_ "© 2024")

page :: Html ()
page = doctypehtml_ (do
  head_ (title_ "My Site")
  body_ (do
    header
    div_ [class_ "container"] (do
      sidebar
      mainContent)
    footer)
```

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

### Import Lucid for HTML5 Projects

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/configuration.md

Use this import for standard HTML5 projects.

```haskell
{-# LANGUAGE OverloadedStrings, ExtendedDefaultRules #-}
import Lucid
import Lucid.Html5
```

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

### Setting Attributes with Argument List

Source: https://github.com/chrisdone/lucid/blob/master/lucid2/README.md

Shows how to set attributes for an HTML element by providing a list of attribute-value pairs.

```haskell
λ> p_ [class_ "brand"] "Lucid Inc" :: Html ()

```

```html
<p class="brand">Lucid Inc</p>

```

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

### Hspec Test Setup for Lucid HTML Rendering

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/configuration.md

Set up Hspec tests to verify Lucid's HTML rendering and content escaping capabilities.

```haskell
import Lucid
import Test.Hspec

main :: IO ()
main = hspec $ do
  describe "HTML rendering" $ do
    it "renders simple elements" $ do
      renderText (p_ "hello") `shouldBe` "<p>hello</p>"
    it "escapes content" $ do
      renderText (p_ "<script>") `shouldBe` "<p>&lt;script&gt;</p>"
```

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

### Basic HTML Page Generation

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/README.md

Demonstrates how to create a simple HTML page using Lucid's Html monad. The generated HTML is then rendered to text.

```haskell
import Lucid

page :: Html ()
page = do
  h1_ "Title"
  p_ "Content"

output = renderText page
```

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

### Typical Usage Pattern

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-main.md

Defines an HTML page structure and demonstrates rendering it to text or a file. Requires OverloadedStrings and ExtendedDefaultRules language extensions.

```haskell
{-# LANGUAGE OverloadedStrings, ExtendedDefaultRules #-}

import Lucid

-- Define HTML
page :: Html ()
page = do
  h1_ "Title"
  p_ "Content"

-- Render and output
main :: IO ()
main = do
  putStrLn $ renderText page
  -- or
  renderToFile "output.html" page
```

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

### Text Instance for ToHtml

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Demonstrates converting a strict Text value to HTML using the `toHtml` method.

```haskell
import Data.Text
p_ (toHtml ("hello" :: Text))
```

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

### toHtml vs toHtmlRaw Example Comparison

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Compares the output of `toHtml` (safe, escaped) and `toHtmlRaw` (dangerous, unescaped) when processing potentially harmful user input.

```haskell
import Lucid

userComment = "<img src=x onerror='alert(1)'>"

-- Safe: automatically escaped
p_ (toHtml userComment)
-- Output: <p>&lt;img src=x onerror=&#39;alert(1)&#39;&gt;</p>

-- Dangerous: no escaping
p_ (toHtmlRaw "<img src=x onerror='alert(1)'>")
-- Output: <p><img src=x onerror='alert(1)'></p>
```

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

### Usage of Custom ToHtml Instance

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Illustrates how to use the custom ToHtml instance for the User type to render a User object within an HTML structure.

```haskell
-- Usage:
page = div_ (toHtml $ User "Alice" 30)
```

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

### Reusable Template Components with Lucid

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/patterns-and-advanced.md

Shows how to create reusable HTML components (like 'card') using Lucid and then compose them into a larger template ('page'). Components use `toHtml` for safe rendering of dynamic content.

```haskell
import Lucid

-- Reusable components
card :: String -> Html ()
card title = div_ [class_ "card"] (do
  h3_ (toHtml title)
  p_ "Card content")

-- Template combining components
page :: Html ()
page = div_ [class_ "cards"] (do
  card "Card 1"
  card "Card 2"
  card "Card 3")
```

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

### Adding Debug Markers to HTML

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/patterns-and-advanced.md

Wrap generated HTML content with start and end debug markers. Useful for identifying specific sections in the rendered output.

```haskell
import Lucid

renderWithDebug :: Html () -> Html ()
renderWithDebug h = do
  "<!-- DEBUG START -->"
  h
  "<!-- DEBUG END -->"

page = renderWithDebug (p_ "Content")
```

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

### Element with Text Content

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/complete-element-attribute-list.md

Shows how to create an element with simple text content.

```haskell
p_ "Text content"
```

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

### Automatic HTML Escaping

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/README.md

Shows how Lucid automatically escapes content to prevent cross-site scripting (XSS) vulnerabilities. The example demonstrates that script tags are rendered as HTML entities.

```haskell
p_ "<script>"  -- Safe: renders as &lt;script&gt;
```

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

### Lifting Operations with HtmlT and Reader

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Demonstrates lifting the 'ask' operation from the Reader monad into HtmlT to access environment values.

```haskell
import Lucid
import Control.Monad.Reader

page :: HtmlT (Reader String) ()
page = do
  name <- lift ask
  p_ (toHtml name)
```

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

### Rendering HTML to Text

Source: https://github.com/chrisdone/lucid/blob/master/lucid2/README.md

Demonstrates how to render an HTML structure to a plain text string using `renderText`.

```haskell
λ> renderText (p_ "Hello!")

```

```html
"<p>Hello!</p>"

```

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

### With Instance for Content-ful Elements

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Provides an instance of the With class for regular, content-ful elements.

```haskell
instance (Functor m) => With (HtmlT m a -> HtmlT m a)
```

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

### HTML with Reader Environment

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/configuration.md

This snippet demonstrates generating HTML within a Reader monad, allowing access to an environment. Ensure Control.Monad.Reader is imported.

```haskell
import Control.Monad.Reader

page :: HtmlT (Reader String) ()
page = do
  user <- lift ask
  p_ (toHtml user)

output = runReader (renderTextT page) "Alice"
```

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

### Data-Driven HTML Generation with Lucid

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/patterns-and-advanced.md

Shows how to generate HTML dynamically from Haskell data structures, such as rendering a list of blog posts.

```haskell
import Lucid
import Data.List (sortBy)

data Post = Post
  {
  title :: String
  , author :: String
  , content :: String
  , tags :: [String]
  }

renderPost :: Post -> Html ()
renderPost p = article_ (do
  h2_ (toHtml $ title p)
  p_ [class_ "meta"] (toHtml $ "By " ++ author p)
  div_ [class_ "tags"] (mapM_ renderTag $ tags p)
  div_ [class_ "content"] (toHtml $ content p))

renderTag :: String -> Html ()
renderTag t = span_ [class_ "tag"] (toHtml t)

postList :: [Post] -> Html ()
postList posts = section_ (mapM_ renderPost posts)

-- Usage:
sample :: Html ()
sample = postList
  [
  Post "Hello" "Alice" "Content..." ["haskell", "lucid"]
  ,
  Post "World" "Bob" "More..." ["web"]
  ]
```

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

### Streaming HTML Output

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/patterns-and-advanced.md

Shows how to combine Lucid's lazy rendering with lazy I/O for efficient streaming of HTML content, suitable for large outputs or real-time generation.

```haskell
import Lucid
import qualified Data.ByteString.Lazy as BL

streamHtml :: Html () -> IO ()
streamHtml html = do
  let bs = renderBS html
  BL.putStr bs

-- For file output with streaming:
main = renderToFile "huge.html" largeDocument
```

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

### Import Lucid Module

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-main.md

To use the Lucid library, import the main module. This provides access to commonly used functions and types.

```haskell
import Lucid
```

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

### Generate Metadata Elements

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Use meta_, title_, link_, and base_ to create HTML metadata elements. meta_, link_, and base_ are void elements.

```haskell
meta_ :: Applicative m => [Attribute] -> HtmlT m ()

`<meta>` metadata element (void element).

title_ :: Term arg result => arg -> result

`<title>` document title.

link_ :: Applicative m => [Attribute] -> HtmlT m ()

`<link>` external resource link (void element).

base_ :: Applicative m => [Attribute] -> HtmlT m ()

`<base>` base URL (void element).
```

```haskell
import Lucid

head_ (do
  meta_ [charset_ "utf-8"]
  meta_ [name_ "viewport", content_ "width=device-width"]
  title_ "Page Title"
  link_ [rel_ "stylesheet", href_ "style.css"])
```

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

### HTML Rendering and Validation Testing

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/patterns-and-advanced.md

Demonstrates basic HTML rendering, attribute inclusion, element nesting, and content escaping for validation testing using Lucid and Hspec.

```haskell
import Lucid
import Test.Hspec

spec :: Spec
spec = describe "HTML rendering" $ do
  it "renders basic elements" $ do
    renderText (p_ "hello") `shouldBe` "<p>hello</p>"
  
  it "escapes user content" $ do
    renderText (p_ "<script>") `shouldBe` "<p>&lt;script&gt;</p>"
  
  it "includes attributes" $ do
    renderText (p_ [class_ "intro"] "text")
      `shouldBe` "<p class=\"intro\">text</p>"
  
  it "nests elements" $ do
    renderText (div_ (p_ "nested"))
      `shouldBe` "<div><p>nested</p></div>"
```

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

### With Instance for Content-less Elements

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Provides an instance of the With class for content-less (void) elements like br_ and img_.

```haskell
instance (Functor m) => With (HtmlT m a)
```

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

### Selecting Lucid Package Version

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-main.md

Choose one of the build dependencies for either the stable 'lucid' package or the next-generation 'lucid2' package in your .cabal file.

```cabal
-- Choose one:
build-depends: lucid >= 2.11
-- or
build-depends: lucid2 >= 0.0
```

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

### Complex Dashboard Layout with Lucid Bootstrap

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-bootstrap.md

Builds a complex dashboard layout with a sidebar, a row of metrics, and a main content area, utilizing various column spans and nested rows.

```haskell
import Lucid
import Lucid.Bootstrap

dashboard = containerFluid_ (do
  row_ (do
    span3_ (div_ [id_ "sidebar"] "Navigation")
    span9_ (do
      row_ (do
        span4_ (div_ [class_ "metric"] "Sales: $10K")
        span4_ (div_ [class_ "metric"] "Users: 500")
        span4_ (div_ [class_ "metric"] "Revenue: $5K"))
      row_ (do
        span12_ (div_ [id_ "main"] "Content Area"))))
```

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

### Generate Media Elements

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Use img_, audio_, video_, source_, canvas_, and svg_ to create corresponding HTML5 media and graphics elements. The img_ and source_ functions are void elements.

```haskell
img_ :: Applicative m => [Attribute] -> HtmlT m ()

`<img>` image element (void element).

audio_ :: Term arg result => arg -> result

`<audio>` audio content.

video_ :: Term arg result => arg -> result

`<video>` video content.

source_ :: Applicative m => [Attribute] -> HtmlT m ()

`<source>` media source (void element).

canvas_ :: Term arg result => arg -> result

`<canvas>` drawing canvas.

svg_ :: Term arg result => arg -> result

`<svg>` scalable vector graphics.
```

```haskell
import Lucid

page = do
  img_ [src_ "photo.jpg", alt_ "A photo"]
  video_ [controls_] (do
    source_ [src_ "video.mp4", type_ "video/mp4"])
```

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

### Importing Lucid Submodules

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-main.md

Shows how to import specific Lucid submodules for advanced functionality beyond the main module's re-exports.

```haskell
import Lucid             -- Basic usage
import Lucid.Base        -- Low-level combinators
import Lucid.Bootstrap   -- Bootstrap grid helpers
```

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

### Scotty Web Framework Integration

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/patterns-and-advanced.md

Integrates Lucid for rendering HTML within a Scotty web application. Sets up a basic route to serve an HTML page on the root path.

```haskell
import Lucid
import Web.Scotty

page :: Html ()
page = doctypehtml_ (do
  head_ (title_ "Hello")
  body_ (p_ "Welcome"))

main = scotty 3000 $ do
  get "/" $ do
    html $ renderText page
```

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

### Element with Attributes and Text Content

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/complete-element-attribute-list.md

Illustrates creating an element with specified attributes and text content.

```haskell
div_ [class_ "container", id_ "main"] "Content"
```

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

### HTML Escaping vs Raw Output

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-main.md

Demonstrates Lucid's automatic HTML escaping for security and how to output raw HTML content when necessary.

```haskell
import Lucid

-- Automatically escaped
p_ "<script>"  -- Renders: <p>&lt;script&gt;</p>

-- Raw output without escaping
p_ (toHtmlRaw "<b>Bold</b>")  -- Renders: <p><b>Bold</b></p>
```

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

### Render HTML to Text and ByteString

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/quick-start.md

Demonstrates rendering Lucid's Html type to a String (Text) and a ByteString.

```Haskell
import Lucid

page :: Html ()
page = h1_ "Hello"

-- As Text
output1 = renderText page  -- "<h1>Hello</h1>"

-- As ByteString
output2 = renderBS page    -- "<h1>Hello</h1>"
```

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

### Create a Fixed-Width Grid Container

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-bootstrap.md

Use `container_` to create a fixed-width grid container. It applies the `container` class to the div element.

```haskell
import Lucid
import Lucid.Bootstrap

page = container_ (do
  row_ (do
    span6_ "Left column"
    span6_ "Right column"))
```

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

### Enable Compiler Optimizations (Cabal)

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/configuration.md

Configure your cabal file to enable GHC optimizations for improved performance.

```cabal
library
  ghc-options: -O2
```

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

### Lucid Bootstrap Element Implementation

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-bootstrap.md

Shows the underlying implementation of Lucid Bootstrap elements using `termWith` to pre-apply CSS classes.

```haskell
container_ = termWith "div" [class_ "container"]
span6_ = termWith "div" [class_ "span6"]
```

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

### Render HTML to File

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-base.md

Use renderToFile to directly write the rendered HTML output to a specified file path. This simplifies file generation workflows.

```haskell
import Lucid

page = html_ (body_ (p_ "Hello"))
main = renderToFile "output.html" page
```

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

### Monad Transformer Stack Support

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/README.md

Demonstrates using Lucid with a monad transformer stack, specifically `HtmlT` over `Reader Config`. It shows how to access environment values within the HTML computation.

```haskell
page :: HtmlT (Reader Config) ()
page = do
  cfg <- ask
  p_ (toHtml $ appName cfg)
```

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

### Rendering HTML to ByteString

Source: https://github.com/chrisdone/lucid/blob/master/lucid2/README.md

Shows how to render an HTML structure to a ByteString, including attributes like style.

```haskell
λ> renderBS (p_ [style_ "color:red"] "Hello!")

```

```html
"<p style=\"color:red\">Hello!</p>"

```

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

### Term Instance: Attributes → Children → Element

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

This instance handles cases where attributes are provided first, returning a function that expects children.

```haskell
instance (Applicative m, f ~ HtmlT m a) 
  => Term [Attribute] (f -> HtmlT m a)

```

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

### Create a Fluid-Width Grid Container

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-bootstrap.md

Use `containerFluid_` to create a fluid-width grid container that spans the full viewport. It applies the `container-fluid` class.

```haskell
import Lucid
import Lucid.Bootstrap

page = containerFluid_ (do
  row_ (do
    span3_ "Column 1"
    span3_ "Column 2"
    span3_ "Column 3"
    span3_ "Column 4"))
```

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

### Import Lucid.Html5 for HTML5 Elements

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-main.md

Import Lucid.Html5 to access all standard HTML5 elements and attributes. These are re-exported by the main Lucid module.

```haskell
import Lucid.Html5
```

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

### HTML Generation with Configuration (Reader Monad)

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/patterns-and-advanced.md

Uses the Reader monad to pass configuration data, like application name and debug status, to HTML generation functions.

```haskell
import Lucid
import Control.Monad.Reader

data Config = Config
  {
  appName :: String
  , appVersion :: String
  , debug :: Bool
  }

header :: HtmlT (Reader Config) ()
header = do
  cfg <- ask
  div_ (toHtml $ appName cfg)
  if debug cfg
    then p_ [class_ "debug"] "Debug mode enabled"
    else mempty

page :: HtmlT (Reader Config) ()
page = do
  header
  p_ "Content"

-- Usage:
main = do
  let cfg = Config "MyApp" "1.0" True
  putStrLn $ renderText $ runReader page cfg
```

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

### Two-Column Layout with Lucid Bootstrap

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-bootstrap.md

Creates a two-column layout using span9_ for main content and span3_ for a sidebar within a container and row.

```haskell
import Lucid
import Lucid.Bootstrap

twoCol = container_ (row_ (do
  span9_ (p_ "Main content")
  span3_ (p_ "Sidebar")))
```

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

### Render HTML to File

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-main.md

Renders an HTML structure and saves it directly to a specified file. Ensures proper file handling.

```haskell
import Lucid

page = html_ (body_ (p_ "Content"))
main = renderToFile "index.html" page
```

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

### String Instance for ToHtml

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Shows how the String type can be converted to HTML using `toHtml` (escaped) or `toHtmlRaw` (raw).

```haskell
instance ToHtml String

p_ (toHtml "hello")
p_ (toHtml "<tag>")  -- Escapes to &lt;tag&gt;
```

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

### containerFluid_

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-bootstrap.md

Creates a fluid-width grid container that spans the full viewport by applying the `container-fluid` class.

```APIDOC
## containerFluid_

### Description
A fluid-width grid container that spans the full viewport. Applies the `container-fluid` class.

### Returns
Container div with `class="container-fluid"`

### Example
```haskell
import Lucid
import Lucid.Bootstrap

page = containerFluid_ (do
  row_ (do
    span3_ "Column 1"
    span3_ "Column 2"
    span3_ "Column 3"
    span3_ "Column 4"))
```
```

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

### Blaze.ByteString.Builder Type Import

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/types.md

Import the Builder type for low-level, efficient HTML output construction in Lucid.

```haskell
import Blaze.ByteString.Builder (Builder)
```

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

### Enable Language Extensions and Import Lucid

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/quick-start.md

Enables necessary Haskell language extensions and imports the Lucid library for use in your project.

```Haskell
{-# LANGUAGE OverloadedStrings, ExtendedDefaultRules #-}

import Lucid
```

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

### Generate Script and Style Elements

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-html5.md

Use script_ and style_ to create script and style elements. Content for these elements is not HTML-escaped.

```haskell
script_ :: TermRaw arg result => arg -> result

`<script>` element. Content is not HTML-escaped.

style_ :: TermRaw arg result => arg -> result

`<style>` element or attribute. Content is not HTML-escaped when used as element.
```

```haskell
import Lucid

page = do
  style_ "body { color: blue; }"
  script_ "console.log('Hello');"
```

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

### Running/Execution Functions

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-main.md

These functions are used to execute Lucid HTML computations within a monadic context, allowing for extraction of the resulting HTML builder or its evaluated return value.

```APIDOC
## Running/Execution Functions

### Description
Functions for executing Lucid HTML computations within monadic contexts.

### Functions
- `execHtmlT` — Execute and extract builder
- `evalHtmlT` — Execute and extract return value
- `runHtmlT` — Low-level execution

### See Also
See `Lucid.Base` for detailed documentation.
```

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

### Three-Column Layout with Lucid Bootstrap

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-bootstrap.md

Constructs a three-column layout where each column occupies one-third of the row width using span4_.

```haskell
import Lucid
import Lucid.Bootstrap

threeCol = container_ (row_ (do
  span4_ (p_ "Left")
  span4_ (p_ "Center")
  span4_ (p_ "Right")))
```

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

### Add Lucid to Stack Project

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/quick-start.md

Shows how to add Lucid as a dependency in a Haskell project's package.yaml file for Stack.

```YAML
dependencies:
- lucid
```

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

### Optional GHC Language Extensions for Custom Lucid Instances

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/configuration.md

Includes FlexibleInstances and MultiParamTypeClasses, primarily used internally by Lucid but needed for defining custom instances.

```haskell
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
```

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

### renderToFile

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/api-reference/lucid-base.md

Renders an Html structure directly to a specified file path. This is a convenient function for writing HTML output to disk.

```APIDOC
## renderToFile

### Description

Render HTML directly to a file.

### Parameters

#### Path Parameters

None

#### Query Parameters

None

#### Request Body

None

### Method

Not applicable (function call)

### Endpoint

Not applicable (function call)

### Function Signature

```haskell
renderToFile :: FilePath -> Html a -> IO ()
```

### Parameters

- **filepath** (`FilePath`) - Required - Path to write to
- **html** (`Html a`) - Required - HTML to render

### Returns

- `IO ()` - An IO action that performs the file write.

### Example

```haskell
import Lucid

page = html_ (body_ (p_ "Hello"))
main = renderToFile "output.html" page
```
```

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

### Import Lucid for Bootstrap 2 Legacy Projects

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/configuration.md

Use this import for projects relying on Bootstrap 2 legacy components.

```haskell
{-# LANGUAGE OverloadedStrings, ExtendedDefaultRules #-}
import Lucid
import Lucid.Bootstrap
```

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

### Usage of TermRaw for Script and Style Elements

Source: https://github.com/chrisdone/lucid/blob/master/_autodocs/class-reference.md

Demonstrates how to use TermRaw to create script and style elements with content that should not be HTML-escaped.

```haskell
script_ "console.log('Hello')"
-- Produces: <script>console.log('Hello')</script>
-- Not escaped even though it contains special characters

style_ "body { color: red; }"
-- Produces: <style>body { color: red; }</style>
```