############################################################################### ############################################################################### ############################################################################### #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# #) ############################################################################### ## QuasiQuotes #test quasi-quotes simple 1 {-# LANGUAGE QuasiQuotes #-} func = [blub| asd qwe |] #test quasi-quotes simple 2 {-# LANGUAGE QuasiQuotes #-} func = [blub| asd qwe|] #test quasi-quotes ignoring layouting {-# LANGUAGE QuasiQuotes #-} func = do let body = [json| hello |] pure True #test quasi-quotes ignoring layouting, strict mode -- brittany { lconfig_allowHangingQuasiQuotes: False } {-# LANGUAGE QuasiQuotes #-} func = do let body = [json| hello |] pure True