Data.Text.Display

Methods

• displayBuilder :: a -> Builder

  Implement this method to describe how to convert your value to Builder.

• displayList :: [a] -> Builder

  The method displayList is provided to allow for a specialised way to render lists of a certain value. This is used to render the list of Char as a string of characters enclosed in double quotes, rather than between square brackets and separated by commas.

  Example

  import qualified Data.Text.Lazy.Builder as TB
  
  instance Display Char where
    displayBuilder c = TB.fromText $ T.singleton c
    displayList cs = TB.fromText $ T.pack cs
  
  instance (Display a) => Display [a] where
    -- In this instance, 'displayBuilder' is defined in terms of 'displayList', which for most types
    -- is defined as the default written in the class declaration.
    -- But when a ~ Char, there is an explicit implementation that is selected instead, which
    -- provides the rendering of the character string between double quotes.
    displayBuilder = displayList

  How implementations are selected

  displayBuilder ([1,2,3] :: [Int])
  → displayBuilder @[Int] = displayBuilderList @Int
  → Default `displayList`
  
  displayBuilder ("abc" :: [Char])
  → displayBuilder @[Char] = displayBuilderList @Char
  → Custom `displayList`

• displayPrec :: Int -> a -> Builder

  The method displayPrec allows you to write instances that require nesting. The precedence parameter can be thought of as a suggestion coming from the surrounding context for how tightly to bind. If the precedence parameter is higher than the precedence of the operator (or constructor, function, etc.) being displayed, then that suggests that the output will need to be surrounded in parentheses in order to bind tightly enough (see displayParen).

  For example, if an operator constructor is being displayed, then the precedence requirement for its arguments will be the precedence of the operator. Meaning, if the argument binds looser than the surrounding operator, then it will require parentheses.

  Note that function/constructor application has an effective precedence of 10.

  Examples

  instance (Display a) => Display (Maybe a) where
    -- In this instance, we define 'displayPrec' rather than 'displayBuilder' as we need to decide
    -- whether or not to surround ourselves in parentheses based on the surrounding context.
    -- If the precedence parameter is higher than 10 (the precedence of constructor application)
    -- then we indeed need to surround ourselves in parentheses to avoid malformed outputs
    -- such as @Just Just 5@.
    -- We then set the precedence parameter of the inner 'displayPrec' to 11, as even
    -- constructor application is not strong enough to avoid parentheses.
    displayPrec _ Nothing = "Nothing"
    displayPrec prec (Just a) = displayParen (prec > 10) $ "Just " <> displayPrec 11 a

  data Pair a b = a :*: b
  infix 5 :*: -- arbitrary choice of precedence
  instance (Display a, Display b) => Display (Pair a b) where
    displayPrec prec (a :*: b) = displayParen (prec > 5) $ displayPrec 6 a <> " :*: " <> displayPrec 6 b