leungbk
commented
2 years ago Closed mpickering closed 2 years ago
leungbk
commented
2 years ago leungbk
commented
2 years ago When I try building haskellPackages.fast-tags on the haskell-updates branch on aarch64-darwin, two tests fail for me.
cdepillabout
commented
2 years ago @mpickering Basically the process is to remove this line:
Then run ./maintainers/scripts/haskell/regenerate-hackage-packages.sh in order to regenerate hackage-packages.nix. Send a PR to the haskell-updates branch with those changes.
sternenseemann
commented
2 years ago It was marked broken due to this test failure:
tests
tokenize
"xyz -- abc": OK
"xyz --- abc": OK
" {- foo -}": OK
" {- foo \n\n-}": OK
" {- foo {- bar-} -}": OK
" {-# INLINE #-}": OK
"a::b->c": OK
"a\8759b\8594c": OK
"x{-\n bc#-}\n": OK
"X.Y": OK
"a=>b": OK
"a \8658 b": OK
"x9": OK
"x :+: y": OK
"(#$)": OK
"Data.Map.map": OK
"Map.map": OK
"forall a. f a": OK
"forall a . Foo": OK
"forall a. Foo": OK
"forall a .Foo": OK
"forall a.Foo": OK
"$#-- hi": OK
"(*), (-)": OK
"(.::)": OK
"data (:+) a b": OK
"data (.::+::) a b": OK
"foo \"bar\" baz": OK
"foo \"bar\\\n \\bar\" baz": OK
"foo \"bar\\\r\n \\bar\" baz": OK
"foo \"bar\\\r\n\\bar\" baz": OK
"(\\err -> case err of Foo -> True; _ -> False)": OK
"foo = \"foo\\n\\\r\n \\\" bar": OK
"foo = \"foo\\n\\\n \\x\" bar": OK
"{- ___ -}import Data.Char;main=putStr$do{c<-\"/1 AA A A;9+ )11929: OK
"one_hash, two_hash :: text_type\nhash_prec :: Int -> Int\none_hash =: OK
"showComplexFloat x 0.0 = showFFloat Nothing x \"\"": OK
"deriveJSON defaultOptions ''CI.CI": OK
"--:+: :+: :+:": OK
"\\x -> y": OK
"f :: G -> N -> R\nf g = \n\\n -> case lookup n info' of\n\tNothing ->: OK
tokenize splices
"$(foo)": OK
"$(foo [| baz |])": OK
"$(foo \10214 baz \10215)": OK
"$(foo [bar| baz |])": OK
"$(foo [Foo.bar| baz \10215)": OK
"$(foo [$bar| baz |])": OK
"$(foo [$Foo.bar| baz \10215)": OK
"$(foo [bar| bar!\nbaz!\n $(baz) |])": OK
"$(foo [Foo.bar| bar!\nbaz!\n $(baz) \10215)": OK
"$(foo [$bar| bar!\nbaz!\n $(baz) |])": OK
"$(foo [$Foo.bar| bar!\nbaz!\n $(baz) \10215)": OK
"foo [$bar| baz |]": OK
"foo [$bar|\n baz |]": OK
"foo [$bar|\n baz \n|]": OK
"foo\n$bar\nbaz": OK
"foo\nf $ x = f x\nbaz": OK
"import Foo hiding (Bar)": OK
"foo\n#{enum Bar, Baz }\nquux": OK
"newtype ControlOp' = ControlOp' CInt\n\n#{enum ControlOp, ControlOp\n: OK
"a # b = apply a b": OK
"\"\"": OK
"\"a\"": OK
"\"abc\"": OK
"\"abc\\n\"": OK
"\"abc\\d\"": OK
"\"abc\\\\d\"": OK
"\"\\\\d\"": OK
"\"\\\\\"": OK
"\"a\" ++ \"b\"": OK
"\"\\\\\" ++ \"b\"": OK
"'a'": OK
"'\\''": OK
"'\"'": OK
"'\\\\'": OK
"foo' bar'": OK
"'\\n'": OK
"argsOf s = map (init . (drop $ 2 + length s)) . filter ((\"\\\\\" ++ : OK
"foo\n# 17 \"/usr/include/stdc-predef.h\" 3 4\nbar": OK
"foo\n#{get_area \"Queue.T\"}\nbar": OK
"foo\n#ccall apr_atomic_init, Ptr <apr_pool_t> -> IO <apr_status_t>\nb: OK
tokenize with newlines
vanilla
"x\ny\n": OK
" xx\n yy\n": OK
"\nclass (X x) => C a b where\n\tm :: a->b\n\tn :: c\n": OK
literate
"foo bar baz": OK
"foo bar baz\nquux fizz buzz": OK
"> foo = 1": OK
"This is a factorial function\n\n> f :: Integer -> Integer\n> f 0 = 1\: OK
"This is a factorial function\n\n> f :: Integer -> Integer\n> f 0 = 1\: OK
" This is a factorial function\n\n> f :: Integer -> Integer\n> f 0 : OK
"This is a factorial function\n\\begin{code}\nf :: Integer -> Integer\: OK
"This is a 'factorial' function\n\\begin{code}\nf :: Integer -> Intege: OK
"This is a 'factorial' function\n\\begin{code}\n f :: Integer -> Inte: OK
"Test\n\\begin{code}\nclass (X x) => C a b where\n m :: a->b\n n :: : OK
"Test\n\\begin{code}\nclass (X x) => C a b where\n\tm :: a->b\n\tn :: : OK
Comments stripping
"hello -- there": OK
"hello --there": OK
"hello {- there -} fred": OK
"hello -- {- there -}\nfred": OK
"{-# LANG #-} hello {- there {- nested -} comment -} fred": OK
"hello {-\nthere\n------}\n fred": OK
"hello {- \nthere\n ------} \n fred": OK
"hello {-\nthere\n-----}\n fred": OK
"hello {- \nthere\n -----} \n fred": OK
"hello {-\n-- there -}": OK
"foo --- my comment\n--- my other comment\nbar": OK
Break blocks
vanilla
"a\nb\n": OK
"a\n a\nb\n": OK
"a\n a\n a\nb\n": OK
"a\n a\n\n a\nb\n": OK
"a\n\n\n a\nb\n": OK
"a\n aa\n aa\n": OK
" aa\n aa\n": OK
"one_hash, two_hash :: text_type\nhash_prec :: Int -> Int\none_hash =: OK
"one_hash, two_hash :: text_type; hash_prec :: Int -> Int; one_hash =: OK
"{\n data F f :: * ; -- foo\n -- bar\n : OK
literate
"> a\n>\n>\n> a\n> b\n": OK
"> a\n> \n> \n> a\n> b\n": OK
"> a\n> aa\n> aa\n": OK
"> a\n> aa\n>\n> aa\n": OK
whereBlock
"class A f where\n data F f :: * -- foo\n -- bar\n : OK
"class A f where {\n data F f :: * ; -- foo\n -- bar: OK
Emacs
format
fn:10:20:/wibble/:/ wobble/:TagVal {tvName = "wibble wobble", tvType =: OK
Vim
parseTag
("fn",1,"text",Function): OK
dropAdjacent
[("fn",0,"a")]: OK
[("fn",0,"a"),("fn",1,"a")]: OK
[("fn",1,"a"),("fn",0,"a")]: OK
[("fn",0,"a"),("fn",1,"a"),("fn",2,"a")]: OK
[("fn",0,"a"),("fn",1,"a"),("fn",2,"a"),("fn",3,"a")]: OK
[("fn",0,"a"),("fn2",1,"a")]: OK
[("fn",0,"a"),("fn",1,"b")]: OK
process
prefix, suffix and offset tracking
"module Bar.Foo where\n": OK
"newtype Foo a b =\n\tBar x y z\n": OK
"data Foo a b =\n\tBar x y z\n": OK
"f :: A -> B\ng :: C -> D\ndata D = C {\n\tf :: A\n\t}\n": OK
"instance Foo Bar where\n newtype FooFam Bar = BarList [Int]": OK
"instance Foo Bar where\n newtype FooFam Bar = BarList { getBarList :: OK
"instance Foo Bar where\n data (Ord a) => FooFam Bar a = BarList { ge: OK
"newtype instance FooFam Bar = BarList { getBarList :: [Int] }": OK
"data instance (Ord a) => FooFam Bar a = BarList { getBarList :: [a] }: OK
data
"data X\n": OK
"data X = X Int\n": OK
"data Foo = Bar | Baz": OK
"data Foo =\n\tBar\n\t| Baz": OK
"data Foo a = Bar { field :: Field }": OK
"data R = R { a::X, b::Y }": OK
"data R = R { a, b::X }": OK
"data R = R { a\8759X, b\8759Y }": OK
"data R = R { a, b\8759X }": OK
"data R = R {\n\ta::X\n\t, b::Y\n\t}": OK
"data R = R {\n\ta,b::X\n\t}": OK
"data Foo a b = (:*:) { foo :: a, bar :: b }": OK
"data R = R {\n a :: !RealTime\n , b :: !RealTime\n}": OK
"data Rec = Rec {\n a :: Int\n, b :: !Double\n, c :: Maybe Rec\n}": OK
"data X = X !Int": OK
"data X = Y !Int !X | Z": OK
"data X = Y :+: !Z | !X `Mult` X": OK
"data X = !Y `Add` !Z": OK
"data X = forall a. Y a": OK
"data X = forall a . Y a": OK
"data X = forall a .Y a": OK
"data X = forall a.Y a": OK
"data X = forall a. Eq a => Y a": OK
"data X = forall a. (Eq a) => Y a": OK
"data X = forall (a :: Nat). (Eq' a) => Y a": OK
"data X = forall a. (Eq a, Ord a) => Y a": OK
"data X = forall a. Ref :<: a => Y a": OK
"data X = forall a. (:<:) Ref a => Y a": OK
"data X = forall a. ((:<:) Ref a) => Y a": OK
"data X = forall a. Y !a": OK
"data X = forall a. (Eq a, Ord a) => Y !a": OK
"data Foo a = \n Plain Int\n | forall a. Bar a Int\n | forall a b: OK
"data X a = Add a ": OK
"data Eq a => X a = Add a": OK
"data (Eq a) => X a = Add a": OK
"data (Eq a, Ord a) => X a = Add a": OK
"data (Eq (a), Ord (a)) => X a = Add a": OK
"data Ref :<: f => X f = RRef f": OK
"data a :<: b => X a b = Add a": OK
"newtype Ref :<: f => X f = RRef f": OK
"newtype a :<: b => X a b = Add a": OK
"data Ref :<: [f] => X f = RRef f": OK
"data [a] :<: b => X a b = Add a": OK
"newtype Ref :<: [f] => X f = RRef f": OK
"newtype [a] :<: b => X a b = Add a": OK
"data (a :<: b) => X a b = Add a": OK
"data a :><: b = a :>|<: b": OK
"data (:><:) a b = (:>|<:) a b": OK
"data (:><:) a b = Foo b | (:>|<:) a b": OK
"data (:><:) a b = Foo b | forall c. (:>|<:) a c": OK
"data (:><:) a b = Foo b | forall c. (Eq c) => (:>|<:) a c": OK
"data (:><:) a b = Foo b | forall c. Eq c => (:>|<:) a c": OK
"newtype Eq a => X a = Add a": OK
"newtype (Eq a) => X a = Add a": OK
"newtype (Eq a, Ord a) => X a = Add a": OK
"newtype () => X a = Add a": OK
"newtype (u :*: v) z = X": OK
"data (u :*: v) z = X": OK
"type (u :*: v) z = (u, v, z)": OK
"newtype ((u :: (* -> *) -> *) :*: v) z = X": OK
"data ((u :: (* -> *) -> *) :*: v) z = X": OK
"type ((u :: (* -> *) -> *) :*: v) z = (u, v, z)": OK
"newtype () => ((u :: (* -> *) -> *) :*: v) z = X": OK
"data () => ((u :: (* -> *) -> *) :*: v) z = X": OK
"type () => ((u :: (* -> *) -> *) :*: v) z = (u, v, z)": OK
"newtype (Eq (v z)) => ((u :: (* -> *) -> *) :*: v) z = X": OK
"data (Eq (v z)) => ((u :: (* -> *) -> *) :*: v) z = X": OK
"type (Eq (v z)) => ((u :: (* -> *) -> *) :*: v) z = (u, v, z)": OK
"newtype Eq (v z) => ((u :: (* -> *) -> *) :*: v) z = X": OK
"data Eq (v z) => ((u :: (* -> *) -> *) :*: v) z = X": OK
"type Eq (v z) => ((u :: (* -> *) -> *) :*: v) z = (u, v, z)": OK
"newtype (Eq (v z)) => ((u :: (* -> *) -> *) `Foo` v) z = X": OK
"data (Eq (v z)) => ((u :: (* -> *) -> *) `Foo` v) z = X": OK
"type (Eq (v z)) => ((u :: (* -> *) -> *) `Foo` v) z = (u, v, z)": OK
"type (Eq (v z)) => ((u \8759 (* -> *) -> *) `Foo` v) z = (u, v, z)": OK
"newtype Eq (v z) => ((u :: (* -> *) -> *) `Foo` v) z = X": OK
"data Eq (v z) => ((u :: (* -> *) -> *) `Foo` v) z = X": OK
"type Eq (v z) => ((u :: (* -> *) -> *) `Foo` v) z = (u, v, z)": OK
"type Eq (v z) \8658 ((u \8759 (* \8594 *) \8594 *) `Foo` v) z = (u, v: OK
"data (:*:) u v z = X": OK
"data (Eq (u v), Ord (z)) => (:*:) u v z = X": OK
"data (u `W` v) z = X": OK
"data (Eq (u v), Ord (z)) => (u `W` v) z = X": OK
"newtype X a = Z {\n -- TODO blah\n foo :: [a] }": OK
"newtype (u :*: v) z = X {\n -- my insightful comment\n extract :: (u : OK
"newtype (u :*: v) z = X {\n -- my insightful comment\n pattern :: (u : OK
"data Hadron a b = Science { f :: a, g :: a, h :: b }": OK
"data Hadron a b = Science { f :: a, g :: a, pattern :: b }": OK
"data Hadron a b = Science { f :: a, g :: (a, b), h :: b }": OK
"data Hadron a b = forall x. Science { f :: x, h :: b }": OK
"data Hadron a b = forall x. Science { f :: [x], h :: b }": OK
"data Hadron a b = forall x y. Science { f :: (x, y), h :: b }": OK
"data Hadron a b = forall x y. Science { f :: [(x, y)], h :: b }": OK
"data Hadron a b = forall x y. Science { f :: [(Box x, Map x y)], h ::: OK
"data Hadron a b = forall x y. Science { f \8759 [(Box x, Map x y)], h: OK
"data Hadron a b = forall x y z. Science\n { f :: x\n , g :: [(Box x: OK
"data Hadron a b = forall x y z. Science\n { f :: x\n , g :: [(Box x: OK
"data Hadron a b = Science { h :: b }": OK
"data Test a b =\n Foo a\n | Bar [(Maybe a, Map a b, b)]": OK
"data Test a b =\n Foo a\n | [(Maybe b, Map b a, a)] `Bar` [(Maybe: OK
"data IO a = IO (World->(a,World))": OK
"data SubTransformTriple a =\n SubTransformTriple\n (: OK
"data TestCase \n = forall a prop . (Testable prop, Data a) \n =: OK
"-- | Binding List\ndata BindingList v a = Variable v => BindingList {: OK
"data Tester a = Tester\n {(===) :: [String] -> a -> IO ()\n ,fa: OK
"data Tester a = Tester\n {(===) :: [String] -> a -> IO ()\n ,fa: OK
"-- | View of the right end of a sequence.\ndata ViewR s a\n = Empt: OK
"-- | View of the right end of a sequence.\ndata ViewR s a\n = s a : OK
"data [] a = [] | a : [a]": OK
"data () = ()": OK
"data (,) a b = (,) a b": OK
"data (,,) a b c = (,,) a b c": OK
"data (a, b) = (a, b)": OK
"data (a, b, c) = (a, b, c)": OK
gadt
"data X where A :: X\n": OK
"data X where\n\tA :: X\n": OK
"data X where\n\tA :: X\n\tB :: X\n": OK
"data X where\n\tA, B :: X\n": OK
"data X :: * -> * -> * where\n A, B :: Int -> Int -> X\n": OK
"data X \8759 * \8594 * \8594 * where\n A, B \8759 Int \8594 Int \859: OK
"data Vec ix where\n Nil :: Int -> Foo Int\n (:::) :: Int -> Vec I: OK
"data Vec ix where\n Nil :: Int -> Foo Int\n -- foo\n (:::) :: In: OK
"data NatSing (n :: Nat) where\n ZeroSing :: 'Zero\n SuccSing :: Nat: OK
"data Rec a where\n C :: { foo :: Int } -> Rec a": OK
"data Rec a where\n C :: { foo :: Int, bar :: Int -> Int } -> Rec a": OK
"data Rec a where\n C :: { foo :: Int, bar :: Int -> Int } -> Rec a\n: OK
"newtype TyConProxy a b where\n TyConProxy :: () -> TyConProxy a b\: OK
"data Foo a where\n Bar :: Baz a => { foo :: Int, bar :: a } -> Foo a: OK
"type role Map nominal representational": OK
families
"type family X :: *\n": OK
"data family X :: * -> *\n": OK
"data family a ** b": OK
"type family a :<: b\n": OK
"type family (a :: Nat) :<: (b :: Nat) :: Nat\n": OK
"type family (a :: Nat) `Family` (b :: Nat) :: Nat\n": OK
"type family (m :: Nat) <=? (n :: Nat) :: Bool": OK
"type family (m \8759 Nat) <=? (n \8759 Nat) \8759 Bool": OK
"data instance X a b = Y a | Z { unZ :: b }": OK
"data instance (Eq a, Eq b) => X a b = Y a | Z { unZ :: b }": OK
"data instance (Eq a, Eq b) => X a b = Y a | Z { pattern :: b }": OK
"data instance XList Char = XCons !Char !(XList Char) | XNil": OK
"newtype instance Cxt x => T [x] = A (B x) deriving (Z,W)": OK
"type instance Cxt x => T [x] = A (B x)": OK
"data instance G [a] b where\n G1 :: c -> G [Int] b\n G2 :: G [a] : OK
"class C where\n\ttype X y :: *\n": OK
"class C where\n\tdata X y :: *\n": OK
"class C where\n\ttype X y \8759 *\n": OK
"class C where\n\tdata X y \8759 *\n": OK
functions
"a,b::X": OK
"(+), a :: X": OK
"(\8226) :: X": OK
"1 :: Int": OK
"f :: Int -> Int\nf _ = 1": OK
"(.::) :: X -> Y": OK
"(+::) :: X -> Y": OK
"(->:) :: X -> Y": OK
"(--+) :: X -> Y": OK
"(=>>) :: X -> Y": OK
"one_hash, two_hash :: text_type;\nhash_prec :: Int -> Int;\none_hash : OK
"one_hash, two_hash :: text_type; hash_prec :: Int -> Int; one_hash =: OK
"assertDataFormatError :: DecompressError -> IO String\nassertDataForm: OK
"instance PartialComparison Double where\n type PartialCompareEffor: OK
"hexQuad :: Z.Parser Int\nhexQuad = do\n s <- Z.take 4\n let hex n |: OK
"instance Path T.Text where readPath = Just; pathRep _ = typeRep: OK
"prop_bounds2 o1 w1 o2 w2 = let n1 = fromW8 w1 ; n2 = fromW8 w2 ; bs =: OK
"string :: String -> ReadP r String\n-- ^ Parses and returns the speci: OK
"-- | Get every node of a tree, put it into a list.\nclimb :: Tree a -: OK
"addend hid a (NotM (App uid okh elr as)) = NotM $ App uid okh elr (f : OK
"realWorldTc :: TyCon; \\\nrealWorldTc = mkTyCon3 \"ghc-prim\" \"GHC.T: OK
"(r `mkQ` br) a = _": OK
"_?_ = return unsafePerformIO": OK
"(+) :: DebMap -> String -> DebianVersion\nm + k = maybe (error (\"No : OK
"(!) :: DebMap -> String -> DebianVersion\n_ ! k = maybe (error (\"No : OK
"(.) :: DebMap -> String -> DebianVersion\nm . k = maybe (error (\"No : OK
"(.) :: DebMap -> String -> DebianVersion\nm . k x = maybe (error (\"N: OK
"{- 123___ -}import Data.Char;main=putStr$do{c<-\"/1 AA A A;9+ )11929 : OK
"{- 456___ -}import Data.Char;main=putStr$do{c<-\"/1 AA A A;9+ )11: OK
"showComplexFloat :: Double -> Double -> String\nshowComplexFloat x 0.: OK
"createAlert :<|>\n getAlert :<|>\n deleteAler: OK
"_g :: X -> Y": OK
"(f . g) x = f (g x)": OK
"(#) :: TransArray c => c -> (b -> IO r) -> Trans c b -> IO r\na # b =: OK
"escape :: FilePath -> FilePath\nescape s = \"\\\"\" ++ concatMap esc : OK
"happyError = \tks i -> error (\n\t\"Parse error in line \" ++ show (i: OK
"> happyError = \tks i -> error (\n>\t\"Parse error in line \" ++ show: OK
"module UnindentedImportList(\nfoo,\n(++),\nbar,\nquux \n)\nwhere\n\ni: OK
"\n\n#define FOO\n\n\n module UnindentedImportList(\n foo,\n (++),\: OK
"\n{-# LANGAUGE TemplateHaskell #-}\nmodule Example where\n\nimport Lo: OK
"\n{-# LANGAUGE TemplateHaskell #-}\nmodule Example where\n\nimport Lo: OK
toplevel functions without signatures
"$(return . map sumDeclaration $ [0..15])": OK
"$( fmap (reverse . concat) . traverse prismsForSingleType $ [1..15] ): OK
"T.makeInstances [2..6]\nx": OK
"infix 5 |+|": OK
"infixl 5 |+|": OK
"infixr 5 |+|": OK
"f = g": OK
"f :: a -> b -> a\nf x y = x": OK
"f x y = x": OK
"f (x :+: y) z = x": OK
"(x :+: y) `f` z = x": OK
"(x :+: y) *: z = x": OK
"((:+:) x y) *: z = x": OK
"(*:) (x :+: y) z = x": OK
"(*:) ((:+:) x y) z = x": OK
strict match (!)
"f !x y = x": OK
"f x !y = x": OK
"f !x !y = x": OK
"f ! x y = x": OK
"f ! x = x": OK
"(*:) !(x :+: y) z = x": OK
"(*:) !(!x :+: !y) !z = x": OK
"(*:) !((:+:) x y) z = x": OK
"(*:) !((:+:) !x !y) !z = x": OK
"(!) :: a -> b -> a\n(!) x y = x": OK
"x ! y = x": OK
lazy match (~)
"f ~x y = x": OK
"f x ~y = x": OK
"f ~x ~y = x": OK
"f ~ x y = x": OK
"f ~ x = x": OK
"(*:) ~(x :+: y) z = x": OK
"(*:) ~(~x :+: ~y) ~z = x": OK
"(*:) ~((:+:) x y) z = x": OK
"(*:) ~((:+:) ~x ~y) ~z = x": OK
"(~) :: a -> b -> a\n(~) x y = x": OK
"x ~ y = x": OK
at patterns (@)
"f z@x y = z": OK
"f x z'@y = z'": OK
"f z@x z'@y = z": OK
"f z@(Foo _) z'@y = z": OK
"f z@(Foo _) z'@(Bar _) = z": OK
"f z @ x y = z": OK
"f z @ (x : xs) = z: [x: xs]": OK
"f z @ (x : zs @ xs) = z: [x: zs]": OK
"f z @ (zz @x : zs @ xs) = z: [zz: zs]": OK
"(*:) zzz@(x :+: y) z = x": OK
"(*:) zzz@(zx@x :+: zy@y) zz@z = x": OK
"(*:) zzz@((:+:) x y) z = x": OK
"(*:) zzz@((:+:) zs@x zs@y) zz@z = x": OK
"f z@(!x) ~y = x": OK
"f x Nothing = x\nf x (Just y) = y": OK
"x `f` Nothing = x\nx `f` (Just y) = y": OK
"f x y = g x\n where\n g _ = y": OK
"x `f` y = x": OK
"(|+|) x y = x": OK
"x |+| y = x": OK
"(!) x y = x": OK
"--- my comment": OK
"foo :: Rec -> Bar\nfoo Rec{..} = Bar (recField + 1)": OK
"foo :: Rec -> Bar\nfoo Rec { bar = Baz {..}} = Bar (recField + 1)": OK
"pattern :: Int -> String -> [Int]": OK
"pattern x () = x + x": OK
"pattern, foo :: Int -> String -> [Int]": OK
"foo, pattern :: Int -> String -> [Int]": OK
"foo, pattern, bar :: Int -> String -> [Int]": OK
"pattern x = x ": OK
"pattern x y = x + y": OK
"x `pattern` y = x + y": OK
"pattern x y z = x + y + z": OK
"f forall = forall + 1": OK
"a # b = apply a b": OK
class
"class (X x) => C a b where\n\tm :: a->b\n\tn :: c\n": OK
"class (X x) \8658 C a b where\n\tm \8759 a\8594b\n\tn \8759 c\n": OK
"class (X x) => C a b | a -> b where\n\tm :: a->b\n\tn :: c\n": OK
"class (X x) \8658 C a b | a \8594 b where\n\tm \8759 a\8594b\n\tn \87: OK
"class A a where f :: X\n": OK
"class X where\n\ta, (+) :: X\n": OK
"class X where\n\ta :: X\n\tb, c :: Y": OK
"class X\n\twhere\n\ta :: X\n\tb, c :: Y": OK
"class X\n\twhere\n\ta ::\n\t\tX\n\tb :: Y": OK
"class a :<: b where\n f :: a -> b": OK
"class (:<:) a b where\n f :: a -> b": OK
"class Eq a => a :<: b where\n f :: a -> b": OK
"class a ~ 'Foo => a :<: b where\n f :: a -> b": OK
"class 'Foo ~ a => a :<: b where\n f :: a -> b": OK
"class (Eq a) => a :<: b where\n f :: a -> b": OK
"class (a ~ 'Foo) => a :<: b where\n f :: a -> b": OK
"class ('Foo ~ a) => a :<: b where\n f :: a -> b": OK
"class a :<<<: b => a :<: b where\n f :: a -> b": OK
"class (a :<<<: b) => a :<: b where\n f :: a -> b": OK
"class (a :<<<: b) \8658 a :<: b where\n f \8759 a \8594 b": OK
"class (Eq a, Ord b) => a :<: b where\n f :: a -> b": OK
"class (Eq a, Ord b) => (a :: (* -> *) -> *) :<: b where\n f :: a -: OK
"class (Eq (a), Ord (f a [a])) => f `Z` a": OK
"class A f where\n data F f :: *\n g :: a -> f a\n h :: f a -> a": OK
"class A f where\n data F f :: *\n mkF :: f -> F f\n getF :: F f ->: OK
"class A f where\n data F f :: * -- foo\n -- bar\n : OK
"class X a where\n\tfoo :: Eq a => a -> a\n": OK
"class Category cat where\n -- | the identity morphism\n id :: c: OK
"class Match a b where\n pattern :: Pattern a b\n": OK
"class a ~~ b => (a :: k) ~ (b :: k) | a -> b, b -> a": OK
"class a ~~ b => (a :: k) ! (b :: k) | a -> b, b -> a": OK
"class A f where {\n data F f :: * ; -- foo\n -- bar: OK
instance
"instance Foo Quux where\n data Bar Quux a = QBar { frob :: a }\n : OK
"instance Foo Quux where\n data Bar Quux a = QBar a | QBaz String der: OK
"instance Foo Quux where\n data Bar Quux a = QBar { frob :: a }\n : OK
"instance Foo Quux where\n data Bar Quux a = QBar { frob :: a }\n : OK
"instance Foo Int where foo _ = 1": OK
"instance Foo Quux where\n newtype Bar Quux a = QBar a \n : OK
"instance Foo Quux where\n newtype Bar Quux a = QBar { frob :: a }": OK
"instance (Monoid w, MBC b m) => MBC b (JournalT w m) where\n newtyp: OK
Literate
"> class (X x) => C a b where\n>\tm :: a->b\n>\tn :: c\n": OK
"Test\n\\begin{code}\nclass (X x) => C a b where\n\tm :: a->b\n\tn :: : OK
"> precalcClosure0 :: Grammar -> Name -> RuleList\n> precalcClosure0 g: OK
"New Resolutions by Jean-Luc Ponty, Scott O'Neil, and John Garvin\r\n\: OK
patterns
"pattern Arrow a b = ConsT \"->\" [a, b]": OK
"pattern Arrow a b = ConsT \"->\" [a, b]\npattern Pair a b = [a, b]": OK
"pattern Sub a b = Op '-' [a, b]\npattern Pair a b = [a, b]": OK
"pattern (:++) x y = [x, y]": OK
"pattern x :** y = [x, y]": OK
"pattern Nil :: Vec2 a\npattern Nil = Vec2 []\n": OK
"pattern (:>) x xs <- ((\\ys -> (head $ unvec2 ys,Vec2 . tail $ unvec2: OK
"\ndata Foo = Foo_ { _foo :: !(Last String) } deriving (Eq)\nnpattern : OK
"\ndata Foo = Foo_ { _foo :: !(Last String), _bar :: !(Last String) } : OK
ffi
"foreign import ccall foo :: Double -> IO Double": OK
"foreign import unsafe java foo :: Double -> IO Double": OK
"foreign import safe stdcall foo :: Double -> IO Double": OK
"foreign import safe stdcall pattern :: Double -> IO Double": OK
preprocessor defines
"#define FOO 1": OK
"#define FOO \n 1": OK
"#define FOO \n1": OK
"#define FOO(x) (x + x)": OK
"#if X\n#define FOO 1\n#else\n#define FOO 2\n#endif": OK
"#if X\n\n#define FOO 1\n\n\n#else\n\n\n#define FOO 2\n\n#endif": OK
"#define FOO(x) (x + x)": OK
"#let BAR x y z = \"x + y + z\"": OK
hsc2hs
"#{enum ControlOp, ControlOp\n , controlOpAdd = EPOLL_CTL_ADD\n , c: OK
"#{\nenum ControlOp, ControlOp\n , controlOpAdd = EPOLL_CTL_ADD\n ,: OK
"#{enum Test1, Test2 \n , foo\n , foo_bar\n , BAR_BAZ\n , BAR_BAZquux\: OK
"#enum Mask, UserSpace, IN_ACCESS, IN_MODIFY, IN_ATTRIB, IN_CLOSE_WRIT: OK
"#enum ExecOption,ExecOption, \\\n execAnchored = PCRE_ANCHORED, \\\n: OK
"#enum ReturnCode,ReturnCode, \\\n retNoMatch = PCRE_ERROR_NOMATCH, \: OK
"#{\ndefine hsc_patsyn(l, typ, cons, hprefix, recmac) { \\\n struct {: OK
alex
vanilla
"{\nmodule AlexTest where\n\nimport FooBar\n\nfoobar :: Int -> Int\nfo: OK
literate
"Very useful description 1\nVery useful description 2\n> {\n> module A: OK
"Very useful description 1\nVery useful description 2\n\\begin{code}\n: OK
happy
vanilla
"{\n{-# OPTIONS_GHC -w #-}\nmodule AttrGrammarParser (agParser) where\: OK
literate
"This parser parses the contents of the attribute grammar\ninto a list: FAIL
tests/MainTest.hs:2608:
expected: (["AttrGrammarParser","happyError","test"],[])
but got: (["AttrGrammarParser"],[])
Use -p '$0=="tests.process.happy.literate.\"This parser parses the contents of the attribute grammar\\ninto a list"' to rerun this test only.
"This parser parses the contents of the attribute grammar\ninto a list: OK
1 out of 479 tests failed (0.02s)Seems like the test suite is flaky?
Describe the bug
haskellPackage.fast-tags is marked broken, but builds fine.
Steps To Reproduce
The build fails because the package is marked broken.. it just needs to be marked as unbroken, but I don't know where to modify to achieve that as the brokeness is described in the generated
hackage-packages.nixfile.Expected behavior
The build succeeds