-S String
+stripLocalLinks = replaceBetween " String
+stripLocalReferences = stripLocalLinks . stripLocalAnchors
diff --git a/hypsrc-test/accept.hs b/hypsrc-test/accept.hs
new file mode 100755
index 0000000000..4606b2dfb0
--- /dev/null
+++ b/hypsrc-test/accept.hs
@@ -0,0 +1,27 @@
+#!/usr/bin/env runhaskell
+{-# LANGUAGE CPP #-}
+
+
+import System.Directory
+import System.FilePath
+import System.Environment
+
+import Utils
+
+
+main :: IO ()
+main = do
+ args <- getArgs
+ files <- filter isHtmlFile <$> getDirectoryContents outDir'
+ let files' = if args == ["--all"] || args == ["-a"]
+ then files
+ else filter ((`elem` args) . takeBaseName) files
+ mapM_ copy files'
+ where
+ isHtmlFile = (== ".html") . takeExtension
+
+
+copy :: FilePath -> IO ()
+copy file = do
+ content <- stripLocalReferences <$> readFile (outDir' file)
+ writeFile (refDir' file) content
diff --git a/hypsrc-test/ref/src/Classes.html b/hypsrc-test/ref/src/Classes.html
new file mode 100644
index 0000000000..a5a3d243f4
--- /dev/null
+++ b/hypsrc-test/ref/src/Classes.html
@@ -0,0 +1,931 @@
+
+module Classes where
+
+
+ class Foo a where
+ bar :: a -> Int
+ baz :: Int -> ( a , a )
+
+ instance Foo Int where
+ bar = id
+ baz x = ( x , x )
+
+ instance Foo [ a ] where
+ bar = length
+ baz _ = ( [ ] , [ ] )
+
+
+ class Foo a => Foo' a where
+ quux :: ( a , a ) -> a
+ quux ( x , y ) = norf [ x , y ]
+
+ norf :: [ a ] -> a
+ norf = quux . baz . sum . map bar
+
+ instance Foo' Int where
+ norf = sum
+
+ instance Foo' [ a ] where
+ quux = uncurry ( ++ )
+
+
+ class Plugh p where
+ plugh :: p a a -> p b b -> p ( a -> b ) ( b -> a )
+
+ instance Plugh Either where
+ plugh ( Left a ) _ = Right $ const a
+ plugh ( Right a ) _ = Right $ const a
+ plugh _ ( Left b ) = Left $ const b
+ plugh _ ( Right b ) = Left $ const b
+
diff --git a/hypsrc-test/ref/src/Constructors.html b/hypsrc-test/ref/src/Constructors.html
new file mode 100644
index 0000000000..96be3627f1
--- /dev/null
+++ b/hypsrc-test/ref/src/Constructors.html
@@ -0,0 +1,834 @@
+
+module Constructors where
+
+
+ data Foo
+ = Bar
+ | Baz
+ | Quux Foo Int
+
+ newtype Norf = Norf ( Foo , [ Foo ] , Foo )
+
+
+ bar , baz , quux :: Foo
+ bar = Bar
+ baz = Baz
+ quux = Quux quux 0
+
+
+ unfoo :: Foo -> Int
+ unfoo Bar = 0
+ unfoo Baz = 0
+ unfoo ( Quux foo n ) = 42 * n + unfoo foo
+
+
+ unnorf :: Norf -> [ Foo ]
+ unnorf ( Norf ( Bar , xs , Bar ) ) = xs
+ unnorf ( Norf ( Baz , xs , Baz ) ) = reverse xs
+ unnorf _ = undefined
+
+
+ unnorf' :: Norf -> Int
+ unnorf' x @ ( Norf ( f1 @ ( Quux _ n ) , _ , f2 @ ( Quux f3 _ ) ) ) =
+ x' + n * unfoo f1 + aux f3
+ where
+ aux fx = unfoo f2 * unfoo fx * unfoo f3
+ x' = sum . map unfoo . unnorf $ x
+ module Identifiers where
+
+
+ foo , bar , baz :: Int -> Int -> Int
+ foo x y = x + x * bar y x * y + y
+ bar x y = y + x - baz x y - x + y
+ baz x y = x * y * y * y * x
+
+ quux :: Int -> Int
+ quux x = foo ( bar x x ) ( bar x x )
+
+ norf :: Int -> Int -> Int -> Int
+ norf x y z
+ | x < 0 = quux x
+ | y < 0 = quux y
+ | z < 0 = quux z
+ | otherwise = norf ( - x ) ( - y ) ( - z )
+
+
+ main :: IO ( )
+ main = do
+ putStrLn . show $ foo x y
+ putStrLn . show $ quux z
+ putStrLn . show $ Identifiers . norf x y z
+ where
+ x = 10
+ y = 20
+ z = 30
+ module Literals where
+
+
+ str :: String
+ str = "str literal"
+
+ num :: Num a => a
+ num = 0 + 1 + 1010011 * 41231 + 12131
+
+ frac :: Fractional a => a
+ frac = 42.0000001
+
+ list :: [ [ [ [ a ] ] ] ]
+ list = [ [ ] , [ [ ] ] , [ [ [ ] ] ] ]
+
+ pair :: ( ( ) , ( ( ) , ( ) , ( ) ) , ( ) )
+ pair = ( ( ) , ( ( ) , ( ) , ( ) ) , ( ) )
+ module Operators where
+
+
+ ( +++ ) :: [ a ] -> [ a ] -> [ a ]
+ a +++ b = a ++ b ++ a
+
+ ( $$$ ) :: [ a ] -> [ a ] -> [ a ]
+ a $$$ b = b +++ a
+
+ ( *** ) :: [ a ] -> [ a ] -> [ a ]
+ ( *** ) a [ ] = a
+ ( *** ) a ( _ : b ) = a +++ ( a *** b )
+
+ ( */\* ) :: [ [ a ] ] -> [ a ] -> [ a ]
+ a */\* b = concatMap ( *** b ) a
+
+ ( **/\** ) :: [ [ a ] ] -> [ [ a ] ] -> [ [ a ] ]
+ a **/\** b = zipWith ( */\* ) [ a +++ b ] ( a $$$ b )
+
+
+ ( #.# ) :: a -> b -> ( c -> ( a , b ) )
+ a #.# b = const $ ( a , b )
+ {-# LANGUAGE NamedFieldPuns #-}
+ {-# LANGUAGE RecordWildCards #-}
+
+
+ module Records where
+
+
+ data Point = Point
+ { x :: ! Int
+ , y :: ! Int
+ }
+
+
+ point :: Int -> Int -> Point
+ point x y = Point { x = x , y = y }
+
+
+ lengthSqr :: Point -> Int
+ lengthSqr ( Point { x = x , y = y } ) = x * x + y * y
+
+ lengthSqr' :: Point -> Int
+ lengthSqr' ( Point { x , y } ) = y * y + x * x
+
+
+ translateX , translateY :: Point -> Int -> Point
+ translateX p d = p { x = x p + d }
+ translateY p d = p { y = y p + d }
+
+ translate :: Int -> Int -> Point -> Point
+ translate x y p =
+ aux p
+ where
+ ( dx , dy ) = ( x , y )
+ aux Point { .. } = p { x = x + dx , y = y + dy }
+ {-# LANGUAGE TypeFamilies #-}
+
+
+ module Types where
+
+
+ data Quux = Bar | Baz
+
+ newtype Foo = Foo ( )
+
+ type FooQuux = ( Foo , Quux )
+ type QuuxFoo = ( Quux , Foo )
+
+
+ data family Norf a b
+
+ data instance Norf Foo Quux = NFQ Foo Quux
+ data instance Norf Quux Foo = NQF Quux Foo
+
+
+ type family Norf' a b
+
+ type instance Norf' Foo Quux = ( Foo , Quux )
+ type instance Norf' Quux Foo = ( Quux , Foo )
+
+
+ norf1 :: Norf Foo Quux -> Int
+ norf1 ( NFQ ( Foo ( ) ) Bar ) = 0
+ norf1 ( NFQ ( Foo ( ) ) Baz ) = 1
+
+ norf2 :: Norf Quux Foo -> Int
+ norf2 ( NQF Bar ( Foo ( ) ) ) = 0
+ norf2 ( NQF Baz ( Foo ( ) ) ) = 1
+
+
+ norf1' :: Norf' Foo Quux -> Int
+ norf1' ( Foo ( ) , Bar ) = 0
+ norf1' ( Foo ( ) , Baz ) = 1
+
+ norf2' :: Norf' Quux Foo -> Int
+ norf2' ( Bar , Foo ( ) ) = 0
+ norf2' ( Baz , Foo ( ) ) = 1
+