text-display-0.0.4.0: doc/book/print.html
<!DOCTYPE HTML>
<html lang="en" class="sidebar-visible no-js light">
<head>
<!-- Book generated using mdBook -->
<meta charset="UTF-8">
<title>text-display</title>
<meta name="robots" content="noindex" />
<!-- Custom HTML head -->
<meta name="description" content="">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="theme-color" content="#ffffff" />
<link rel="icon" href="favicon.svg">
<link rel="shortcut icon" href="favicon.png">
<link rel="stylesheet" href="css/variables.css">
<link rel="stylesheet" href="css/general.css">
<link rel="stylesheet" href="css/chrome.css">
<link rel="stylesheet" href="css/print.css" media="print">
<!-- Fonts -->
<link rel="stylesheet" href="FontAwesome/css/font-awesome.css">
<link rel="stylesheet" href="fonts/fonts.css">
<!-- Highlight.js Stylesheets -->
<link rel="stylesheet" href="highlight.css">
<link rel="stylesheet" href="tomorrow-night.css">
<link rel="stylesheet" href="ayu-highlight.css">
<!-- Custom theme stylesheets -->
</head>
<body>
<div id="body-container">
<!-- Provide site root to javascript -->
<script>
var path_to_root = "";
var default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "navy" : "light";
</script>
<!-- Work around some values being stored in localStorage wrapped in quotes -->
<script>
try {
var theme = localStorage.getItem('mdbook-theme');
var sidebar = localStorage.getItem('mdbook-sidebar');
if (theme.startsWith('"') && theme.endsWith('"')) {
localStorage.setItem('mdbook-theme', theme.slice(1, theme.length - 1));
}
if (sidebar.startsWith('"') && sidebar.endsWith('"')) {
localStorage.setItem('mdbook-sidebar', sidebar.slice(1, sidebar.length - 1));
}
} catch (e) { }
</script>
<!-- Set the theme before any content is loaded, prevents flash -->
<script>
var theme;
try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
if (theme === null || theme === undefined) { theme = default_theme; }
var html = document.querySelector('html');
html.classList.remove('no-js')
html.classList.remove('light')
html.classList.add(theme);
html.classList.add('js');
</script>
<!-- Hide / unhide sidebar before it is displayed -->
<script>
var html = document.querySelector('html');
var sidebar = 'hidden';
if (document.body.clientWidth >= 1080) {
try { sidebar = localStorage.getItem('mdbook-sidebar'); } catch(e) { }
sidebar = sidebar || 'visible';
}
html.classList.remove('sidebar-visible');
html.classList.add("sidebar-" + sidebar);
</script>
<nav id="sidebar" class="sidebar" aria-label="Table of contents">
<div class="sidebar-scrollbox">
<ol class="chapter"><li class="chapter-item expanded affix "><a href="Introduction.html">Introduction</a></li><li class="chapter-item expanded affix "><a href="Tutorial.html">Tutorial</a></li><li class="chapter-item expanded affix "><a href="https://hackage.haskell.org/package/text-display/docs/Data-Text-Display.html">API Reference (→ Hackage)</a></li><li class="chapter-item expanded affix "><a href="Design.html">Design</a></li><li class="chapter-item expanded affix "><a href="Comparison.html">Comparison</a></li></ol>
</div>
<div id="sidebar-resize-handle" class="sidebar-resize-handle"></div>
</nav>
<div id="page-wrapper" class="page-wrapper">
<div class="page">
<div id="menu-bar-hover-placeholder"></div>
<div id="menu-bar" class="menu-bar sticky bordered">
<div class="left-buttons">
<button id="sidebar-toggle" class="icon-button" type="button" title="Toggle Table of Contents" aria-label="Toggle Table of Contents" aria-controls="sidebar">
<i class="fa fa-bars"></i>
</button>
<button id="theme-toggle" class="icon-button" type="button" title="Change theme" aria-label="Change theme" aria-haspopup="true" aria-expanded="false" aria-controls="theme-list">
<i class="fa fa-paint-brush"></i>
</button>
<ul id="theme-list" class="theme-popup" aria-label="Themes" role="menu">
<li role="none"><button role="menuitem" class="theme" id="light">Light</button></li>
<li role="none"><button role="menuitem" class="theme" id="rust">Rust</button></li>
<li role="none"><button role="menuitem" class="theme" id="coal">Coal</button></li>
<li role="none"><button role="menuitem" class="theme" id="navy">Navy</button></li>
<li role="none"><button role="menuitem" class="theme" id="ayu">Ayu</button></li>
</ul>
<button id="search-toggle" class="icon-button" type="button" title="Search. (Shortkey: s)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="S" aria-controls="searchbar">
<i class="fa fa-search"></i>
</button>
</div>
<h1 class="menu-title">text-display</h1>
<div class="right-buttons">
<a href="print.html" title="Print this book" aria-label="Print this book">
<i id="print-button" class="fa fa-print"></i>
</a>
<a href="https://github.com/haskell-text/text-display/tree/main/docs" title="Git repository" aria-label="Git repository">
<i id="git-repository-button" class="fa fa-github"></i>
</a>
</div>
</div>
<div id="search-wrapper" class="hidden">
<form id="searchbar-outer" class="searchbar-outer">
<input type="search" id="searchbar" name="searchbar" placeholder="Search this book ..." aria-controls="searchresults-outer" aria-describedby="searchresults-header">
</form>
<div id="searchresults-outer" class="searchresults-outer hidden">
<div id="searchresults-header" class="searchresults-header"></div>
<ul id="searchresults">
</ul>
</div>
</div>
<!-- Apply ARIA attributes after the sidebar and the sidebar toggle button are added to the DOM -->
<script>
document.getElementById('sidebar-toggle').setAttribute('aria-expanded', sidebar === 'visible');
document.getElementById('sidebar').setAttribute('aria-hidden', sidebar !== 'visible');
Array.from(document.querySelectorAll('#sidebar a')).forEach(function(link) {
link.setAttribute('tabIndex', sidebar === 'visible' ? 0 : -1);
});
</script>
<div id="content" class="content">
<main>
<p>Welcome to the <code>text-display</code> documentation.</p>
<div style="break-before: page; page-break-before: always;"></div><h1 id="tutorial"><a class="header" href="#tutorial">Tutorial</a></h1>
<p>This tutorial will teach you how to use the <code>Display</code> typeclass for your own data types.</p>
<h2 id="the-display-typeclass"><a class="header" href="#the-display-typeclass">The Display typeclass</a></h2>
<p>The <code>Display</code> typeclass is an interface to create user-facing output.
As opposed to the <code>Show</code> typeclass, it does not have to output Haskell syntax at all
time. This enables the programmer to separate concerns between textual output
that needs to be parsable by derived instances of the <code>Read</code> typeclass, and
output whose prime goal is to convey information to humans.</p>
<p>The main way to get started with it is to call the <code>display</code> function on any data type
that implements the <code>Display</code> typeclass. We are going to see how to implement it in
the next sections.</p>
<h2 id="implementing-the-typeclass"><a class="header" href="#implementing-the-typeclass">Implementing the typeclass</a></h2>
<p>The easiest way to implement the typeclass is to provide an implementation for its
<code>displayBuilder</code> method:</p>
<pre><code class="language-haskell">import Data.Text.Display
data MyType = MyType Int
-- >>> display (MyType 32)
-- "MyType 32"
instance Display MyType where
displayBuilder (MyType i) = "MyType " <> display i
</code></pre>
<p>But this can be quite time-consuming, especially if your datatype already has
an existing <code>Show</code> that you wish to reuse. In which case, you can piggy-back
on this instance like this:</p>
<pre><code class="language-haskell">{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE DerivingStrategies #-}
data AutomaticallyDerived = AD
deriving stock Show
deriving Display
via (ShowInstance AutomaticallyDerived)
</code></pre>
<p>This derivation takes advantage of the <a href="https://hackage.haskell.org/package/text-display/docs/Data-Text-Display.html#t:ShowInstance">ShowInstance</a> helper to reuse
the <code>Show</code> instance of <code>AutomaticallyDerived</code>.
In this case, <code>show</code> and <code>display</code> will give the same result on the
<code>AutomaticallyDerived</code> datatype.</p>
<p>But let's say you want to redact an instance of <code>Display</code>? You can do it locally, through
the <code>OpaqueInstance</code> helper. It is most useful to hide tokens or passwords:</p>
<pre><code class="language-haskell">data UserToken = UserToken UUID
deriving Display
via (OpaqueInstance "[REDACTED]" UserToken)
display $ UserToken "7a01d2ce-31ff-11ec-8c10-5405db82c3cd"
-- => "[REDACTED]"
</code></pre>
<p>By now you should be comfortable with the base concepts of <code>Display</code>. Have fun. :) </p>
<div style="break-before: page; page-break-before: always;"></div><h1 id="api-reference--hackage"><a class="header" href="#api-reference--hackage">API Reference (→ Hackage)</a></h1>
<div style="break-before: page; page-break-before: always;"></div><h1 id="library-design"><a class="header" href="#library-design">Library design</a></h1>
<h2 id="a-lawless-typeclass1"><a class="header" href="#a-lawless-typeclass1">A “Lawless Typeclass”<sup class="footnote-reference"><a href="#lois">1</a></sup></a></h2>
<p>The <code>Display</code> typeclass does not contain any law. This is a controversial choice for some people,
but the truth is that there are not any laws to ask of the consumer that are not already enforced
by the type system and the internals of the <code>Text</code> type.</p>
<h2 id="the-builder-type"><a class="header" href="#the-builder-type">The <code>Builder</code> type</a></h2>
<p>As opposed to <code>Show</code>, <code>Display</code> takes the opportunity of pionneering better techniques when it comes
to the messy business of handling the textual representation of data structure, faithfully and efficiently.</p>
<p>The first of these choices is that it does not use the <code>Text</code> type up until the text is requested by the
user. Internally, everything is built with the <code>Builder</code> type, a buffer used for efficiently building <code>Text</code>
values, with an <code>append</code> operation running in <code>𝛰(1)</code>. In comparison, the <code>append</code> operation for <code>Text</code> has a
complexity of <code>𝛰(n)</code>.<br />
This is especially useful for types that are defined recursively, like lists or trees for example. </p>
<p>For example: </p>
<pre><code class="language-haskell">data Tree a = Node a [Tree a]
instance Display a => Display (Tree a) where
-- displayBuilder for the instance
displayBuilder (Node a xs) = displayBuilder a <> displayBuilderList xs
-- display for the application code
display $ Node 1 [Node 2 [], Node 3 [], Node 4 []]
-- => "1[2[],3[],4[]]"
</code></pre>
<h2 id="the-four-siblings-display-displayprec-displaylist-and-displaybuilder"><a class="header" href="#the-four-siblings-display-displayprec-displaylist-and-displaybuilder">The four siblings: <code>display</code>, <code>displayPrec</code>, <code>displayList</code>, and <code>displayBuilder</code></a></h2>
<p>If you take a close look at the <code>Display</code> typeclass, you will see the following information:</p>
<pre><code class="language-haskell">ghci> :i Display
type Display :: * -> Constraint
┌──
│ class Display a where
│ displayBuilder :: a -> Builder
1. │ displayList :: [a] -> Builder
│ displayPrec :: Int -> a -> Builder
└──
┌──
2. │ {-# MINIMAL displayBuilder | displayPrec #-}
└──
</code></pre>
<ol>
<li>
<p>This is the class definition, with its methods.</p>
<ul>
<li>
<p><code>displayBuilder</code> produces a <code>Builder</code> value out of an <code>a</code>.<br />
This is the most common way to implement <code>Display</code> when you just need to render something for an end-user.</p>
</li>
<li>
<p><code>displayList</code> produces a <code>Builder</code> value out of a list of <code>a</code>.
This method has a default implementation provided by the library, but it may be overloaded in case you
wish to render the list of a particular type in a certain way, like how <code>[Char]</code> is rendered to <code>"this nice user-readable string"</code> instead of something <code>['l', 'i', 'k', 'e', ' ', 't', 'h', 'i', 's']</code>.</p>
</li>
<li>
<p><code>displayPrec</code> takes a precedence value with the value to be transformed, and produces a <code>Builder</code>.<br />
It has a more advanced target audience in mind, and is used when printing nested datatypes calls for a clarification of operator and constructor precedence.
If the precedence is not set, we cannot say that we want parentheses surrounding an inner value, like <code>"Just (Just 5)"</code>, and indeed, may find ourselves
with a result like <code>"Just Just 5"</code>, which is unacceptable.</p>
</li>
</ul>
</li>
<li>
<p>This is the minimal implementation a user of the library must provide in order to implement <code>Display</code> for
their datatype.</p>
</li>
</ol>
<p>You will notice that <code>display</code> itself is not part of the Typeclass. And indeed, we wanted the typeclass to:</p>
<ol>
<li>Internally use a <code>Builder</code> type for efficient production of textual data;</li>
<li>Be able to handle precedence;</li>
<li>Be user-friendly and return a <code>Text</code>, that is understood in most textual APIs.</li>
</ol>
<p>While all three goals have been achieved, we noticed that only the first two points had to be implemented
<em>inside</em> the typeclass definition, and <code>display :: Display a => a -> Text</code> could live outside of the typeclass
and still serve its purpose. As such, as not to clutter the typeclass methods, it was decided to keep <code>display</code>
out of it.</p>
<h2 id="usage-restrictions"><a class="header" href="#usage-restrictions">Usage restrictions</a></h2>
<h3 id="-you-should-not-try-to-display-function-types"><a class="header" href="#-you-should-not-try-to-display-function-types">"🚫 You should not try to display function types!"</a></h3>
<p>Sometimes, when using the library, you may encounter this message:</p>
<pre><code>• 🚫 You should not try to display function types!
💡 Write a 'newtype' wrapper that represents your domain more accurately.
If you are not consciously trying to use `display` on a function,
make sure that you are not missing an argument somewhere.
</code></pre>
<p>The <code>display</code> library does not allow the definition and usage of <code>Display</code> on
bare function types (<code>(a -> b)</code>).<br />
Experience and time have shown that due to partial application being baked in the language,
many users encounter a partial application-related error message when a simple missing
argument to a function is the root cause.</p>
<p>There may be legitimate uses of a <code>Display</code> instance on a function type.
But these usages are extremely dependent on their domain of application.
That is why it is best to wrap them in a newtype that can better
express and enforce the domain.</p>
<h3 id="-you-should-not-try-to-display-bytestrings"><a class="header" href="#-you-should-not-try-to-display-bytestrings">"🚫 You should not try to display ByteStrings!"</a></h3>
<p>An arbitrary ByteStrings cannot be safely converted to text without prior knowledge of its encoding.
As such, in order to avoid dangerously blind conversions, it is recommended to use a specialised
function such as <code>decodeUtf8'</code> or <code>decodeUtf8Strict</code> if you wish to turn a UTF8-encoded ByteString
to Text.</p>
<div class="footnote-definition" id="lois"><sup class="footnote-definition-label">1</sup>
<p><em>"mort aux lois, vive l'anarchie"</em> - Georges Brassens</p>
</div>
<div style="break-before: page; page-break-before: always;"></div><h1 id="comparison-table"><a class="header" href="#comparison-table">Comparison Table</a></h1>
<p>
<div class="table-wrapper"><table><thead><tr><th>Package</th><th>Dependencies</th><th>Purpose</th><th>GHC Support</th></tr></thead><tbody>
<tr><td><a href="https://flora.pm/packages/@hackage/text-display"><code>text‑display</code></a></td><td><code>base</code>, <code>bytestring</code>, <code>text</code></td><td>Human-readable display</td><td>Starts with 8.8</td></tr>
<tr><td><a href="https://flora.pm/packages/@hackage/pretty-show"><code>pretty‑show</code></a></td><td><code>array</code>,<code>base</code>, <code>filepath</code>,<code>ghc‑prim</code>, <code>haskell‑lexer</code>,<code>pretty</code>, <code>text</code></td><td>Pretty‑printing Show instancesfor Haskell data structures</td><td>7.10.3 to 8.6.1</td></tr>
<tr><td><a href="https://flora.pm/packages/@hackage/text-show"><code>text‑show</code></a></td><td><code>array</code>, <code>base‑compat‑batteries</code>, <code>bifunctors</code>,<code>bytestring</code>, <code>bytestring‑builder</code>, <code>containers</code>,<code>generic‑deriving</code>, <code>ghc‑prim</code>, <code>text</code>,<code>th‑abstraction</code>, <code>th‑lift</code>,</td><td>Systematic replacement of Showinstances of <code>base</code>, <code>array</code>, <code>bytestring</code> and <code>text</code> with a Text‑based equivalent</td><td>7.8.4 to 9.2.2</td></tr>
<tr><td><a href="https://flora.pm/packages/@hackage/pretty-display"><code>pretty‑display</code></a></td><td><code>base</code>, <code>text</code>, <code>pretty‑show</code></td><td>Human‑readable display</td><td>7.8.4 to 8.0.1</td></tr>
<tr><td><a href="https://flora.pm/packages/@hackage/display"><code>display</code></a></td><td><code>base</code>, <code>bytestring</code>, <code>text</code></td><td>Human‑readable display</td><td>Unclear</td></tr>
</tbody></table>
</div></p>
<p>
<div class="table-wrapper"><table><thead><tr><th>Package</th><th>Underlying representation</th></tr></thead><tbody>
<tr><td><a href="https://flora.pm/packages/@hackage/text-display"><code>text‑display</code></a></td><td>Lazy Text Builder</td></tr>
<tr><td><a href="https://flora.pm/packages/@hackage/pretty-show"><code>pretty‑show</code></a></td><td>ADT for generic representation</td></tr>
<tr><td><a href="https://flora.pm/packages/@hackage/text-show"><code>text‑show</code></a></td><td>Lazy Text Builder</td></tr>
<tr><td><a href="https://flora.pm/packages/@hackage/pretty-display"><code>pretty‑display</code></a></td><td>Defers to <code>pretty‑show</code></td></tr>
<tr><td><a href="https://flora.pm/packages/@hackage/display"><code>display</code></a></td><td>ByteString Builder</td></tr>
</tbody></table>
</div></p>
</main>
<nav class="nav-wrapper" aria-label="Page navigation">
<!-- Mobile navigation buttons -->
<div style="clear: both"></div>
</nav>
</div>
</div>
<nav class="nav-wide-wrapper" aria-label="Page navigation">
</nav>
</div>
<!-- Livereload script (if served using the cli tool) -->
<script>
const wsProtocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
const wsAddress = wsProtocol + "//" + location.host + "/" + "__livereload";
const socket = new WebSocket(wsAddress);
socket.onmessage = function (event) {
if (event.data === "reload") {
socket.close();
location.reload();
}
};
window.onbeforeunload = function() {
socket.close();
}
</script>
<script>
window.playground_copyable = true;
</script>
<script src="elasticlunr.min.js"></script>
<script src="mark.min.js"></script>
<script src="searcher.js"></script>
<script src="clipboard.min.js"></script>
<script src="highlight.js"></script>
<script src="book.js"></script>
<!-- Custom JS scripts -->
<script>
window.addEventListener('load', function() {
window.setTimeout(window.print, 100);
});
</script>
</div>
</body>
</html>