###############################################################################
###############################################################################
###############################################################################
#group extensions
###############################################################################
###############################################################################
###############################################################################

###############################################################################
## MultiWayIf
#test multiwayif 1
{-# LANGUAGE MultiWayIf #-}
func = if
  | cond1 -> loooooooooooooooooooooooooooooong expr1
  | cond2 -> loooooooooooooooooooooooooooooong expr2

#test multiwayif 2
{-# LANGUAGE MultiWayIf #-}
func = do
  foo
  bar $ if
    | cond1 -> loooooooooooooooooooooooooooooong expr1
    | cond2 -> loooooooooooooooooooooooooooooong expr2


###############################################################################
## LambdaCase
#test lambdacase 1
{-# LANGUAGE LambdaCase #-}
func = \case
  FooBar -> x
  Baz    -> y



###############################################################################
## ImplicitParams
#test ImplicitParams 1
{-# LANGUAGE ImplicitParams #-}
func :: (?asd::Int) -> ()

#test ImplicitParams 2
{-# LANGUAGE ImplicitParams #-}
func
  :: (  ?asd
     :: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
     -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
     )
  -> ()


###############################################################################
## RecursiveDo
#test recursivedo 1
{-# LANGUAGE RecursiveDo #-}
foo = do
  rec a <- f b
      b <- g a
  return (a, b)

#test recursivedo 2
{-# LANGUAGE RecursiveDo #-}
foo = do
  rec -- comment
      a <- f b
      b <- g a
  return (a, b)

###############################################################################
## ExplicitNamespaces + PatternSynonyms
#test explicitnamespaces_patternsynonyms export
{-# LANGUAGE ExplicitNamespaces #-}
{-# LANGUAGE PatternSynonyms #-}
module Test (type (++), (++), pattern Foo) where

#test explicitnamespaces_patternsynonyms import
{-# LANGUAGE ExplicitNamespaces #-}
{-# LANGUAGE PatternSynonyms #-}
import           Test                                     ( type (++)
                                                          , (++)
                                                          , pattern Foo
                                                          , pattern (:.)
                                                          )

###############################################################################
## UnboxedTuples + MagicHash
#test unboxed-tuple and vanilla names
{-# LANGUAGE UnboxedTuples #-}
spanKey :: (# Int, Int #) -> (# Int, Int #)
spanKey = case foo of
  (# bar, baz #) -> (# baz, bar #)

#test unboxed-tuple and hashed name
{-# LANGUAGE MagicHash, UnboxedTuples #-}
spanKey :: (# Int#, Int# #) -> (# Int#, Int# #)
spanKey = case foo of
  (# bar#, baz# #) -> (# baz# +# bar#, bar# #)