input.hs

{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE LinearTypes #-}

module Main where

-- | Something else.
class Bar a where
  -- | Bar
  bar ::
    String ->
    String ->
    a
  -- Pointless comment
  default bar ::
    ( Read a,
      Semigroup a
    ) =>
    a ->
    a ->
    a
  -- Even more pointless comment
  bar
    a
    b =
      read a <> read b

-- | Here goes a comment.
data Foo a where
  -- | 'Foo' is wonderful.
  Foo ::
    forall a b.
    (Show a, Eq b) => -- foo
    -- bar
    a ->
    b ->
    Foo 'Int
  -- | But 'Bar' is also not too bad.
  Bar ::
    -- | An Int
    Int ->
    Maybe Text ->
    -- ^ And a Maybe Text
    Foo 'Bool
  -- | So is 'Baz'.
  Baz ::
    forall a.
    a ->
    Foo 'String
  (:~>) :: Foo a -> Foo a -> Foo a

-- Single line type signature is preserved
instance Eq Int where
  (==) :: Int -> Int -> Bool
  (==) _ _ = False
singleLineFun :: forall a. (C1, C2) => Int -> Bool

instance Ord Int where
  compare ::
    Int ->
    Int ->
    Ordering
  compare
    _
    _ =
      GT

functionName ::
  (C1, C2, C3, C4, C5) =>
  a ->
  b ->
  ( forall a.
    (C6, C7) =>
    LongDataTypeName ->
    a ->
    AnotherLongDataTypeName ->
    b ->
    c
  ) ->
  (c -> d) ->
  (a, b, c, d)

functionWithInterleavedCommentsTrailing ::
  -- arg1
  Int ->
  -- arg2
  Int ->
  -- result
  Bool

functionWithInterleavedCommentsLeading
  -- arg1
  :: Int
  -- arg2
  -> Int
  -- result
  -> Bool

multilineExprSig = do
  bar
    ( x ::
        Int ->
        Bool
    )
  bar
    ( x ::
        -- arg
        Int ->
        -- result
        Bool
    )
  bar
    ( x
        -- arg
        :: Int
        -- result
        -> Bool
    )

data Record = Record
  { recFun :: forall a. (C1, C2) => Int ->
              Int ->
              Bool
  , recOther :: Bool
  }

data Foo
  = Foo
      -- | arg1
      Int
      String
      -- ^ arg2

foo ::
  Int %1 ->
  Bool
foo ::
  forall x.
  Int %Many ->
  Bool