content: -- Less than 80 characters
  import Data.List (head, isPrefixOf, tail)
  
  -- Over 80 characters, should break this line when column-limit is set to 80.
  import Data.Maybe (
      catMaybe,
      fromJust,
      fromMaybe,
      isJust,
      isNothing,
      listToMaybe,
      mapMaybe,
      maybe,
      maybeToList,
   )
  
  -- For reference, this line had exactly 80 characters -------------------------|
  
  oneVeryLongLine :: [String]
  oneVeryLongLine =
      ["akjsndjklansdsad"] ++ ["jkanskdjnajsndjnasd"] ++ ["jknasdljknasdlnasdn"] ++ ["lajndljnasdlnasds"]
  
  oneVeryLongList :: [String]
  oneVeryLongList = ["akjsndjklansdsad", "jkanskdjnajsndjnasd", "jknasdljknasdlnasdn", "lajndljnasdlnasds"]
  
  data NewDataType = NewDataType {field1 :: String, field2 :: String, field3 :: String, field4 :: String}
  
  -- Test if the current line breaking still works normally, i.e. if the user
  -- breaks the line, fourmolu breaks and aligns the rest.
  data SecondDataType = SecondDataType
      { field1 :: String
      , field2 :: String
      , field3 :: String
      , field4 :: String
      }
  
  data DataTypeWithAVeryLongName = DataTypeWithAVeryLongName String String String String String
  
  -- For reference, this line had exactly 80 characters -------------------------|
  
  {----- Long function signatures -----}
  
  longFunction0 ::
      String -> String -> String -> Maybe Int -> Maybe Int -> Maybe Int -> String -> [String]
  longFunction0 veryLongArg1 a b c d e f = ["a list", "of strings", "that will break the", "column limit"]
  
  longFunction1 :: String -> String -> String -> Maybe Int -> Maybe Int -> Maybe Int -> String
  longFunction1
      veryLongArg1
      veryLongArg2
      veryLongArg3
      veryLongArg4
      veryLongArgument5
      veryLongArg6 = undefined
  
  longFunction12 veryLongArg1 veryLongArg2 veryLongArg3 veryLongArg4 veryLongArgument5
  longFunction12 ::
      String ->
      String ->
      String ->
      Maybe Int ->
      Maybe Int ->
      Maybe Int ->
      String ->
      String
          veryLongArg6
          veryLongArg6 = undefined
  
  longFunction2 :: String -> String -> String -> Maybe Int -> Maybe Int -> Maybe Int -> String
  longFunction2 veryLongArg1 veryLongArg2 veryLongArg3 veryLongArg4 a veryLongArg6 =
      let aVeryLongLine = ["list one", "list one", "list one", "list one", "list one", "list one"]
       in undefined
  
  longFunction3 :: String -> String -> String -> Maybe Int -> Maybe Int -> Maybe Int -> String
  longFunction3 veryLongArg1 veryLongArg2 veryLongArg3 veryLongArg4 veryLongArgument5 veryLongArg6 = undefined
  
  -- For reference, this line had exactly 80 characters -------------------------|
  
  {-----  Known limitation: idempotence is broken -----}
  
  -- With the column-limit option set, fourmolu will not be idempotent in some
  -- cases. An example can be seen below, where the long line ends with a `do`.
  
  -- Original code
  testFund :: Maybe Int
  testFund =
      firstTest oneFunctionArgument abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde $ do
          result <- aRandomResult
  
  -- Will become this when formatted with column-limit set to 80.
  testFund :: Maybe Int
  testFund =
      firstTest
          oneFunctionArgument
          abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde
          $ do
              result <- aRandomResult
  
  -- Which, if formatted again, will become this:
  testFund :: Maybe Int
  testFund =
      firstTest
          oneFunctionArgument
          abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde
          $ do
              result <- aRandomResult
  
  {- // -}
  
  {----- BlockArguments (https://github.com/fourmolu/fourmolu/issues/377) -----}
  {-# LANGUAGE BlockArguments #-}
  
  putThen :: String -> IO a -> IO a
  putThen s action =
      putStrLn s >> action
  
  main :: IO ()
  main = do
      putThen
          "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"
          do
              putStrLn ""
  