info > Dpkg::Arch

Not found locally for Dpkg::Arch. Try Google search

The user wants me to transform this Perl man page for Dpkg::Arch into an emoji-rich, visually scannable HTML version. Let me follow all the rules carefully. Let me identify the sections: - NAME - DESCRIPTION - FUNCTIONS (contains a list of functions) - CHANGES (has subsections with versions) - SEE ALSO The function reference section should use `
  • name(args) — description
    • ` format WITHOUT per-item emoji per rule #12. Let me also create a Quick Reference section. For a Perl module like this, I can include common usage patterns like getting the build architecture, host architecture, mapping between GNU triplets and multiarch, and checking architecture wildcards. Let me think about what code blocks I need: - The function signatures in the FUNCTIONS section are descriptions of code, but they're not really code blocks themselves - they're documentation of function calls. However, per rule #6, code includes "$variable, ->method, function()". So `$arch = get_raw_build_arch()` looks like code... Actually, looking at this more carefully - in man pages for Perl modules, these are formatted as code examples with explanations. I should wrap them in `
    ` blocks. Let me follow the original format.

Wait, looking at the original, the function signatures appear inline as part of the text, like:
```
       $arch = get_raw_build_arch()
           Get the raw build Debian architecture...
```

These are indented with spaces (man page style). I should preserve this structure. The function signature lines look like code, and the descriptions are regular text.

Let me convert this properly:
- Function signature line → wrapped in `
    ` 
- Description → regular text following

But then I need a separate paragraph or just keep them flowing. Let me think about this. The original uses indentation to separate each function. I think the cleanest approach is to keep each function as:
- Code block for the signature
- Paragraph for the description

But that creates a lot of `
    ` blocks. Looking at rule #6, "Code includes anything with: $variable, ->method, use Module;, function(), flags like -f --long". Yes, the `$arch = get_raw_build_arch()` is code.

Let me wrap each function signature in a `
    ` block.

Now for the changes section, the "Version 1.03 (dpkg 1.19.1)" etc. are sub-headings (h3) within the CHANGES section.

Let me also think about the CHANGES section - those version lines like "Version 1.03 (dpkg 1.19.1)" should be h3 headings per rule #3.

Let me draft the output now.

For Quick Reference, I'll create a useful table:
| Use Case | Command | Description |
| Get build arch | `my $arch = get_build_arch();` | Current build architecture |
| Get host arch | `my $arch = get_host_arch();` | Current host architecture |
| Map to multiarch | `my $m = debarch_to_multiarch('amd64');` | Convert Debian arch to multiarch tuple |
| Check architecture match | `debarch_is('amd64', 'any');` | Match arch against wildcard |
| GNU triplet mapping | `my $g = debarch_to_gnutriplet('amd64');` | Convert to GNU triplet |
| Parse arch list | `my @a = debarch_list_parse('amd64 !armhf');` | Parse dependency arch restrictions |

Now let me write it out.

Emoji choices:
- NAME: 📛
- Quick Reference: 🚀
- DESCRIPTION: 📖
- FUNCTIONS: ⚙️
- CHANGES: 📝
- SEE ALSO: 🔗

For the function reference list (per rule #12), I'll use `
  • name(args) — description
    • ` WITHOUT per-item emoji. But wait, the original FUNCTIONS section has the function signatures as indented code blocks, not as a list. Let me think about whether to use a list format or preserve the original format.

Looking again at the original structure, each function in the FUNCTIONS section has:
1. A signature line (indented)
2. A description (indented further or as paragraphs)

I think the cleanest is to keep this as it is - use `
    ` for each signature and paragraph for descriptions. This preserves the structure better than converting to a list. The rule about function reference lists using `
  • ` is more about when the input has a list-like format.

Actually, looking at the rule again: "For function, method, and class reference sections (pydoc modules, ruby ri classes, perldoc function lists): use 
  • name(args) — description
    •  format WITHOUT per-item emoji."

This is a Perl module (perldoc), so it would apply here. Let me convert the function list to use `