diff --git a/EXAMPLES.md b/EXAMPLES.md
deleted file mode 100644
index a4e4f8a..0000000
--- a/EXAMPLES.md
+++ /dev/null
@@ -1,296 +0,0 @@
-We aim for a format of Haskell code that minimizes the amount of changes
-necessary when modifying a line. For instance the indentation of any
-given fragment of code should not depend on the length of identifiers.
-
-```Haskell
-longFunctionName :: a
-                 -> b
-                 -> c
-                 -> d
-                 -> (a, b, c, d)
-```
-
-Renaming the function requires changing all the lines to 
-```Haskell
-f :: a
-  -> b
-  -> c
-  -> d
-  -> (a, b, c, d)
-```
-
-A preferred alternative is to format like
-```Haskell
-longFunctionName
-  :: a
-  -> b
-  -> c
-  -> d
-  -> (a, b, c, d)
-```
-
-We are grabbing some inspiration from
-[Elm](https://elm-lang.org/docs/style-guide)
-and
-[Tweag's](https://github.com/tweag/guides/blob/master/style/Haskell.md)
-style guides.
-
-The following examples show how a program is formatted in
-multiple lines when the user introduces linebreaks. Otherwise,
-the programs would be written in one line.
-
-### Function types
-
-```Haskell
-functionName
-  :: (C1, C2, C3)
-  => a
-  -> b
-  -> c
-  -> d
-  -> (a, b, c, d)
-```
-
-Context
-```Haskell
-functionName
-  :: ( C1
-     , C2
-     , C3
-     , C4
-     , C5
-     )
-  => a
-  -> b
-  -> c
-  -> d
-  -> (a, b, c, d)
-```
-
-Arguments
-```Haskell
-functionName
-  :: (C1, C2, C3, C4, C5)
-  => a
-  -> b
-  -> (forall a.
-        (C6, C7)
-     => LongDataTypeName
-     -> a
-     -> AnotherLongDataTypeName
-     -> b 
-     -> c
-     )
-  -> (c -> d)
-  -> (a, b, c, d)
-```
-
-```Haskell
-functionName
-  :: (C1, C2, C3, C4, C5)
-  => a
-  -> b
-  -> (  LongDataTypeName
-          AnotherLongDataTypeName
-          AnotherLongDataTypeName2
-          AnotherLongDataTypeName3
-     -> a
-     -> AnotherLongDataTypeName4
-     -> b
-     -> c
-     )
-  -> (c -> d)
-  -> (a, b, c, d)
-```
-
-### Expressions
-
-```Haskell
-f x y z =
-    if x then longFunctionName y else anotherLongFunctionName z
-```
-
-A lambda
-```Haskell
-f =
-    \(LongPattern x) ->
-    longFunctionName x
-```
-
-Multiple lambdas
-```Haskell
-f =
-    \(LongPattern x) ->
-    \(LongPattern2 y) ->
-    longFunctionName x
-```
-
-Lambda arguments
-```Haskell
-f xs =
-    forM xs $
-    \( LongPattern x
-     , LongPattern2 y
-     ) ->
-    longFunctionName x
-```
-
-There is a do block. Note the change of indentation in the
-body of `forM`.
-```Haskell
-f xs = do
-    forM xs $
-      \( LongPattern x
-       , LongPattern2 y
-       ) ->
-      longFunctionName x
-```
-
-`if` expression
-```Haskell
-f x y z =
-    if x then
-      longFunctionName x y
-    else
-      anotherLongFunctionName x z
-```
-
-`if` expression with monadic blocks
-```Haskell
-f x y z =
-    if x then do
-      longFunctionName1 x y
-      longFunctionName2 x y
-    else do
-      anotherLongFunctionName1 x z
-      anotherLongFunctionName2 x z
-```
-
-Monadic blocks
-```Haskell
-f x y z = do
-    functionName1 x y
-    functionName2 x z
-```
-
-`case` expression
-```Haskell
-f x y z = case
-    Just w -> functionName x y w
-    Nothing -> functionName x y z
-```
-
-Branches of `case` expression
-```Haskell
-f x y z = case
-    Just w ->
-      longFunctionName x y w
-    Nothing ->
-      anotherLongFunctionName x y z
-```
-
-A list of arguments
-```Haskell
-f
-    (LongPattern x)
-    (AnotherLongPattern y)
-    =
-    functionName x y
-```
-
-Guards
-```Haskell
-f x y
-  | x > y = True
-  | otherwise = False
-```
-
-The right-hand side of guards
-```Haskell
-f x y
-  | x > y =
-    longFunctionName y
-  | otherwise =
-    anotherLongFunctionName x
-```
-
-Long guards
-```Haskell
-function x y z w y
-  | x > y
-  , y > z
-  , z > w
-  , w > z
-  =
-    longFunctionName y
-  | otherwise =
-    anotherLongFunctionName x
-```
-
-### Data type declarations
-
-Declaration
-```Haskell
-data A
-    = B
-    | C
-    | D
-    | E
-    | F
-    | G
-```
-
-TODO: GADTs, record syntax, type families
-
-### Comments
-
-```Haskell
-{- When a comment is not preceded with elements on the same line,
-   they are indented as the elements in the enclosing AST node or
-   braces/parenthesis/brackets.
-   If it is between AST nodes, it is indented as the following
-   node.
-   If the end-of-file follows, then indent to column 0.
--}
-
-f = g {- When there are preceding elements, keep single-line comments in the same line. -}
-
-h = g
-{- Multi-line comments can't be kept on the same line as @h = g@.
-   Otherwise, changing h or g would change the indentation of all
-   the comment lines.
- -}
-
-data R = R
-    {- This comment always follows the R constructor -}
-    { f1 :: T1
-      {- A comment not preceded by other elements -}
-      {- Another comment -}
-    , f2 :: T2
-    , f3 :: T3
-    }
-```
-
-```Haskell
-{- a comment line -}
-f = h
-  where
-    h = g
-    -- indented the same as g
-    g = False
-```
-
-This example
-```Haskell
-data R = R {- This comment always follows the R constructor -}
-  { f1 :: T1, {- An inner comment -} {- Another inner comment -} f2 :: T2, f3 :: T3}
-```
-is reformatted to
-```Haskell
-data R = R
-    {- This comment always follows the R constructor -}
-    { f1 :: T1 {- An inner comment -} {- Another inner comment -}
-    , f2 :: T2
-    , f3 :: T3
-    }
-```