a year went by

This does many meta-things, but changes no functionality:
 - get rid of stack, and use just cabal with a stackage snapshot instead
   (why did I ever think stack was a good idea?)
 - update the stackage snapshot to something halfway recent
 - thus making builds work on nixpkgs-23.05 (current stable)
 - separating out packages into their own cabal files
 - use the GHC2021 set of extensions as default
 - very slight code changes to make things build again
 - update readme accordingly
 - stylish-haskell run

45 files changed, 305 insertions, 1856 deletions

diff --git a/.gitignore b/.gitignore
index 7683061..305e3cb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,2 @@
 dist-newstyle/*
-.stack-work
-walint.cabal
 result*
diff --git a/.hlint.yaml b/.hlint.yaml
deleted file mode 100644
index 202635a..0000000
--- a/.hlint.yaml
+++ /dev/null
@@ -1,1039 +0,0 @@
-# This is a custom hlint config with rules that suggest
-# using Universum functions whenever it has a suitable
-# alternative. You may either copy-paste this config into
-# your .hlint.yaml or run hlint twice: once with your
-# default config, and the second time with this one.
-# This config is *not* intended for Universum developers.
-
-############################################################################
-## Universum
-############################################################################
-
-# There's no 'head' in Universum
-- ignore: {name: "Use head"}
-
-# We have 'whenJust' for this
-- ignore: {name: "Use Foldable.forM_"}
-
-- warn: {lhs: Data.Text.pack, rhs: Universum.toText}
-- warn: {lhs: Data.Text.unpack, rhs: Universum.toString}
-
-- warn: {lhs: Data.Text.Lazy.pack, rhs: Universum.toLText}
-- warn: {lhs: Data.Text.Lazy.unpack, rhs: Universum.toString}
-- warn: {lhs: Data.Text.Lazy.toStrict, rhs: Universum.toText}
-- warn: {lhs: Data.Text.Lazy.fromStrict, rhs: Universum.toLText}
-
-- warn: {lhs: Data.Text.pack (show x), rhs: Universum.show x}
-- warn: {lhs: Data.Text.Lazy.pack (show x), rhs: Universum.show x}
-
-- warn: {lhs: Control.Exception.evaluate, rhs: evaluateWHNF}
-- warn: {lhs: Control.Exception.evaluate (force x), rhs: evaluateNF x}
-- warn: {lhs: Control.Exception.evaluate (x `deepseq` ()), rhs: evaluateNF_ x}
-- warn: {lhs: void (evaluateWHNF x), rhs: evaluateWHNF_ x}
-- warn: {lhs: void (evaluateNF x), rhs: evaluateNF_ x}
-
-## Containers
-- hint: {lhs: Data.HashMap.Lazy.keys, rhs: Universum.keys}
-- hint: {lhs: Data.HashMap.Strict.keys, rhs: Universum.keys}
-- hint: {lhs: Data.Map.Lazy.keys, rhs: Universum.keys}
-- hint: {lhs: Data.Map.Strict.keys, rhs: Universum.keys}
-- hint: {lhs: Data.IntMap.Lazy.keys, rhs: Universum.keys}
-- hint: {lhs: Data.IntMap.Strict.keys, rhs: Universum.keys}
-
-- hint: {lhs: Data.HashMap.Lazy.elems, rhs: Universum.elems}
-- hint: {lhs: Data.HashMap.Strict.elems, rhs: Universum.elems}
-- hint: {lhs: Data.Map.Lazy.elems, rhs: Universum.elems}
-- hint: {lhs: Data.Map.Strict.elems, rhs: Universum.elems}
-- hint: {lhs: Data.IntMap.Lazy.elems, rhs: Universum.elems}
-- hint: {lhs: Data.IntMap.Strict.elems, rhs: Universum.elems}
-
-- hint: {lhs: Data.HashMap.Lazy.toList, rhs: Universum.toPairs}
-- hint: {lhs: Data.HashMap.Strict.toList, rhs: Universum.toPairs}
-- hint: {lhs: Data.Map.Lazy.toList, rhs: Universum.toPairs}
-- hint: {lhs: Data.Map.Lazy.assocs, rhs: Universum.toPairs}
-- hint: {lhs: Data.Map.Strict.toList, rhs: Universum.toPairs}
-- hint: {lhs: Data.Map.Strict.assocs, rhs: Universum.toPairs}
-- hint: {lhs: Data.IntMap.Lazy.toList, rhs: Universum.toPairs}
-- hint: {lhs: Data.IntMap.Lazy.assocs, rhs: Universum.toPairs}
-- hint: {lhs: Data.IntMap.Strict.toList, rhs: Universum.toPairs}
-- hint: {lhs: Data.IntMap.Strict.assocs, rhs: Universum.toPairs}
-
-- warn: { lhs: Data.Map.toAscList (Data.Map.fromList x)
-        , rhs: Universum.sortWith fst x
-        }
-- warn: { lhs: Data.Map.toDescList (Data.Map.fromList x)
-        , rhs: Universum.sortWith (Down . fst) x
-        }
-
-- warn: {lhs: Data.Set.toList (Data.Set.fromList l), rhs: Universum.sortNub l}
-- warn: {lhs: Data.Set.assocs (Data.Set.fromList l), rhs: Universum.sortNub l}
-- warn: {lhs: Data.Set.toAscList (Data.Set.fromList l), rhs: Universum.sortNub l}
-
-- warn: {lhs: Data.HashSet.toList (Data.HashSet.fromList l), rhs: Universum.unstableNub}
-
-- hint: { lhs: nub, rhs: Universum.ordNub
-        , note: "'nub' is O(n^2), 'ordNub' is O(n log n)" }
-
-- warn: { lhs: sortBy (comparing f), rhs: Universum.sortWith f
-        , note: "If the function you are using for 'comparing' is slow, use 'sortOn' instead of 'sortWith', because 'sortOn' caches applications the function and 'sortWith' doesn't." }
-
-- warn: { lhs: sortOn fst, rhs: Universum.sortWith fst
-        , note: "'sortWith' will be faster here because it doesn't do caching" }
-- warn: { lhs: sortOn snd, rhs: Universum.sortWith snd
-        , note: "'sortWith' will be faster here because it doesn't do caching" }
-- warn: { lhs: sortOn (Down . fst), rhs: Universum.sortWith (Down . fst)
-        , note: "'sortWith' will be faster here because it doesn't do caching" }
-- warn: { lhs: sortOn (Down . snd), rhs: Universum.sortWith (Down . snd)
-        , note: "'sortWith' will be faster here because it doesn't do caching" }
-
-- warn: {lhs: map fst &&& map snd, rhs: unzip}
-
-- warn: {lhs: f >>= guard, rhs: guardM}
-- warn: {lhs: guard =<< f, rhs: guardM}
-
-- warn: {lhs: fmap concat (mapM f s), rhs: Universum.concatMapM f s}
-- warn: {lhs: concat <$> mapM f s, rhs: Universum.concatMapM f s}
-
-- warn: {lhs: fmap concat (forM f s), rhs: Universum.concatForM s f}
-- warn: {lhs: fmap concat (for f s), rhs: Universum.concatForM s f}
-- warn: {lhs: concat <$> forM f s, rhs: Universum.concatForM s f}
-- warn: {lhs: concat <$> for f s, rhs: Universum.concatForM s f}
-
-- hint: { lhs: fmap and (sequence s), rhs: Universum.andM s
-        , note: "Applying this hint would mean that some actions\n that were being executed previously would no longer be executed." }
-- hint: { lhs: and <$> sequence s, rhs: Universum.andM s
-        , note: "Applying this hint would mean that some actions\n that were being executed previously would no longer be executed." }
-
-- hint: { lhs: fmap or (sequence s), rhs: Universum.orM s
-        , note: "Applying this hint would mean that some actions\n that were being executed previously would no longer be executed." }
-- hint: { lhs: or <$> sequence s, rhs: Universum.orM s
-        , note: "Applying this hint would mean that some actions\n that were being executed previously would no longer be executed." }
-
-- hint: { lhs: fmap and (mapM f s), rhs: Universum.allM f s
-        , note: "Applying this hint would mean that some actions\n that were being executed previously would no longer be executed." }
-- hint: { lhs: and <$> mapM f s, rhs: Universum.allM f s
-        , note: "Applying this hint would mean that some actions\n that were being executed previously would no longer be executed." }
-- hint: { lhs: fmap or (mapM f s), rhs: Universum.anyM f s
-        , note: "Applying this hint would mean that some actions\n that were being executed previously would no longer be executed." }
-- hint: { lhs: or <$> mapM f s, rhs: Universum.anyM f s
-        , note: "Applying this hint would mean that some actions\n that were being executed previously would no longer be executed." }
-
-- warn: {lhs: whenM (not <$> x), rhs: unlessM x}
-- warn: {lhs: unlessM (not <$> x), rhs: whenM x}
-
-- warn: {lhs: either (const True) (const False), rhs: isLeft}
-- warn: {lhs: either (const False) (const True), rhs: isRight}
-
-- warn: {lhs: either id (const a), rhs: fromLeft a}
-- warn: {lhs: either (const b) id, rhs: fromRight b}
-
-- warn: {lhs: either Just (const Nothing), rhs: leftToMaybe}
-- warn: {lhs: either (const Nothing) Just, rhs: rightToMaybe}
-- warn: {lhs: maybe (Left l) Right, rhs: maybeToRight}
-- warn: {lhs: maybe (Right r) Left, rhs: maybeToLeft}
-
-- warn: {lhs: fromMaybe mempty, rhs: maybeToMonoid}
-- warn: {lhs: "m ?: mempty", rhs: maybeToMonoid m}
-
-
-# Probably will be reduced when function equality is done:
-# https://github.com/ndmitchell/hlint/issues/434
-- warn: {lhs: (case m of Just x -> f x; Nothing -> pure ()  ), rhs: Universum.whenJust m f}
-- warn: {lhs: (case m of Just x -> f x; Nothing -> return ()), rhs: Universum.whenJust m f}
-- warn: {lhs: (case m of Just x -> f x; Nothing -> pass     ), rhs: Universum.whenJust m f}
-- warn: {lhs: (case m of Nothing -> pure ()  ; Just x -> f x), rhs: Universum.whenJust m f}
-- warn: {lhs: (case m of Nothing -> return (); Just x -> f x), rhs: Universum.whenJust m f}
-- warn: {lhs: (case m of Nothing -> pass     ; Just x -> f x), rhs: Universum.whenJust m f}
-- warn: {lhs: (maybe (pure ())   f m), rhs: Universum.whenJust m f}
-- warn: {lhs: (maybe (return ()) f m), rhs: Universum.whenJust m f}
-- warn: {lhs: (maybe pass        f m), rhs: Universum.whenJust m f}
-
-- warn: {lhs: (m >>= \case Just x -> f x; Nothing -> pure ()  ), rhs: Universum.whenJustM m f}
-- warn: {lhs: (m >>= \case Just x -> f x; Nothing -> return ()), rhs: Universum.whenJustM m f}
-- warn: {lhs: (m >>= \case Just x -> f x; Nothing -> pass     ), rhs: Universum.whenJustM m f}
-- warn: {lhs: (m >>= \case Nothing -> pure ()  ; Just x -> f x), rhs: Universum.whenJustM m f}
-- warn: {lhs: (m >>= \case Nothing -> return (); Just x -> f x), rhs: Universum.whenJustM m f}
-- warn: {lhs: (m >>= \case Nothing -> pass     ; Just x -> f x), rhs: Universum.whenJustM m f}
-- warn: {lhs: (maybe (pure ())   f =<< m), rhs: Universum.whenJustM m f}
-- warn: {lhs: (maybe (return ()) f =<< m), rhs: Universum.whenJustM m f}
-- warn: {lhs: (maybe pass        f =<< m), rhs: Universum.whenJustM m f}
-- warn: {lhs: (m >>= maybe (pure ())   f), rhs: Universum.whenJustM m f}
-- warn: {lhs: (m >>= maybe (return ()) f), rhs: Universum.whenJustM m f}
-- warn: {lhs: (m >>= maybe pass        f), rhs: Universum.whenJustM m f}
-
-- warn: {lhs: (case m of Just _ -> pure ()  ; Nothing -> x), rhs: Universum.whenNothing_ m x}
-- warn: {lhs: (case m of Just _ -> return (); Nothing -> x), rhs: Universum.whenNothing_ m x}
-- warn: {lhs: (case m of Just _ -> pass     ; Nothing -> x), rhs: Universum.whenNothing_ m x}
-- warn: {lhs: (case m of Nothing -> x; Just _ -> pure ()  ), rhs: Universum.whenNothing_ m x}
-- warn: {lhs: (case m of Nothing -> x; Just _ -> return ()), rhs: Universum.whenNothing_ m x}
-- warn: {lhs: (case m of Nothing -> x; Just _ -> pass     ), rhs: Universum.whenNothing_ m x}
-- warn: {lhs: (maybe x (\_ -> pure ()    ) m), rhs: Universum.whenNothing_ m x}
-- warn: {lhs: (maybe x (\_ -> return ()  ) m), rhs: Universum.whenNothing_ m x}
-- warn: {lhs: (maybe x (\_ -> pass       ) m), rhs: Universum.whenNothing_ m x}
-- warn: {lhs: (maybe x (const (pure ()  )) m), rhs: Universum.whenNothing_ m x}
-- warn: {lhs: (maybe x (const (return ())) m), rhs: Universum.whenNothing_ m x}
-- warn: {lhs: (maybe x (const (pass     )) m), rhs: Universum.whenNothing_ m x}
-
-- warn: {lhs: (m >>= \case Just _ -> pure ()  ; Nothing -> x), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (m >>= \case Just _ -> return (); Nothing -> x), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (m >>= \case Just _ -> pass     ; Nothing -> x), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (m >>= \case Nothing -> x; Just _ -> pure ()  ), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (m >>= \case Nothing -> x; Just _ -> return ()), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (m >>= \case Nothing -> x; Just _ -> pass     ), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (maybe x (\_ -> pure ()    ) =<< m), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (maybe x (\_ -> return ()  ) =<< m), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (maybe x (\_ -> pass       ) =<< m), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (maybe x (const (pure ()  )) =<< m), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (maybe x (const (return ())) =<< m), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (maybe x (const (pass     )) =<< m), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (m >>= maybe x (\_ -> pure ())    ), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (m >>= maybe x (\_ -> return ())  ), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (m >>= maybe x (\_ -> pass)       ), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (m >>= maybe x (const (pure ())  )), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (m >>= maybe x (const (return ()))), rhs: Universum.whenNothingM_ m x}
-- warn: {lhs: (m >>= maybe x (const (pass)     )), rhs: Universum.whenNothingM_ m x}
-
-- warn: {lhs: (case m of Left x -> f x; Right _ -> pure ()  ), rhs: Universum.whenLeft m f}
-- warn: {lhs: (case m of Left x -> f x; Right _ -> return ()), rhs: Universum.whenLeft m f}
-- warn: {lhs: (case m of Left x -> f x; Right _ -> pass     ), rhs: Universum.whenLeft m f}
-- warn: {lhs: (case m of Right _ -> pure ()  ; Left x -> f x), rhs: Universum.whenLeft m f}
-- warn: {lhs: (case m of Right _ -> return (); Left x -> f x), rhs: Universum.whenLeft m f}
-- warn: {lhs: (case m of Right _ -> pass     ; Left x -> f x), rhs: Universum.whenLeft m f}
-- warn: {lhs: (either f (\_ -> pure ()    ) m), rhs: Universum.whenLeft m f}
-- warn: {lhs: (either f (\_ -> return ()  ) m), rhs: Universum.whenLeft m f}
-- warn: {lhs: (either f (\_ -> pass       ) m), rhs: Universum.whenLeft m f}
-- warn: {lhs: (either f (const (pure ()  )) m), rhs: Universum.whenLeft m f}
-- warn: {lhs: (either f (const (return ())) m), rhs: Universum.whenLeft m f}
-- warn: {lhs: (either f (const (pass     )) m), rhs: Universum.whenLeft m f}
-
-- warn: {lhs: (m >>= \case Left x -> f x; Right _ -> pure ()  ), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (m >>= \case Left x -> f x; Right _ -> return ()), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (m >>= \case Left x -> f x; Right _ -> pass     ), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (m >>= \case Right _ -> pure ()  ; Left x -> f x), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (m >>= \case Right _ -> return (); Left x -> f x), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (m >>= \case Right _ -> pass     ; Left x -> f x), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (either f (\_ -> pure ()    ) =<< m), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (either f (\_ -> return ()  ) =<< m), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (either f (\_ -> pass       ) =<< m), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (either f (const (pure ()  )) =<< m), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (either f (const (return ())) =<< m), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (either f (const (pass     )) =<< m), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (m >>= either f (\_ -> pure ())    ), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (m >>= either f (\_ -> return ())  ), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (m >>= either f (\_ -> pass)       ), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (m >>= either f (const (pure ())  )), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (m >>= either f (const (return ()))), rhs: Universum.whenLeftM m f}
-- warn: {lhs: (m >>= either f (const (pass)     )), rhs: Universum.whenLeftM m f}
-
-- warn: {lhs: (case m of Right x -> f x; Left _ -> pure ()  ), rhs: Universum.whenRight m f}
-- warn: {lhs: (case m of Right x -> f x; Left _ -> return ()), rhs: Universum.whenRight m f}
-- warn: {lhs: (case m of Right x -> f x; Left _ -> pass     ), rhs: Universum.whenRight m f}
-- warn: {lhs: (case m of Left _ -> pure ()  ; Right x -> f x), rhs: Universum.whenRight m f}
-- warn: {lhs: (case m of Left _ -> return (); Right x -> f x), rhs: Universum.whenRight m f}
-- warn: {lhs: (case m of Left _ -> pass     ; Right x -> f x), rhs: Universum.whenRight m f}
-- warn: {lhs: (either (\_ -> pure ()    ) f m), rhs: Universum.whenRight m f}
-- warn: {lhs: (either (\_ -> return ()  ) f m), rhs: Universum.whenRight m f}
-- warn: {lhs: (either (\_ -> pass       ) f m), rhs: Universum.whenRight m f}
-- warn: {lhs: (either (const (pure ()  )) f m), rhs: Universum.whenRight m f}
-- warn: {lhs: (either (const (return ())) f m), rhs: Universum.whenRight m f}
-- warn: {lhs: (either (const (pass     )) f m), rhs: Universum.whenRight m f}
-
-- warn: {lhs: (m >>= \case Right x -> f x; Left _ -> pure ()  ), rhs: Universum.whenRightM m f}
-- warn: {lhs: (m >>= \case Right x -> f x; Left _ -> return ()), rhs: Universum.whenRightM m f}
-- warn: {lhs: (m >>= \case Right x -> f x; Left _ -> pass     ), rhs: Universum.whenRightM m f}
-- warn: {lhs: (m >>= \case Left _ -> pure ()  ; Right x -> f x), rhs: Universum.whenRightM m f}
-- warn: {lhs: (m >>= \case Left _ -> return (); Right x -> f x), rhs: Universum.whenRightM m f}
-- warn: {lhs: (m >>= \case Left _ -> pass     ; Right x -> f x), rhs: Universum.whenRightM m f}
-- warn: {lhs: (either (\_ -> pure ()    ) f =<< m), rhs: Universum.whenRightM m f}
-- warn: {lhs: (either (\_ -> return ()  ) f =<< m), rhs: Universum.whenRightM m f}
-- warn: {lhs: (either (\_ -> pass       ) f =<< m), rhs: Universum.whenRightM m f}
-- warn: {lhs: (either (const (pure ()  )) f =<< m), rhs: Universum.whenRightM m f}
-- warn: {lhs: (either (const (return ())) f =<< m), rhs: Universum.whenRightM m f}
-- warn: {lhs: (either (const (pass     )) f =<< m), rhs: Universum.whenRightM m f}
-- warn: {lhs: (m >>= either (\_ -> pure ())     f), rhs: Universum.whenRightM m f}
-- warn: {lhs: (m >>= either (\_ -> return ())   f), rhs: Universum.whenRightM m f}
-- warn: {lhs: (m >>= either (\_ -> pass)        f), rhs: Universum.whenRightM m f}
-- warn: {lhs: (m >>= either (const (pure ())  ) f), rhs: Universum.whenRightM m f}
-- warn: {lhs: (m >>= either (const (return ())) f), rhs: Universum.whenRightM m f}
-- warn: {lhs: (m >>= either (const (pass)     ) f), rhs: Universum.whenRightM m f}
-
-- warn: {lhs: "(case m of [] -> return (); (x:xs) -> f (x :| xs))", rhs: Universum.whenNotNull m f}
-- warn: {lhs: "(case m of [] -> pure ()  ; (x:xs) -> f (x :| xs))", rhs: Universum.whenNotNull m f}
-- warn: {lhs: "(case m of [] -> pass     ; (x:xs) -> f (x :| xs))", rhs: Universum.whenNotNull m f}
-- warn: {lhs: "(case m of (x:xs) -> f (x :| xs); [] -> return ())", rhs: Universum.whenNotNull m f}
-- warn: {lhs: "(case m of (x:xs) -> f (x :| xs); [] -> pure ()  )", rhs: Universum.whenNotNull m f}
-- warn: {lhs: "(case m of (x:xs) -> f (x :| xs); [] -> pass     )", rhs: Universum.whenNotNull m f}
-- warn: {lhs: "(m >>= \\case [] -> pass     ; (x:xs) -> f (x :| xs))", rhs: Universum.whenNotNullM m f}
-- warn: {lhs: "(m >>= \\case [] -> pure ()  ; (x:xs) -> f (x :| xs))", rhs: Universum.whenNotNullM m f}
-- warn: {lhs: "(m >>= \\case [] -> return (); (x:xs) -> f (x :| xs))", rhs: Universum.whenNotNullM m f}
-- warn: {lhs: "(m >>= \\case (x:xs) -> f (x :| xs); [] -> pass     )", rhs: Universum.whenNotNullM m f}
-- warn: {lhs: "(m >>= \\case (x:xs) -> f (x :| xs); [] -> pure ()  )", rhs: Universum.whenNotNullM m f}
-- warn: {lhs: "(m >>= \\case (x:xs) -> f (x :| xs); [] -> return ())", rhs: Universum.whenNotNullM m f}
-
-- warn: {lhs: mapMaybe leftToMaybe, rhs: lefts}
-- warn: {lhs: mapMaybe rightToMaybe, rhs: rights}
-
-############################################################################
-## Reexports
-############################################################################
-
-## Applicative
-- warn: { name: "Use 'Alternative' from Universum"
-        , lhs: Control.Applicative.Alternative, rhs: Universum.Alternative }
-- warn: { name: "Use 'empty' from Universum"
-        , lhs: Control.Applicative.empty, rhs: Universum.empty }
-- warn: { name: "Use '(<|>)' from Universum"
-        , lhs: Control.Applicative.(<|>), rhs: Universum.(<|>) }
-- warn: { name: "Use 'some' from Universum"
-        , lhs: Control.Applicative.some, rhs: Universum.some }
-- warn: { name: "Use 'many' from Universum"
-        , lhs: Control.Applicative.many, rhs: Universum.many }
-- warn: { name: "Use 'Const' from Universum"
-        , lhs: Control.Applicative.Const, rhs: Universum.Const }
-- warn: { name: "Use 'getConst' from Universum"
-        , lhs: Control.Applicative.getConst, rhs: Universum.getConst }
-- warn: { name: "Use 'ZipList' from Universum"
-        , lhs: Control.Applicative.ZipList, rhs: Universum.ZipList }
-- warn: { name: "Use 'getZipList' from Universum"
-        , lhs: Control.Applicative.getZipList, rhs: Universum.getZipList }
-- warn: { name: "Use 'liftA2' from Universum"
-        , lhs: Control.Applicative.liftA2, rhs: Universum.liftA2 }
-- warn: { name: "Use 'liftA3' from Universum"
-        , lhs: Control.Applicative.liftA3, rhs: Universum.liftA3 }
-- warn: { name: "Use 'optional' from Universum"
-        , lhs: Control.Applicative.optional, rhs: Universum.optional }
-- warn: { name: "Use '(<**>)' from Universum"
-        , lhs: Control.Applicative.(<**>), rhs: Universum.(<**>) }
-
-## Base
-- warn: { name: "Use 'xor' from Universum"
-        , lhs: Data.Bits.xor, rhs: Universum.xor }
-
-- warn: { name: "Use 'chr' from Universum"
-        , lhs: Data.Char.chr, rhs: Universum.chr }
-
-- warn: { name: "Use 'Int16' from Universum"
-        , lhs: Data.Int.Int16, rhs: Universum.Int16 }
-- warn: { name: "Use 'Int32' from Universum"
-        , lhs: Data.Int.Int32, rhs: Universum.Int32 }
-- warn: { name: "Use 'Int64' from Universum"
-        , lhs: Data.Int.Int64, rhs: Universum.Int64 }
-- warn: { name: "Use 'Int8' from Universum"
-        , lhs: Data.Int.Int8, rhs: Universum.Int8 }
-
-- warn: { name: "Use 'Word16' from Universum"
-        , lhs: Data.Word.Word16, rhs: Universum.Word16 }
-- warn: { name: "Use 'Word32' from Universum"
-        , lhs: Data.Word.Word32, rhs: Universum.Word32 }
-- warn: { name: "Use 'Word64' from Universum"
-        , lhs: Data.Word.Word64, rhs: Universum.Word64 }
-- warn: { name: "Use 'Word8' from Universum"
-        , lhs: Data.Word.Word8, rhs: Universum.Word8 }
-- warn: { name: "Use 'byteSwap16' from Universum"
-        , lhs: Data.Word.byteSwap16, rhs: Universum.byteSwap16 }
-- warn: { name: "Use 'byteSwap32' from Universum"
-        , lhs: Data.Word.byteSwap32, rhs: Universum.byteSwap32 }
-- warn: { name: "Use 'byteSwap64' from Universum"
-        , lhs: Data.Word.byteSwap64, rhs: Universum.byteSwap64 }
-
-- warn: { name: "Use 'Natural' from Universum"
-        , lhs: Numeric.Natural.Natural, rhs: Universum.Natural }
-
-- warn: { name: "Use 'Handle' from Universum"
-        , lhs: System.IO.Handle, rhs: Universum.Handle }
-- warn: { name: "Use 'IOMode' from Universum"
-        , lhs: System.IO.IOMode, rhs: Universum.IOMode }
-- warn: { name: "Use 'ReadMode' from Universum"
-        , lhs: System.IO.ReadMode, rhs: Universum.ReadMode }
-- warn: { name: "Use 'WriteMode' from Universum"
-        , lhs: System.IO.WriteMode, rhs: Universum.WriteMode }
-- warn: { name: "Use 'AppendMode' from Universum"
-        , lhs: System.IO.AppendMode, rhs: Universum.AppendMode }
-- warn: { name: "Use 'ReadWriteMode' from Universum"
-        , lhs: System.IO.ReadWriteMode, rhs: Universum.ReadWriteMode }
-- warn: { name: "Use 'stderr' from Universum"
-        , lhs: System.IO.stderr, rhs: Universum.stderr }
-- warn: { name: "Use 'stdin' from Universum"
-        , lhs: System.IO.stdin, rhs: Universum.stdin }
-- warn: { name: "Use 'stdout' from Universum"
-        , lhs: System.IO.stdout, rhs: Universum.stdout }
-- warn: { name: "Use 'withFile' from Universum"
-        , lhs: System.IO.withFile, rhs: Universum.withFile }
-
-- warn: { name: "Use 'foldlM' from Universum"
-        , lhs: Data.Foldable.foldlM, rhs: Universum.foldlM }
-- warn: { name: "Use 'foldrM' from Universum"
-        , lhs: Data.Foldable.foldrM, rhs: Universum.foldrM }
-- warn: { name: "Use 'maximumBy' from Universum"
-        , lhs: Data.Foldable.maximumBy, rhs: Universum.maximumBy }
-- warn: { name: "Use 'minimumBy' from Universum"
-        , lhs: Data.Foldable.minimumBy, rhs: Universum.minimumBy }
-
-- warn: { name: "Use 'Down' from Universum"
-        , lhs: Data.Ord.Down, rhs: Universum.Down }
-- warn: { name: "Use 'comparing' from Universum"
-        , lhs: Data.Ord.comparing, rhs: Universum.comparing }
-
-- warn: { name: "Use 'fmapDefault' from Universum"
-        , lhs: Data.Traversable.fmapDefault, rhs: Universum.fmapDefault }
-- warn: { name: "Use 'foldMapDefault' from Universum"
-        , lhs: Data.Traversable.foldMapDefault, rhs: Universum.foldMapDefault }
-- warn: { name: "Use 'forM' from Universum"
-        , lhs: Data.Traversable.forM, rhs: Universum.forM }
-- warn: { name: "Use 'mapAccumL' from Universum"
-        , lhs: Data.Traversable.mapAccumL, rhs: Universum.mapAccumL }
-- warn: { name: "Use 'mapAccumR' from Universum"
-        , lhs: Data.Traversable.mapAccumR, rhs: Universum.mapAccumR }
-
-- warn: { name: "Use 'Proxy' from Universum"
-        , lhs: Data.Proxy.Proxy, rhs: Universum.Proxy }
-
-- warn: { name: "Use 'Typeable' from Universum"
-        , lhs: Data.Typeable.Typeable, rhs: Universum.Typeable }
-
-- warn: { name: "Use 'Void' from Universum"
-        , lhs: Data.Void.Void, rhs: Universum.Void }
-- warn: { name: "Use 'absurd' from Universum"
-        , lhs: Data.Void.absurd, rhs: Universum.absurd }
-- warn: { name: "Use 'vacuous' from Universum"
-        , lhs: Data.Void.vacuous, rhs: Universum.vacuous }
-
-- warn: { name: "Use 'maxInt' from Universum"
-        , lhs: Data.Base.maxInt, rhs: Universum.maxInt }
-- warn: { name: "Use 'minInt' from Universum"
-        , lhs: Data.Base.minInt, rhs: Universum.minInt }
-- warn: { name: "Use 'ord' from Universum"
-        , lhs: Data.Base.ord, rhs: Universum.ord }
-
-- warn: { name: "Use 'boundedEnumFrom' from Universum"
-        , lhs: GHC.Enum.boundedEnumFrom, rhs: Universum.boundedEnumFrom }
-- warn: { name: "Use 'boundedEnumFromThen' from Universum"
-        , lhs: GHC.Enum.boundedEnumFromThen, rhs: Universum.boundedEnumFromThen }
-
-- warn: { name: "Use 'Constraint' from Universum"
-        , lhs: GHC.Exts.Constraint, rhs: Universum.Constraint }
-- warn: { name: "Use 'FunPtr' from Universum"
-        , lhs: GHC.Exts.FunPtr, rhs: Universum.FunPtr }
-- warn: { name: "Use 'Ptr' from Universum"
-        , lhs: GHC.Exts.Ptr, rhs: Universum.Ptr }
-
-- warn: { name: "Use 'Generic' from Universum"
-        , lhs: GHC.Generics.Generic, rhs: Universum.Generic }
-
-- warn: { name: "Use 'Ratio' from Universum"
-        , lhs: GHC.Real.Ratio, rhs: Universum.Ratio }
-- warn: { name: "Use 'Rational' from Universum"
-        , lhs: GHC.Real.Rational, rhs: Universum.Rational }
-
-- warn: { name: "Use 'CmpNat' from Universum"
-        , lhs: GHC.TypeNats.CmpNat, rhs: Universum.CmpNat }
-- warn: { name: "Use 'KnownNat' from Universum"
-        , lhs: GHC.TypeNats.KnownNat, rhs: Universum.KnownNat }
-- warn: { name: "Use 'Nat' from Universum"
-        , lhs: GHC.TypeNats.Nat, rhs: Universum.Nat }
-- warn: { name: "Use 'SomeNat' from Universum"
-        , lhs: GHC.TypeNats.SomeNat, rhs: Universum.SomeNat }
-- warn: { name: "Use 'natVal' from Universum"
-        , lhs: GHC.TypeNats.natVal, rhs: Universum.natVal }
-- warn: { name: "Use 'someNatVal' from Universum"
-        , lhs: GHC.TypeNats.someNatVal, rhs: Universum.someNatVal }
-
-- warn: { name: "Use 'CmpNat' from Universum"
-        , lhs: GHC.TypeLits.CmpNat, rhs: Universum.CmpNat }
-- warn: { name: "Use 'KnownNat' from Universum"
-        , lhs: GHC.TypeLits.KnownNat, rhs: Universum.KnownNat }
-- warn: { name: "Use 'Nat' from Universum"
-        , lhs: GHC.TypeLits.Nat, rhs: Universum.Nat }
-- warn: { name: "Use 'SomeNat' from Universum"
-        , lhs: GHC.TypeLits.SomeNat, rhs: Universum.SomeNat }
-- warn: { name: "Use 'natVal' from Universum"
-        , lhs: GHC.TypeLits.natVal, rhs: Universum.natVal }
-- warn: { name: "Use 'someNatVal' from Universum"
-        , lhs: GHC.TypeLits.someNatVal, rhs: Universum.someNatVal }
-
-- warn: { name: "Use 'Coercible' from Universum"
-        , lhs: GHC.Types.Coercible, rhs: Universum.Coercible }
-
-- warn: { name: "Use 'getStackTrace' from Universum"
-        , lhs: GHC.ExecutionStack.getStackTrace, rhs: Universum.getStackTrace }
-- warn: { name: "Use 'showStackTrace' from Universum"
-        , lhs: GHC.ExecutionStack.showStackTrace, rhs: Universum.showStackTrace }
-
-- warn: { name: "Use 'IsLabel' from Universum"
-        , lhs: GHC.OverloadedLabels.IsLabel, rhs: Universum.IsLabel }
-- warn: { name: "Use 'fromLabel' from Universum"
-        , lhs: GHC.OverloadedLabels.fromLabel, rhs: Universum.fromLabel }
-
-- warn: { name: "Use 'CallStack' from Universum"
-        , lhs: GHC.Stack.CallStack, rhs: Universum.CallStack }
-- warn: { name: "Use 'HasCallStack' from Universum"
-        , lhs: GHC.Stack.HasCallStack, rhs: Universum.HasCallStack }
-- warn: { name: "Use 'callStack' from Universum"
-        , lhs: GHC.Stack.callStack, rhs: Universum.callStack }
-- warn: { name: "Use 'currentCallStack' from Universum"
-        , lhs: GHC.Stack.currentCallStack, rhs: Universum.currentCallStack }
-- warn: { name: "Use 'getCallStack' from Universum"
-        , lhs: GHC.Stack.getCallStack, rhs: Universum.getCallStack }
-- warn: { name: "Use 'prettyCallStack' from Universum"
-        , lhs: GHC.Stack.prettyCallStack, rhs: Universum.prettyCallStack }
-- warn: { name: "Use 'prettySrcLoc' from Universum"
-        , lhs: GHC.Stack.prettySrcLoc, rhs: Universum.prettySrcLoc }
-- warn: { name: "Use 'withFrozenCallStack' from Universum"
-        , lhs: GHC.Stack.withFrozenCallStack, rhs: Universum.withFrozenCallStack }
-
-- warn: { name: "Use 'Type' from Universum"
-        , lhs: Data.Kind.Type, rhs: Universum.Type }
-
-## Bool
-
-- warn: { name: "Use 'guard' from Universum"
-        , lhs: Control.Monad.guard, rhs: Universum.guard }
-- warn: { name: "Use 'unless' from Universum"
-        , lhs: Control.Monad.unless, rhs: Universum.unless }
-- warn: { name: "Use 'when' from Universum"
-        , lhs: Control.Monad.when, rhs: Universum.when }
-- warn: { name: "Use 'bool' from Universum"
-        , lhs: Data.Bool.bool, rhs: Universum.bool }
-
-## Container
-- warn: { name: "Use 'Hashable' from Universum"
-        , lhs: Data.Hashable.Hashable, rhs: Universum.Hashable }
-- warn: { name: "Use 'hashWithSalt' from Universum"
-        , lhs: Data.Hashable.hashWithSalt, rhs: Universum.hashWithSalt }
-- warn: { name: "Use 'HashMap' from Universum"
-        , lhs: Data.HashMap.Strict.HashMap, rhs: Universum.HashMap }
-- warn: { name: "Use 'HashSet' from Universum"
-        , lhs: Data.HashSet.HashSet, rhs: Universum.HashSet }
-- warn: { name: "Use 'IntMap' from Universum"
-        , lhs: Data.IntMap.Strict.IntMap, rhs: Universum.IntMap }
-- warn: { name: "Use 'IntSet' from Universum"
-        , lhs: Data.IntSet.IntSet, rhs: Universum.IntSet }
-- warn: { name: "Use 'Map' from Universum"
-        , lhs: Data.Map.Strict.Map, rhs: Universum.Map }
-- warn: { name: "Use 'Sequence' from Universum"
-        , lhs: Data.Sequence.Sequence, rhs: Universum.Sequence }
-- warn: { name: "Use 'Set' from Universum"
-        , lhs: Data.Set.Set, rhs: Universum.Set }
-- warn: { name: "Use 'swap' from Universum"
-        , lhs: Data.Tuple.swap, rhs: Universum.swap }
-- warn: { name: "Use 'Vector' from Universum"
-        , lhs: Data.Vector.Vector, rhs: Universum.Vector }
-
-## Deepseq
-- warn: { name: "Use 'NFData' from Universum"
-        , lhs: Control.DeepSeq.NFData, rhs: Universum.NFData }
-- warn: { name: "Use 'rnf' from Universum"
-        , lhs: Control.DeepSeq.rnf, rhs: Universum.rnf }
-- warn: { name: "Use 'deepseq' from Universum"
-        , lhs: Control.DeepSeq.deepseq, rhs: Universum.deepseq }
-- warn: { name: "Use 'force' from Universum"
-        , lhs: Control.DeepSeq.force, rhs: Universum.force }
-- warn: { name: "Use '($!!)' from Universum"
-        , lhs: "Control.DeepSeq.($!!)", rhs: "Universum.($!!)" }
-
-## Exception
-- warn: { name: "Use 'Exception' from Universum"
-        , lhs: Control.Exception.Exception, rhs: Universum.Exception }
-- warn: { name: "Use 'toException' from Universum"
-        , lhs: Control.Exception.toException, rhs: Universum.toException }
-- warn: { name: "Use 'fromException' from Universum"
-        , lhs: Control.Exception.fromException, rhs: Universum.fromException }
-
-- warn: { name: "Use 'Exception' from Universum"
-        , lhs: Control.Exception.Safe.Exception, rhs: Universum.Exception }
-- warn: { name: "Use 'toException' from Universum"
-        , lhs: Control.Exception.Safe.toException, rhs: Universum.toException }
-- warn: { name: "Use 'fromException' from Universum"
-        , lhs: Control.Exception.Safe.fromException, rhs: Universum.fromException }
-- warn: { name: "Use 'displayException' from Universum"
-        , lhs: Control.Exception.Safe.displayException, rhs: Universum.displayException }
-- warn: { name: "Use 'MonadCatch' from Universum"
-        , lhs: Control.Exception.Safe.MonadCatch, rhs: Universum.MonadCatch }
-- warn: { name: "Use 'MonadMask' from Universum"
-        , lhs: Control.Exception.Safe.MonadMask, rhs: Universum.MonadMask }
-- warn: { name: "Use 'mask' from Universum"
-        , lhs: Control.Exception.Safe.mask, rhs: Universum.mask }
-- warn: { name: "Use 'uninterruptibleMask' from Universum"
-        , lhs: Control.Exception.Safe.uninterruptibleMask, rhs: Universum.uninterruptibleMask }
-- warn: { name: "Use 'MonadThrow' from Universum"
-        , lhs: Control.Exception.Safe.MonadThrow, rhs: Universum.MonadThrow }
-- warn: { name: "Use 'SomeException' from Universum"
-        , lhs: Control.Exception.Safe.SomeException, rhs: Universum.SomeException }
-- warn: { name: "Use 'bracket' from Universum"
-        , lhs: Control.Exception.Safe.bracket, rhs: Universum.bracket }
-- warn: { name: "Use 'bracketOnError' from Universum"
-        , lhs: Control.Exception.Safe.bracketOnError, rhs: Universum.bracketOnError }
-- warn: { name: "Use 'bracket_' from Universum"
-        , lhs: Control.Exception.Safe.bracket_, rhs: Universum.bracket_ }
-- warn: { name: "Use 'catch' from Universum"
-        , lhs: Control.Exception.Safe.catch, rhs: Universum.catch }
-- warn: { name: "Use 'catchAny' from Universum"
-        , lhs: Control.Exception.Safe.catchAny, rhs: Universum.catchAny }
-- warn: { name: "Use 'finally' from Universum"
-        , lhs: Control.Exception.Safe.finally, rhs: Universum.finally }
-- warn: { name: "Use 'handleAny' from Universum"
-        , lhs: Control.Exception.Safe.handleAny, rhs: Universum.handleAny }
-- warn: { name: "Use 'onException' from Universum"
-        , lhs: Control.Exception.Safe.onException, rhs: Universum.onException }
-- warn: { name: "Use 'throwM' from Universum"
-        , lhs: Control.Exception.Safe.throwM, rhs: Universum.throwM }
-- warn: { name: "Use 'try' from Universum"
-        , lhs: Control.Exception.Safe.try, rhs: Universum.try }
-- warn: { name: "Use 'tryAny' from Universum"
-        , lhs: Control.Exception.Safe.tryAny, rhs: Universum.tryAny }
-
-## Function
-- warn: { name: "Use 'fix' from Universum"
-        , lhs: Data.Function.fix, rhs: Universum.fix }
-- warn: { name: "Use 'on' from Universum"
-        , lhs: Data.Function.on, rhs: Universum.on }
-
-## Functor
-- warn: { name: "Use '(&&&)' from Universum"
-        , lhs: Control.Arrow.(&&&), rhs: Universum.(&&&) }
-- warn: { name: "Use 'Bifunctor' from Universum"
-        , lhs: Data.Bifunctor.Bifunctor, rhs: Universum.Bifunctor }
-- warn: { name: "Use 'bimap' from Universum"
-        , lhs: Data.Bifunctor.bimap, rhs: Universum.bimap }
-- warn: { name: "Use 'first' from Universum"
-        , lhs: Data.Bifunctor.first, rhs: Universum.first }
-- warn: { name: "Use 'second' from Universum"
-        , lhs: Data.Bifunctor.second, rhs: Universum.second }
-- warn: { name: "Use 'void' from Universum"
-        , lhs: Data.Functor.void, rhs: Universum.void }
-- warn: { name: "Use '($>)' from Universum"
-        , lhs: Data.Functor.($>), rhs: Universum.($>) }
-- warn: { name: "Use 'Compose' from Universum"
-        , lhs: Data.Functor.Compose.Compose, rhs: Universum.Compose }
-- warn: { name: "Use 'getCompose' from Universum"
-        , lhs: Data.Functor.Compose.getCompose, rhs: Universum.getCompose }
-- warn: { name: "Use 'Identity' from Universum"
-        , lhs: Data.Functor.Identity.Identity, rhs: Universum.Identity }
-- warn: { name: "Use 'runIdentity' from Universum"
-        , lhs: Data.Functor.Identity.runIdentity, rhs: Universum.runIdentity }
-
-## List
-- warn: { name: "Use 'genericDrop' from Universum"
-        , lhs: Data.List.genericDrop, rhs: Universum.genericDrop }
-- warn: { name: "Use 'genericLength' from Universum"
-        , lhs: Data.List.genericLength, rhs: Universum.genericLength }
-- warn: { name: "Use 'genericReplicate' from Universum"
-        , lhs: Data.List.genericReplicate, rhs: Universum.genericReplicate }
-- warn: { name: "Use 'genericSplitAt' from Universum"
-        , lhs: Data.List.genericSplitAt, rhs: Universum.genericSplitAt }
-- warn: { name: "Use 'genericTake' from Universum"
-        , lhs: Data.List.genericTake, rhs: Universum.genericTake }
-- warn: { name: "Use 'group' from Universum"
-        , lhs: Data.List.group, rhs: Universum.group }
-- warn: { name: "Use 'inits' from Universum"
-        , lhs: Data.List.inits, rhs: Universum.inits }
-- warn: { name: "Use 'intercalate' from Universum"
-        , lhs: Data.List.intercalate, rhs: Universum.intercalate }
-- warn: { name: "Use 'intersperse' from Universum"
-        , lhs: Data.List.intersperse, rhs: Universum.intersperse }
-- warn: { name: "Use 'isPrefixOf' from Universum"
-        , lhs: Data.List.isPrefixOf, rhs: Universum.isPrefixOf }
-- warn: { name: "Use 'permutations' from Universum"
-        , lhs: Data.List.permutations, rhs: Universum.permutations }
-- warn: { name: "Use 'sort' from Universum"
-        , lhs: Data.List.sort, rhs: Universum.sort }
-- warn: { name: "Use 'sortBy' from Universum"
-        , lhs: Data.List.sortBy, rhs: Universum.sortBy }
-- warn: { name: "Use 'sortOn' from Universum"
-        , lhs: Data.List.sortOn, rhs: Universum.sortOn }
-- warn: { name: "Use 'subsequences' from Universum"
-        , lhs: Data.List.subsequences, rhs: Universum.subsequences }
-- warn: { name: "Use 'tails' from Universum"
-        , lhs: Data.List.tails, rhs: Universum.tails }
-- warn: { name: "Use 'transpose' from Universum"
-        , lhs: Data.List.transpose, rhs: Universum.transpose }
-- warn: { name: "Use 'unfoldr' from Universum"
-        , lhs: Data.List.unfoldr, rhs: Universum.unfoldr }
-
-- warn: { name: "Use 'NonEmpty' from Universum"
-        , lhs: Data.List.NonEmpty.NonEmpty, rhs: Universum.NonEmpty }
-- warn: { name: "Use '(:|)' from Universum"
-        , lhs: "Data.List.NonEmpty.(:|)", rhs: "Universum.(:|)"}
-- warn: { name: "Use 'nonEmpty' from Universum"
-        , lhs: Data.List.NonEmpty.nonEmpty, rhs: Universum.nonEmpty}
-- warn: { name: "Use 'head' from Universum"
-        , lhs: Data.List.NonEmpty.head, rhs: Universum.head }
-- warn: { name: "Use 'init' from Universum"
-        , lhs: Data.List.NonEmpty.init, rhs: Universum.init }
-- warn: { name: "Use 'last' from Universum"
-        , lhs: Data.List.NonEmpty.last, rhs: Universum.last }
-- warn: { name: "Use 'tail' from Universum"
-        , lhs: Data.List.NonEmpty.tail, rhs: Universum.tail }
-- warn: { name: "Use 'sortWith' from Universum"
-        , lhs: GHC.Exts.sortWith, rhs: Universum.sortWith }
-
-## Monad
-- warn: { name: "Use '(>=>)' from Universum"
-        , lhs: Control.Monad.(>=>), rhs: Universum.(>=>) }
-- warn: { name: "Use '(<=<)' from Universum"
-        , lhs: Control.Monad.(<=<), rhs: Universum.(<=<) }
-- warn: { name: "Use 'forever' from Universum"
-        , lhs: Control.Monad.forever, rhs: Universum.forever }
-- warn: { name: "Use 'join' from Universum"
-        , lhs: Control.Monad.join, rhs: Universum.join }
-- warn: { name: "Use 'mfilter' from Universum"
-        , lhs: Control.Monad.mfilter, rhs: Universum.mfilter }
-- warn: { name: "Use 'filterM' from Universum"
-        , lhs: Control.Monad.filterM, rhs: Universum.filterM }
-- warn: { name: "Use 'mapAndUnzipM' from Universum"
-        , lhs: Control.Monad.mapAndUnzipM, rhs: Universum.mapAndUnzipM }
-- warn: { name: "Use 'zipWithM' from Universum"
-        , lhs: Control.Monad.zipWithM, rhs: Universum.zipWithM }
-- warn: { name: "Use 'zipWithM_' from Universum"
-        , lhs: Control.Monad.zipWithM_, rhs: Universum.zipWithM_ }
-- warn: { name: "Use 'foldM' from Universum"
-        , lhs: Control.Monad.foldM, rhs: Universum.foldM }
-- warn: { name: "Use 'foldM_' from Universum"
-        , lhs: Control.Monad.foldM_, rhs: Universum.foldM_ }
-- warn: { name: "Use 'replicateM' from Universum"
-        , lhs: Control.Monad.replicateM, rhs: Universum.replicateM }
-- warn: { name: "Use 'replicateM_' from Universum"
-        , lhs: Control.Monad.replicateM_, rhs: Universum.replicateM_ }
-- warn: { name: "Use 'liftM2' from Universum"
-        , lhs: Control.Monad.liftM2, rhs: Universum.liftM2 }
-- warn: { name: "Use 'liftM3' from Universum"
-        , lhs: Control.Monad.liftM3, rhs: Universum.liftM3 }
-- warn: { name: "Use 'liftM4' from Universum"
-        , lhs: Control.Monad.liftM4, rhs: Universum.liftM4 }
-- warn: { name: "Use 'liftM5' from Universum"
-        , lhs: Control.Monad.liftM5, rhs: Universum.liftM5 }
-- warn: { name: "Use 'ap' from Universum"
-        , lhs: Control.Monad.ap, rhs: Universum.ap }
-- warn: { name: "Use '(<$!>)' from Universum"
-        , lhs: Control.Monad.(<$!>), rhs: Universum.(<$!>) }
-
-- warn: { name: "Use 'ExceptT' from Universum"
-        , lhs: Control.Monad.Except.ExceptT, rhs: Universum.ExceptT }
-- warn: { name: "Use 'runExceptT' from Universum"
-        , lhs: Control.Monad.Except.runExceptT, rhs: Universum.runExceptT }
-
-- warn: { name: "Use 'MonadReader' from Universum"
-        , lhs: Control.Monad.Reader.MonadReader, rhs: Universum.MonadReader }
-- warn: { name: "Use 'Reader' from Universum"
-        , lhs: Control.Monad.Reader.Reader, rhs: Universum.Reader }
-- warn: { name: "Use 'ReaderT' from Universum"
-        , lhs: Control.Monad.Reader.ReaderT, rhs: Universum.ReaderT }
-- warn: { name: "Use 'runReaderT' from Universum"
-        , lhs: Control.Monad.Reader.runReaderT, rhs: Universum.runReaderT }
-- warn: { name: "Use 'ask' from Universum"
-        , lhs: Control.Monad.Reader.ask, rhs: Universum.ask }
-- warn: { name: "Use 'local' from Universum"
-        , lhs: Control.Monad.Reader.local, rhs: Universum.local }
-- warn: { name: "Use 'reader' from Universum"
-        , lhs: Control.Monad.Reader.reader, rhs: Universum.reader }
-- warn: { name: "Use 'runReader' from Universum"
-        , lhs: Control.Monad.Reader.runReader, rhs: Universum.runReader }
-
-- warn: { name: "Use 'MonadState' from Universum"
-        , lhs: Control.Monad.State.Strict.MonadState, rhs: Universum.MonadState }
-- warn: { name: "Use 'State' from Universum"
-        , lhs: Control.Monad.State.Strict.State, rhs: Universum.State }
-- warn: { name: "Use 'StateT' from Universum"
-        , lhs: Control.Monad.State.Strict.StateT, rhs: Universum.StateT }
-- warn: { name: "Use 'runStateT' from Universum"
-        , lhs: Control.Monad.State.Strict.runStateT, rhs: Universum.runStateT }
-- warn: { name: "Use 'evalState' from Universum"
-        , lhs: Control.Monad.State.Strict.evalState, rhs: Universum.evalState }
-- warn: { name: "Use 'evalStateT' from Universum"
-        , lhs: Control.Monad.State.Strict.evalStateT, rhs: Universum.evalStateT }
-- warn: { name: "Use 'execState' from Universum"
-        , lhs: Control.Monad.State.Strict.execState, rhs: Universum.execState }
-- warn: { name: "Use 'execStateT' from Universum"
-        , lhs: Control.Monad.State.Strict.execStateT, rhs: Universum.execStateT }
-- warn: { name: "Use 'get' from Universum"
-        , lhs: Control.Monad.State.Strict.get, rhs: Universum.get }
-- warn: { name: "Use 'gets' from Universum"
-        , lhs: Control.Monad.State.Strict.gets, rhs: Universum.gets }
-- warn: { name: "Use 'modify' from Universum"
-        , lhs: Control.Monad.State.Strict.modify, rhs: Universum.modify }
-- warn: { name: "Use 'modify'' from Universum"
-        , lhs: "Control.Monad.State.Strict.modify'", rhs: "Universum.modify'" }
-- warn: { name: "Use 'put' from Universum"
-        , lhs: Control.Monad.State.Strict.put, rhs: Universum.put }
-- warn: { name: "Use 'runState' from Universum"
-        , lhs: Control.Monad.State.Strict.runState, rhs: Universum.runState }
-- warn: { name: "Use 'state' from Universum"
-        , lhs: Control.Monad.State.Strict.state, rhs: Universum.state }
-- warn: { name: "Use 'withState' from Universum"
-        , lhs: Control.Monad.State.Strict.withState, rhs: Universum.withState }
-
-- warn: { name: "Use 'MonadFail' from Universum"
-        , lhs: Control.Monad.Fail.MonadFail, rhs: Universum.MonadFail }
-
-
-- warn: { name: "Use 'MonadIO' from Universum"
-        , lhs: Control.Monad.Trans.MonadIO, rhs: Universum.MonadIO }
-- warn: { name: "Use 'MonadTrans' from Universum"
-        , lhs: Control.Monad.Trans.MonadTrans, rhs: Universum.MonadTrans }
-- warn: { name: "Use 'lift' from Universum"
-        , lhs: Control.Monad.Trans.lift, rhs: Universum.lift }
-- warn: { name: "Use 'liftIO' from Universum"
-        , lhs: Control.Monad.Trans.liftIO, rhs: Universum.liftIO }
-
-- warn: { name: "Use 'IdentityT' from Universum"
-        , lhs: Control.Monad.Trans.Identity.IdentityT, rhs: Universum.IdentityT }
-- warn: { name: "Use 'runIdentityT' from Universum"
-        , lhs: Control.Monad.Trans.Identity.runIdentityT, rhs: Universum.runIdentityT }
-
-- warn: { name: "Use 'MaybeT' from Universum"
-        , lhs: Control.Monad.Trans.Maybe.MaybeT, rhs: Universum.MaybeT }
-- warn: { name: "Use 'maybeToExceptT' from Universum"
-        , lhs: Control.Monad.Trans.Maybe.maybeToExceptT, rhs: Universum.maybeToExceptT }
-- warn: { name: "Use 'exceptToMaybeT' from Universum"
-        , lhs: Control.Monad.Trans.Maybe.exceptToMaybeT, rhs: Universum.exceptToMaybeT }
-
-- warn: { name: "Use 'catMaybes' from Universum"
-        , lhs: Data.Maybe.catMaybes, rhs: Universum.catMaybes }
-- warn: { name: "Use 'fromMaybe' from Universum"
-        , lhs: Data.Maybe.fromMaybe, rhs: Universum.fromMaybe }
-- warn: { name: "Use 'isJust' from Universum"
-        , lhs: Data.Maybe.isJust, rhs: Universum.isJust }
-- warn: { name: "Use 'isNothing' from Universum"
-        , lhs: Data.Maybe.isNothing, rhs: Universum.isNothing }
-- warn: { name: "Use 'listToMaybe' from Universum"
-        , lhs: Data.Maybe.listToMaybe, rhs: Universum.listToMaybe }
-- warn: { name: "Use 'mapMaybe' from Universum"
-        , lhs: Data.Maybe.mapMaybe, rhs: Universum.mapMaybe }
-- warn: { name: "Use 'maybeToList' from Universum"
-        , lhs: Data.Maybe.maybeToList, rhs: Universum.maybeToList }
-
-- warn: { name: "Use 'isLeft' from Universum"
-        , lhs: Data.Either.isLeft, rhs: Universum.isLeft }
-- warn: { name: "Use 'isRight' from Universum"
-        , lhs: Data.Either.isRight, rhs: Universum.isRight }
-- warn: { name: "Use 'lefts' from Universum"
-        , lhs: Data.Either.lefts, rhs: Universum.lefts }
-- warn: { name: "Use 'partitionEithers' from Universum"
-        , lhs: Data.Either.partitionEithers, rhs: Universum.partitionEithers }
-- warn: { name: "Use 'rights' from Universum"
-        , lhs: Data.Either.rights, rhs: Universum.rights }
-
-- warn: { name: "Use 'newTVar' from Universum"
-        , lhs: Control.Concurrent.STM.TVar.newTVar, rhs: Universum.newTVar }
-- warn: { name: "Use 'readTVar' from Universum"
-        , lhs: Control.Concurrent.STM.TVar.readTVar, rhs: Universum.readTVar }
-- warn: { name: "Use 'writeTVar' from Universum"
-        , lhs: Control.Concurrent.STM.TVar.writeTVar, rhs: Universum.writeTVar }
-- warn: { name: "Use 'modifyTVar'' from Universum"
-        , lhs: "Control.Concurrent.STM.TVar.modifyTVar'", rhs: "Universum.modifyTVar'" }
-- warn: { name: "Use 'newTVarIO' from Universum"
-        , lhs: Control.Concurrent.STM.TVar.newTVarIO, rhs: Universum.newTVarIO }
-- warn: { name: "Use 'readTVarIO' from Universum"
-        , lhs: Control.Concurrent.STM.TVar.readTVarIO, rhs: Universum.readTVarIO }
-
-- warn: { name: "Use 'newIORef' from Universum"
-        , lhs: Data.IORef.newIORef, rhs: Universum.newIORef }
-- warn: { name: "Use 'readIORef' from Universum"
-        , lhs: Data.IORef.readIORef, rhs: Universum.readIORef }
-- warn: { name: "Use 'writeIORef' from Universum"
-        , lhs: Data.IORef.writeIORef, rhs: Universum.writeIORef }
-- warn: { name: "Use 'modifyIORef' from Universum"
-        , lhs: Data.IORef.modifyIORef, rhs: Universum.modifyIORef }
-- warn: { name: "Use 'modifyIORef'' from Universum"
-        , lhs: "Data.IORef.modifyIORef'", rhs: "Universum.modifyIORef'" }
-- warn: { name: "Use 'atomicModifyIORef' from Universum"
-        , lhs: Data.IORef.atomicModifyIORef, rhs: Universum.atomicModifyIORef }
-- warn: { name: "Use 'atomicModifyIORef'' from Universum"
-        , lhs: "Data.IORef.atomicModifyIORef'", rhs: "Universum.atomicModifyIORef'" }
-- warn: { name: "Use 'atomicWriteIORef' from Universum"
-        , lhs: Data.IORef.atomicWriteIORef, rhs: Universum.atomicWriteIORef }
-
-## Monoid
-- warn: { name: "Use 'All' from Universum"
-        , lhs: Data.Monoid.All, rhs: Universum.All }
-- warn: { name: "Use 'Alt' from Universum"
-        , lhs: Data.Monoid.Alt, rhs: Universum.Alt }
-- warn: { name: "Use 'Any' from Universum"
-        , lhs: Data.Monoid.Any, rhs: Universum.Any }
-- warn: { name: "Use 'Dual' from Universum"
-        , lhs: Data.Monoid.Dual, rhs: Universum.Dual }
-- warn: { name: "Use 'Endo' from Universum"
-        , lhs: Data.Monoid.Endo, rhs: Universum.Endo }
-- warn: { name: "Use 'First' from Universum"
-        , lhs: Data.Monoid.First, rhs: Universum.First }
-- warn: { name: "Use 'Last' from Universum"
-        , lhs: Data.Monoid.Last, rhs: Universum.Last }
-- warn: { name: "Use 'Product' from Universum"
-        , lhs: Data.Monoid.Product, rhs: Universum.Product }
-- warn: { name: "Use 'Sum' from Universum"
-        , lhs: Data.Monoid.Sum, rhs: Universum.Sum }
-
-- warn: { name: "Use 'Option' from Universum"
-        , lhs: Data.Semigroup.Option, rhs: Universum.Option }
-- warn: { name: "Use 'Semigroup' from Universum"
-        , lhs: Data.Semigroup.Semigroup, rhs: Universum.Semigroup }
-- warn: { name: "Use 'sconcat' from Universum"
-        , lhs: Data.Semigroup.sconcat, rhs: Universum.sconcat }
-- warn: { name: "Use 'stimes' from Universum"
-        , lhs: Data.Semigroup.stimes, rhs: Universum.stimes }
-- warn: { name: "Use '(<>)' from Universum"
-        , lhs: Data.Semigroup.(<>), rhs: Universum.(<>) }
-- warn: { name: "Use 'WrappedMonoid' from Universum"
-        , lhs: Data.Semigroup.WrappedMonoid, rhs: Universum.WrappedMonoid }
-- warn: { name: "Use 'cycle1' from Universum"
-        , lhs: Data.Semigroup.cycle1, rhs: Universum.cycle1 }
-- warn: { name: "Use 'mtimesDefault' from Universum"
-        , lhs: Data.Semigroup.mtimesDefault, rhs: Universum.mtimesDefault }
-- warn: { name: "Use 'stimesIdempotent' from Universum"
-        , lhs: Data.Semigroup.stimesIdempotent, rhs: Universum.stimesIdempotent }
-- warn: { name: "Use 'stimesIdempotentMonoid' from Universum"
-        , lhs: Data.Semigroup.stimesIdempotentMonoid, rhs: Universum.stimesIdempotentMonoid }
-- warn: { name: "Use 'stimesMonoid' from Universum"
-        , lhs: Data.Semigroup.stimesMonoid, rhs: Universum.stimesMonoid }
-
-## String
-- warn: { name: "Use 'ByteString' from Universum"
-        , lhs: Data.ByteString.ByteString, rhs: Universum.ByteString }
-- warn: { name: "Use 'IsString' from Universum"
-        , lhs: Data.String.IsString, rhs: Universum.IsString }
-
-- warn: { name: "Use 'Text' from Universum"
-        , lhs: Data.Text.Text, rhs: Universum.Text }
-- warn: { name: "Use 'lines' from Universum"
-        , lhs: Data.Text.lines, rhs: Universum.lines }
-- warn: { name: "Use 'unlines' from Universum"
-        , lhs: Data.Text.unlines, rhs: Universum.unlines }
-- warn: { name: "Use 'words' from Universum"
-        , lhs: Data.Text.words, rhs: Universum.words }
-- warn: { name: "Use 'unwords' from Universum"
-        , lhs: Data.Text.unwords, rhs: Universum.unwords }
-
-- warn: { name: "Use 'LText' from Universum"
-        , lhs: Data.Text.Lazy.Text, rhs: Universum.LText }
-- warn: { name: "Use 'LByteString' from Universum"
-        , lhs: Data.ByteString.Lazy.LByteString, rhs: Universum.LByteString }
-
-- warn: { name: "Use 'Buildable' from Universum"
-        , lhs: Data.Text.Buildable, rhs: Universum.Buildable }
-- warn: { name: "Use 'decodeUtf8'' from Universum"
-        , lhs: "Data.Text.Encoding.decodeUtf8'", rhs: "Universum.decodeUtf8'" }
-- warn: { name: "Use 'decodeUtf8With' from Universum"
-        , lhs: Data.Text.Encoding.decodeUtf8With, rhs: Universum.decodeUtf8With }
-
-- warn: { name: "Use 'OnDecodeError' from Universum"
-        , lhs: Data.Text.Encoding.Error.OnDecodeError, rhs: Universum.OnDecodeError }
-- warn: { name: "Use 'OnDecodeError' from Universum"
-        , lhs: Data.Text.Encoding.Error.OnDecodeError, rhs: Universum.OnDecodeError }
-- warn: { name: "Use 'OnError' from Universum"
-        , lhs: Data.Text.Encoding.Error.OnError, rhs: Universum.OnError }
-- warn: { name: "Use 'UnicodeException' from Universum"
-        , lhs: Data.Text.Encoding.Error.UnicodeException, rhs: Universum.UnicodeException }
-- warn: { name: "Use 'lenientDecode' from Universum"
-        , lhs: Data.Text.Encoding.Error.lenientDecode, rhs: Universum.lenientDecode }
-- warn: { name: "Use 'strictDecode' from Universum"
-        , lhs: Data.Text.Encoding.Error.strictDecode, rhs: Universum.strictDecode }
-
-- warn: { name: "Use 'fromStrict' from Universum"
-        , lhs: Data.Text.Lazy.fromStrict, rhs: Universum.fromStrict }
-- warn: { name: "Use 'toStrict' from Universum"
-        , lhs: Data.Text.Lazy.toStrict, rhs: Universum.toStrict }
-
-- warn: { name: "Use 'readMaybe' from Universum"
-        , lhs: Text.Read.readMaybe, rhs: Universum.readMaybe }
-
-- warn: { name: "Use 'getLine' from Universum"
-        , lhs: Data.Text.IO.getLine, rhs: Universum.getLine }
-- warn: { name: "Use 'readFile' from Universum"
-        , lhs: Data.Text.IO.readFile, rhs: Universum.readFile }
-- warn: { name: "Use 'writeFile' from Universum"
-        , lhs: Data.Text.IO.writeFile, rhs: Universum.writeFile }
-- warn: { name: "Use 'appendFile' from Universum"
-        , lhs: Data.Text.IO.appendFile, rhs: Universum.appendFile }
-
-## Unsafe
-- warn: { name: "Use 'head' from Universum.Unsafe"
-        , lhs: Data.List.head, rhs: Universum.Unsafe.head
-        , note: "Use 'import qualified Universum.Unsafe as Unsafe (head)'" }
-- warn: { name: "Use 'tail' from Universum.Unsafe"
-        , lhs: Data.List.tail, rhs: Universum.Unsafe.tail
-        , note: "Use 'import qualified Universum.Unsafe as Unsafe (tail)'" }
-- warn: { name: "Use 'init' from Universum.Unsafe"
-        , lhs: Data.List.init, rhs: Universum.Unsafe.init
-        , note: "Use 'import qualified Universum.Unsafe as Unsafe (init)'" }
-- warn: { name: "Use 'last' from Universum.Unsafe"
-        , lhs: Data.List.last, rhs: Universum.Unsafe.last
-        , note: "Use 'import qualified Universum.Unsafe as Unsafe (last)'" }
-- warn: { name: "Use '(!!)' from Universum.Unsafe"
-        , lhs: "Data.List.(!!)", rhs: "Universum.Unsafe.(!!)"
-        , note: "Use 'import qualified Universum.Unsafe as Unsafe ((!!))'" }
-- warn: { name: "Use 'fromJust' from Universum.Unsafe"
-        , lhs: "Data.Maybe.fromJust", rhs: "Universum.Unsafe.fromJust"
-        , note: "Use 'import qualified Universum.Unsafe as Unsafe (fromJust)'" }
-
-############################################################################
-## Lifted functions in Universum
-############################################################################
-
-## concurrency
-
-- warn: { name: "liftIO is not needed", lhs: liftIO newEmptyMVar, rhs: Universum.newEmptyMVar
-        , note: "If you import 'newEmptyMVar' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (newMVar x), rhs: Universum.newMVar x
-        , note: "If you import 'newMVar' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (putMVar x y), rhs: Universum.putMVar x y
-        , note: "If you import 'putMVar' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (readMVar x), rhs: Universum.readMVar x
-        , note: "If you import 'readMVar' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (swapMVar x y), rhs: Universum.swapMVar x y
-        , note: "If you import 'swapMVar' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (takeMVar x), rhs: Universum.takeMVar x
-        , note: "If you import 'takeMVar' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (tryPutMVar x y), rhs: Universum.tryPutMVar x y
-        , note: "If you import 'tryPutMVar' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (tryReadMVar x), rhs: Universum.tryReadMVar x
-        , note: "If you import 'tryReadMVar' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (tryTakeMVar x), rhs: Universum.tryTakeMVar x
-        , note: "If you import 'tryTakeMVar' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (atomically x), rhs: Universum.atomically x
-        , note: "If you import 'atomically' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (newTVarIO x), rhs: Universum.newTVarIO x
-        , note: "If you import 'newTVarIO' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (readTVarIO x), rhs: Universum.readTVarIO x
-        , note: "If you import 'readTVarIO' from Universum, it's already lifted" }
-
-## IORef
-
-- warn: { name: "liftIO is not needed", lhs: liftIO (newIORef x), rhs: Universum.newIORef x
-        , note: "If you import 'newIORef' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (readIORef x), rhs: Universum.readIORef x
-        , note: "If you import 'readIORef' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (writeIORef x y), rhs: Universum.writeIORef x y
-        , note: "If you import 'writeIORef' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (modifyIORef x y), rhs: Universum.modifyIORef x y
-        , note: "If you import 'modifyIORef' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: "liftIO (modifyIORef' x y)", rhs: "Universum.modifyIORef' x y"
-        , note: "If you import 'modifyIORef'' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (atomicModifyIORef x y), rhs: Universum.atomicModifyIORef x y
-        , note: "If you import 'atomicModifyIORef' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: "liftIO (atomicModifyIORef' x y)", rhs: "Universum.atomicModifyIORef' x y"
-        , note: "If you import 'atomicModifyIORef'' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (atomicWriteIORef x y), rhs: Universum.atomicWriteIORef x y
-        , note: "If you import 'atomicWriteIORef' from Universum, it's already lifted" }
-
-## others
-
-- warn: { name: "liftIO is not needed", lhs: liftIO Universum.getLine, rhs: Universum.getLine
-        , note: "If you import 'getLine' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (Universum.readFile x), rhs: Universum.readFile x
-        , note: "If you import 'readFile' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (Universum.writeFile x y), rhs: Universum.writeFile x y
-        , note: "If you import 'writeFile' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (Universum.appendFile x y), rhs: Universum.appendFile x y
-        , note: "If you import 'appendFile' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (Universum.openFile x y), rhs: Universum.openFile x y
-        , note: "If you import 'openFile' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (exitWith x), rhs: Universum.exitWith x
-        , note: "If you import 'exitWith' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO exitFailure, rhs: Universum.exitFailure
-        , note: "If you import 'exitFailure' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO exitSuccess, rhs: Universum.exitSuccess
-        , note: "If you import 'exitSuccess' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (die x), rhs: Universum.die x
-        , note: "If you import 'die' from Universum, it's already lifted" }
-- warn: { name: "liftIO is not needed", lhs: liftIO (stToIO x), rhs: Universum.stToIO x
-        , note: "If you import 'stToIO' from Universum, it's already lifted" }
diff --git a/Readme.md b/Readme.md
index 1960b51..0f66439 100644
--- a/Readme.md
+++ b/Readme.md
@@ -20,48 +20,23 @@ repositories in `config.toml`, then visit `localhost:8080/admin/overview`.
 
 ## Installing
 
-### From the CI pipeline
-
-Gitlab [automatically builds a version](https://git.cccv.de/hub/walint/-/jobs)
-of `walint` each time something is pushed to the version of this repository
-kept at the CCCV infra. The resulting binary should work fine on most linux 
-systems, especially if they're vaguely debian-like.
-
-In case you get an incomprehensible or confusing error when executing it, try 
-running `ldd walint` and see if anything is marked as not found, then install 
-it.
-
-### Build using stack
-
-This uses a lockfile to pin versions of dependencies (as well as `ghc`, the 
-haskell compiler). You will need 
-[the haskell stack](https://docs.haskellstack.org/en/stable/README/).
-
-Run
-
-```
-stack build
-```
-
-If you lack `ghc` and don't know how to install it, you can add  `--install-ghc`,
-and `stack` will take care of that for you (note that on NixOS, `stack` may
-use a fitting `ghc` derivation if it finds one, even without `--install-ghc`).
-
-To install into your `$PATH`, use
+### Build using cabal
 
-```
-stack install
-```
+Build using
 
-Alternatively, run `walint` via stack:
+~~~sh
+cabal build [all|walint|server]
+~~~
 
-```
-stack run -- walint [options as normal]
-```
+There are no version bounds in the cabal files, but the `cabal.project` file
+tells cabal to follow a stackage snapshot.
 
-### Build using cabal
+### Build using Nix
 
-You can, but probably should not. Beware of older Aeson versions!
+Since nixpkgs also follows stackage snapshots, building the packages with Nix
+should work without difficulty; just pass a nixpkgs to `default.nix` which does
+not diverge too much from the currently-used stackage snapshot (aim is that
+stable nixpkgs should work).
 
 ## Usage
 ``` sh
diff --git a/cabal.project b/cabal.project
new file mode 100644
index 0000000..c5b41d4
--- /dev/null
+++ b/cabal.project
@@ -0,0 +1,2 @@
+packages: */*.cabal
+import: https://www.stackage.org/lts-20.26/cabal.config
diff --git a/default.nix b/default.nix
index 566e710..95764eb 100644
--- a/default.nix
+++ b/default.nix
@@ -1,53 +1,18 @@
-{ nixpkgs ? import <nixpkgs> {}, compiler ? "default", doBenchmark ? false }:
+{ nixpkgs ? import <nixpkgs> {}, compiler ? "default" }:
 
 let
 
   inherit (nixpkgs) pkgs;
 
-  f = { mkDerivation, aeson, aeson-pretty, async, base, base-compat
-      , base64-bytestring, bytestring, containers, cryptohash-sha1
-      , deepseq, directory, dotgen, either, extra, filepath, fmt
-      , getopt-generics, hpack, http-client, http-types, lib, lucid
-      , microlens-platform, monad-logger, network-uri, process
-      , regex-tdfa, servant, servant-client, servant-lucid
-      , servant-server, servant-websockets, stm, template-haskell, text
-      , text-metrics, time, tomland, transformers, universum, uri-encode
-      , uuid, vector, wai, wai-extra, warp, websockets
-      }:
-      mkDerivation {
-        pname = "walint";
-        version = "0.1";
-        src = ./.;
-        isLibrary = true;
-        isExecutable = true;
-        libraryHaskellDepends = [
-          aeson base bytestring containers deepseq dotgen either extra
-          filepath getopt-generics network-uri regex-tdfa text text-metrics
-          transformers universum uri-encode vector
-        ];
-        libraryToolDepends = [ hpack ];
-        executableHaskellDepends = [
-          aeson aeson-pretty async base base-compat base64-bytestring
-          bytestring containers cryptohash-sha1 directory extra filepath fmt
-          getopt-generics http-client http-types lucid microlens-platform
-          monad-logger process servant servant-client servant-lucid
-          servant-server servant-websockets stm template-haskell text time
-          tomland universum uuid wai wai-extra warp websockets
-        ];
-        doHaddock = false;
-        prePatch = "hpack";
-        homepage = "https://stuebinm.eu/git/walint";
-        license = "unknown";
-        hydraPlatforms = lib.platforms.none;
-      };
-
   haskellPackages = if compiler == "default"
                        then pkgs.haskellPackages
                        else pkgs.haskell.packages.${compiler};
 
-  variant = if doBenchmark then pkgs.haskell.lib.doBenchmark else pkgs.lib.id;
-
-  drv = variant (haskellPackages.callPackage f {});
+  inherit (haskellPackages) callPackage;
 
-in
-  drv
+in rec {
+  tiled = callPackage ./tiled {};
+  walint = callPackage ./walint { inherit tiled; };
+  walint-cli = callPackage ./walint-cli { inherit walint; };
+  server = callPackage ./server { inherit walint; };
+}
diff --git a/flake.lock b/flake.lock
deleted file mode 100644
index 59b96a7..0000000
--- a/flake.lock
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-  "nodes": {
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1665466769,
-        "narHash": "sha256-L+qcHpb4Ac3PipMXJY/Ktbu1+KXy23WCZ8pXWmsf7zY=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "0b20bf89e0035b6d62ad58f9db8fdbc99c2b01e8",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "release-22.05",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "nixpkgs": "nixpkgs"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}
diff --git a/flake.nix b/flake.nix
deleted file mode 100644
index fc2f168..0000000
--- a/flake.nix
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  description = "walint: workadventure map linting";
-
-  inputs.nixpkgs.url = "github:NixOS/nixpkgs/release-22.05";
-
-  outputs = { self, nixpkgs }:
-  {
-    defaultPackage.x86_64-linux = import ./default.nix { 
-      nixpkgs = import nixpkgs { system = "x86_64-linux"; }; 
-    };
-  };
-}
diff --git a/nix/sources.json b/nix/sources.json
deleted file mode 100644
index b0eafbe..0000000
--- a/nix/sources.json
+++ /dev/null
@@ -1,38 +0,0 @@
-{
-    "haskellNix": {
-        "branch": "master",
-        "description": "Alternative Haskell Infrastructure for Nixpkgs",
-        "homepage": "https://input-output-hk.github.io/haskell.nix",
-        "owner": "input-output-hk",
-        "repo": "haskell.nix",
-        "rev": "659b73698e06c02cc0f3029383bd383c8acdbe98",
-        "sha256": "0i91iwa11sq0v82v0zl82npnb4qqfm71y7gn3giyaixslm73kspk",
-        "type": "tarball",
-        "url": "https://github.com/input-output-hk/haskell.nix/archive/659b73698e06c02cc0f3029383bd383c8acdbe98.tar.gz",
-        "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
-    },
-    "niv": {
-        "branch": "master",
-        "description": "Easy dependency management for Nix projects",
-        "homepage": "https://github.com/nmattia/niv",
-        "owner": "nmattia",
-        "repo": "niv",
-        "rev": "65a61b147f307d24bfd0a5cd56ce7d7b7cc61d2e",
-        "sha256": "17mirpsx5wyw262fpsd6n6m47jcgw8k2bwcp1iwdnrlzy4dhcgqh",
-        "type": "tarball",
-        "url": "https://github.com/nmattia/niv/archive/65a61b147f307d24bfd0a5cd56ce7d7b7cc61d2e.tar.gz",
-        "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
-    },
-    "nixpkgs": {
-        "branch": "21.05",
-        "description": "Nix Packages collection",
-        "homepage": "",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "7e9b0dff974c89e070da1ad85713ff3c20b0ca97",
-        "sha256": "1ckzhh24mgz6jd1xhfgx0i9mijk6xjqxwsshnvq789xsavrmsc36",
-        "type": "tarball",
-        "url": "https://github.com/NixOS/nixpkgs/archive/7e9b0dff974c89e070da1ad85713ff3c20b0ca97.tar.gz",
-        "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
-    }
-}
diff --git a/nix/sources.nix b/nix/sources.nix
deleted file mode 100644
index 1938409..0000000
--- a/nix/sources.nix
+++ /dev/null
@@ -1,174 +0,0 @@
-# This file has been generated by Niv.
-
-let
-
-  #
-  # The fetchers. fetch_<type> fetches specs of type <type>.
-  #
-
-  fetch_file = pkgs: name: spec:
-    let
-      name' = sanitizeName name + "-src";
-    in
-      if spec.builtin or true then
-        builtins_fetchurl { inherit (spec) url sha256; name = name'; }
-      else
-        pkgs.fetchurl { inherit (spec) url sha256; name = name'; };
-
-  fetch_tarball = pkgs: name: spec:
-    let
-      name' = sanitizeName name + "-src";
-    in
-      if spec.builtin or true then
-        builtins_fetchTarball { name = name'; inherit (spec) url sha256; }
-      else
-        pkgs.fetchzip { name = name'; inherit (spec) url sha256; };
-
-  fetch_git = name: spec:
-    let
-      ref =
-        if spec ? ref then spec.ref else
-          if spec ? branch then "refs/heads/${spec.branch}" else
-            if spec ? tag then "refs/tags/${spec.tag}" else
-              abort "In git source '${name}': Please specify `ref`, `tag` or `branch`!";
-    in
-      builtins.fetchGit { url = spec.repo; inherit (spec) rev; inherit ref; };
-
-  fetch_local = spec: spec.path;
-
-  fetch_builtin-tarball = name: throw
-    ''[${name}] The niv type "builtin-tarball" is deprecated. You should instead use `builtin = true`.
-        $ niv modify ${name} -a type=tarball -a builtin=true'';
-
-  fetch_builtin-url = name: throw
-    ''[${name}] The niv type "builtin-url" will soon be deprecated. You should instead use `builtin = true`.
-        $ niv modify ${name} -a type=file -a builtin=true'';
-
-  #
-  # Various helpers
-  #
-
-  # https://github.com/NixOS/nixpkgs/pull/83241/files#diff-c6f540a4f3bfa4b0e8b6bafd4cd54e8bR695
-  sanitizeName = name:
-    (
-      concatMapStrings (s: if builtins.isList s then "-" else s)
-        (
-          builtins.split "[^[:alnum:]+._?=-]+"
-            ((x: builtins.elemAt (builtins.match "\\.*(.*)" x) 0) name)
-        )
-    );
-
-  # The set of packages used when specs are fetched using non-builtins.
-  mkPkgs = sources: system:
-    let
-      sourcesNixpkgs =
-        import (builtins_fetchTarball { inherit (sources.nixpkgs) url sha256; }) { inherit system; };
-      hasNixpkgsPath = builtins.any (x: x.prefix == "nixpkgs") builtins.nixPath;
-      hasThisAsNixpkgsPath = <nixpkgs> == ./.;
-    in
-      if builtins.hasAttr "nixpkgs" sources
-      then sourcesNixpkgs
-      else if hasNixpkgsPath && ! hasThisAsNixpkgsPath then
-        import <nixpkgs> {}
-      else
-        abort
-          ''
-            Please specify either <nixpkgs> (through -I or NIX_PATH=nixpkgs=...) or
-            add a package called "nixpkgs" to your sources.json.
-          '';
-
-  # The actual fetching function.
-  fetch = pkgs: name: spec:
-
-    if ! builtins.hasAttr "type" spec then
-      abort "ERROR: niv spec ${name} does not have a 'type' attribute"
-    else if spec.type == "file" then fetch_file pkgs name spec
-    else if spec.type == "tarball" then fetch_tarball pkgs name spec
-    else if spec.type == "git" then fetch_git name spec
-    else if spec.type == "local" then fetch_local spec
-    else if spec.type == "builtin-tarball" then fetch_builtin-tarball name
-    else if spec.type == "builtin-url" then fetch_builtin-url name
-    else
-      abort "ERROR: niv spec ${name} has unknown type ${builtins.toJSON spec.type}";
-
-  # If the environment variable NIV_OVERRIDE_${name} is set, then use
-  # the path directly as opposed to the fetched source.
-  replace = name: drv:
-    let
-      saneName = stringAsChars (c: if isNull (builtins.match "[a-zA-Z0-9]" c) then "_" else c) name;
-      ersatz = builtins.getEnv "NIV_OVERRIDE_${saneName}";
-    in
-      if ersatz == "" then drv else
-        # this turns the string into an actual Nix path (for both absolute and
-        # relative paths)
-        if builtins.substring 0 1 ersatz == "/" then /. + ersatz else /. + builtins.getEnv "PWD" + "/${ersatz}";
-
-  # Ports of functions for older nix versions
-
-  # a Nix version of mapAttrs if the built-in doesn't exist
-  mapAttrs = builtins.mapAttrs or (
-    f: set: with builtins;
-    listToAttrs (map (attr: { name = attr; value = f attr set.${attr}; }) (attrNames set))
-  );
-
-  # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/lists.nix#L295
-  range = first: last: if first > last then [] else builtins.genList (n: first + n) (last - first + 1);
-
-  # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L257
-  stringToCharacters = s: map (p: builtins.substring p 1 s) (range 0 (builtins.stringLength s - 1));
-
-  # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L269
-  stringAsChars = f: s: concatStrings (map f (stringToCharacters s));
-  concatMapStrings = f: list: concatStrings (map f list);
-  concatStrings = builtins.concatStringsSep "";
-
-  # https://github.com/NixOS/nixpkgs/blob/8a9f58a375c401b96da862d969f66429def1d118/lib/attrsets.nix#L331
-  optionalAttrs = cond: as: if cond then as else {};
-
-  # fetchTarball version that is compatible between all the versions of Nix
-  builtins_fetchTarball = { url, name ? null, sha256 }@attrs:
-    let
-      inherit (builtins) lessThan nixVersion fetchTarball;
-    in
-      if lessThan nixVersion "1.12" then
-        fetchTarball ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))
-      else
-        fetchTarball attrs;
-
-  # fetchurl version that is compatible between all the versions of Nix
-  builtins_fetchurl = { url, name ? null, sha256 }@attrs:
-    let
-      inherit (builtins) lessThan nixVersion fetchurl;
-    in
-      if lessThan nixVersion "1.12" then
-        fetchurl ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))
-      else
-        fetchurl attrs;
-
-  # Create the final "sources" from the config
-  mkSources = config:
-    mapAttrs (
-      name: spec:
-        if builtins.hasAttr "outPath" spec
-        then abort
-          "The values in sources.json should not have an 'outPath' attribute"
-        else
-          spec // { outPath = replace name (fetch config.pkgs name spec); }
-    ) config.sources;
-
-  # The "config" used by the fetchers
-  mkConfig =
-    { sourcesFile ? if builtins.pathExists ./sources.json then ./sources.json else null
-    , sources ? if isNull sourcesFile then {} else builtins.fromJSON (builtins.readFile sourcesFile)
-    , system ? builtins.currentSystem
-    , pkgs ? mkPkgs sources system
-    }: rec {
-      # The sources, i.e. the attribute set of spec name to spec
-      inherit sources;
-
-      # The "pkgs" (evaluated nixpkgs) to use for e.g. non-builtin fetchers
-      inherit pkgs;
-    };
-
-in
-mkSources (mkConfig {}) // { __functor = _: settings: mkSources (mkConfig settings); }
diff --git a/package.yaml b/package.yaml
deleted file mode 100644
index ceefc73..0000000
--- a/package.yaml
+++ /dev/null
@@ -1,98 +0,0 @@
-name: walint
-version: 0.1
-homepage: https://stuebinm.eu/git/walint
-# TODO: license
-author: stuebinm
-maintainer: stuebinm@disroot.org
-copyright: 2022 stuebinm
-ghc-options: -Wall -Wno-name-shadowing -Wno-unticked-promoted-constructors
-default-extensions: NoImplicitPrelude
-
-dependencies:
-  - base
-  - universum
-  - aeson
-  - bytestring
-  - text
-
-internal-libraries:
-  tiled:
-    source-dirs: 'tiled'
-    dependencies:
-      - vector
-    exposed-modules:
-      - Data.Tiled
-      - Data.Tiled.Abstract
-      - Data.Tiled.TH
-
-library:
-  source-dirs: 'lib'
-  dependencies:
-    - containers
-    - tiled
-    - text
-    - vector
-    - transformers
-    - either
-    - filepath
-    - getopt-generics
-    - regex-tdfa
-    - extra
-    - deepseq
-    - dotgen
-    - text-metrics
-    - uri-encode
-    - network-uri
-  exposed-modules:
-    - CheckDir
-    - CheckMap
-    - WriteRepo
-    - Util
-    - Types
-    - LintConfig
-
-executables:
-  walint:
-    main: Main.hs
-    source-dirs: 'src'
-    dependencies:
-      - walint
-      - getopt-generics
-      - aeson-pretty
-      - template-haskell
-      - process
-  walint-mapserver:
-    main: Main.hs
-    source-dirs: 'server'
-    ghc-options: -rtsopts -threaded
-    dependencies:
-      - walint
-      - containers
-      - base-compat
-      - time
-      - directory
-      - filepath
-      - warp
-      - wai
-      - wai-extra
-      - monad-logger
-      - lucid
-      - servant
-      - servant-server
-      - servant-client
-      - servant-lucid
-      - servant-websockets
-      - http-types
-      - http-client
-      - websockets
-      - process
-      - extra
-      - microlens-platform
-      - fmt
-      - tomland
-      - stm
-      - getopt-generics
-      - async
-      - cryptohash-sha1
-      - uuid
-      - base64-bytestring
diff --git a/server/Handlers.hs b/server/Handlers.hs
index 8990f01..10a729c 100644
--- a/server/Handlers.hs
+++ b/server/Handlers.hs
@@ -1,7 +1,5 @@
 {-# LANGUAGE BlockArguments    #-}
 {-# LANGUAGE DataKinds         #-}
-{-# LANGUAGE ExplicitForAll    #-}
-{-# LANGUAGE FlexibleContexts  #-}
 {-# LANGUAGE LambdaCase        #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RecordWildCards   #-}
diff --git a/server/HtmlOrphans.hs b/server/HtmlOrphans.hs
index e3887c6..a8a355c 100644
--- a/server/HtmlOrphans.hs
+++ b/server/HtmlOrphans.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE DataKinds         #-}
 {-# LANGUAGE LambdaCase        #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RecordWildCards   #-}
@@ -7,8 +7,6 @@
 -- so it's safe to never define it
 {-# OPTIONS_GHC -Wno-missing-methods #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
-{-# LANGUAGE DataKinds         #-}
-{-# LANGUAGE FlexibleInstances #-}
 
 -- | Module containing orphan instances of Lucid's ToHtml, used for rendering
 -- linter results as html
@@ -236,7 +234,7 @@ instance ToHtml (Org True, RemoteRef, DirResult a) where
     where
       maxlevel = maximumLintLevel res
 
-      placeList :: (Monad m, ToHtml a) => [a] -> HtmlT m ()
+      placeList :: (Monad m, ToHtml h) => [h] -> HtmlT m ()
       placeList occurances =
         sequence_ . intersperse ", " $ occurances <&> \place ->
           code_ [class_ "small text-muted"] (toHtml place)
diff --git a/server/Main.hs b/server/Main.hs
index 0aafd65..6431b3f 100644
--- a/server/Main.hs
+++ b/server/Main.hs
@@ -1,13 +1,7 @@
-{-# LANGUAGE DataKinds           #-}
-{-# LANGUAGE DeriveAnyClass      #-}
-{-# LANGUAGE DeriveGeneric       #-}
-{-# LANGUAGE OverloadedStrings   #-}
-{-# LANGUAGE RankNTypes          #-}
-{-# LANGUAGE RecordWildCards     #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeApplications    #-}
-{-# LANGUAGE TypeFamilies        #-}
-{-# LANGUAGE TypeOperators       #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RecordWildCards   #-}
+{-# LANGUAGE TypeFamilies      #-}
 
 
 -- | simple server offering linting "as a service"
diff --git a/server/Server.hs b/server/Server.hs
index ac03a3b..059078b 100644
--- a/server/Server.hs
+++ b/server/Server.hs
@@ -1,24 +1,13 @@
-{-# LANGUAGE BangPatterns               #-}
-{-# LANGUAGE DataKinds                  #-}
-{-# LANGUAGE DeriveAnyClass             #-}
-{-# LANGUAGE DeriveGeneric              #-}
-{-# LANGUAGE DerivingStrategies         #-}
-{-# LANGUAGE ExistentialQuantification  #-}
-{-# LANGUAGE ExplicitForAll             #-}
-{-# LANGUAGE FlexibleContexts           #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE LambdaCase                 #-}
-{-# LANGUAGE OverloadedStrings          #-}
-{-# LANGUAGE RecordWildCards            #-}
-{-# LANGUAGE ScopedTypeVariables        #-}
-{-# LANGUAGE StandaloneDeriving         #-}
-{-# LANGUAGE TemplateHaskell            #-}
-{-# LANGUAGE TupleSections              #-}
-{-# LANGUAGE TypeApplications           #-}
-{-# LANGUAGE TypeFamilies               #-}
-{-# LANGUAGE TypeOperators              #-}
-{-# LANGUAGE UndecidableInstances       #-}
+{-# LANGUAGE DataKinds            #-}
+{-# LANGUAGE DeriveAnyClass       #-}
+{-# LANGUAGE DerivingStrategies   #-}
+{-# LANGUAGE LambdaCase           #-}
+{-# LANGUAGE OverloadedStrings    #-}
+{-# LANGUAGE RecordWildCards      #-}
+{-# LANGUAGE TemplateHaskell      #-}
+{-# LANGUAGE TupleSections        #-}
+{-# LANGUAGE TypeFamilies         #-}
+{-# LANGUAGE UndecidableInstances #-}
 
 module Server ( loadConfig
               , Org(..)
diff --git a/server/Worker.hs b/server/Worker.hs
index ba0fb41..2aa74e0 100644
--- a/server/Worker.hs
+++ b/server/Worker.hs
@@ -1,10 +1,8 @@
-{-# LANGUAGE DataKinds           #-}
-{-# LANGUAGE FlexibleContexts    #-}
-{-# LANGUAGE LambdaCase          #-}
-{-# LANGUAGE OverloadedStrings   #-}
-{-# LANGUAGE RecordWildCards     #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TemplateHaskell     #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE LambdaCase        #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RecordWildCards   #-}
+{-# LANGUAGE TemplateHaskell   #-}
 {-# OPTIONS_GHC -Wno-deferred-out-of-scope-variables #-}
 
 module Worker (linterThread, Job(..)) where
diff --git a/server/default.nix b/server/default.nix
new file mode 100644
index 0000000..5826f0c
--- /dev/null
+++ b/server/default.nix
@@ -0,0 +1,26 @@
+{ mkDerivation, aeson, async, base, base-compat, base64-bytestring
+, bytestring, containers, cryptohash-sha1, directory, extra
+, filepath, fmt, getopt-generics, http-client, http-types, lib
+, lucid, microlens-platform, monad-logger, process, servant
+, servant-client, servant-lucid, servant-server, servant-websockets
+, stm, text, time, tomland, universum, uuid, wai, wai-extra, walint
+, warp, websockets
+}:
+mkDerivation {
+  pname = "walint-server";
+  version = "0.1";
+  src = ./.;
+  isLibrary = false;
+  isExecutable = true;
+  executableHaskellDepends = [
+    aeson async base base-compat base64-bytestring bytestring
+    containers cryptohash-sha1 directory extra filepath fmt
+    getopt-generics http-client http-types lucid microlens-platform
+    monad-logger process servant servant-client servant-lucid
+    servant-server servant-websockets stm text time tomland universum
+    uuid wai wai-extra walint warp websockets
+  ];
+  homepage = "https://stuebinm.eu/git/walint";
+  license = "unknown";
+  mainProgram = "walint-server";
+}
diff --git a/server/server.cabal b/server/server.cabal
new file mode 100644
index 0000000..5b563a6
--- /dev/null
+++ b/server/server.cabal
@@ -0,0 +1,55 @@
+cabal-version:  3.0
+name:           walint-server
+version:        0.1
+author:         stuebinm
+maintainer:     stuebinm@disroot.org
+copyright:      2023 stuebinm
+homepage:       https://stuebinm.eu/git/walint
+
+executable walint-server
+  main-is: Main.hs
+  other-modules:
+      Handlers
+      HtmlOrphans
+      Server
+      Worker
+  default-extensions:
+      NoImplicitPrelude
+  ghc-options: -Wall -Wno-name-shadowing -Wno-unticked-promoted-constructors -rtsopts -threaded
+  build-depends:
+      aeson
+    , async
+    , base
+    , base-compat
+    , base64-bytestring
+    , bytestring
+    , containers
+    , cryptohash-sha1
+    , directory
+    , extra
+    , filepath
+    , fmt
+    , getopt-generics
+    , http-client
+    , http-types
+    , lucid
+    , microlens-platform
+    , monad-logger
+    , process
+    , servant
+    , servant-client
+    , servant-lucid
+    , servant-server
+    , servant-websockets
+    , stm
+    , text
+    , time
+    , tomland
+    , universum
+    , uuid
+    , wai
+    , wai-extra
+    , walint
+    , warp
+    , websockets
+  default-language: GHC2021
diff --git a/stack.yaml b/stack.yaml
deleted file mode 100644
index 56d9597..0000000
--- a/stack.yaml
+++ /dev/null
@@ -1,36 +0,0 @@
-resolver: lts-19.28
-
-# User packages to be built.
-# Various formats can be used as shown in the example below.
-#
-# packages:
-# - some-directory
-# - https://example.com/foo/bar/baz-0.0.2.tar.gz
-#   subdirs:
-#   - auto-update
-#   - wai
-packages:
-- .
-# Dependency packages to be pulled from upstream that are not in the resolver.
-# These entries can reference officially published versions as well as
-# forks / in-progress versions pinned to a git hash. For example:
-#
-allow-newer: true
-extra-deps:
-- mustache-2.4.0@sha256:bd1cfbd027c04d8329877e95413d34dc357d4bee041dd8978cd6a23b114fbda1,3180
-- tomland-1.3.3.1@sha256:83a8fd26a97164100541f7b26aa40ffdc6f230b21e94cbb3eae1fb7093c4356e,8924
-- validation-selective-0.1.0.1@sha256:9a5aa8b801efc6a4ffb120e1b28e80c5f7d090043be56bba11222cd20c393044,3621
-
-# use aeson with a non-hash-floodable implementation
-flags:
- aeson:
-   ordered-keymap: true
-
-nix:
-  enable: true
-  packages:
-    - zlib.dev
-    - zlib
-    - openssl
-    - git
-    - cacert
diff --git a/stack.yaml.lock b/stack.yaml.lock
deleted file mode 100644
index fb1ccd1..0000000
--- a/stack.yaml.lock
+++ /dev/null
@@ -1,33 +0,0 @@
-# This file was autogenerated by Stack.
-# You should not edit this file by hand.
-# For more information, please see the documentation at:
-#   https://docs.haskellstack.org/en/stable/lock_files
-
-packages:
-- completed:
-    pantry-tree:
-      sha256: 44c4d43ecfe1fee11fb03ffd49b0580ed00eec5144067092801ef4256df77ef8
-      size: 1182
-    hackage: mustache-2.4.0@sha256:bd1cfbd027c04d8329877e95413d34dc357d4bee041dd8978cd6a23b114fbda1,3180
-  original:
-    hackage: mustache-2.4.0@sha256:bd1cfbd027c04d8329877e95413d34dc357d4bee041dd8978cd6a23b114fbda1,3180
-- completed:
-    pantry-tree:
-      sha256: 0e3bdbd32955944c3ee9ff0f47dc765d25ab6be4a336c6d735eed8eb9bc8ce27
-      size: 6430
-    hackage: tomland-1.3.3.1@sha256:83a8fd26a97164100541f7b26aa40ffdc6f230b21e94cbb3eae1fb7093c4356e,8924
-  original:
-    hackage: tomland-1.3.3.1@sha256:83a8fd26a97164100541f7b26aa40ffdc6f230b21e94cbb3eae1fb7093c4356e,8924
-- completed:
-    pantry-tree:
-      sha256: bf72fe4304690da4b5bc6e5218b0f90b5613e7d658f3ce31731816a423fcbca6
-      size: 696
-    hackage: validation-selective-0.1.0.1@sha256:9a5aa8b801efc6a4ffb120e1b28e80c5f7d090043be56bba11222cd20c393044,3621
-  original:
-    hackage: validation-selective-0.1.0.1@sha256:9a5aa8b801efc6a4ffb120e1b28e80c5f7d090043be56bba11222cd20c393044,3621
-snapshots:
-- completed:
-    sha256: 7f4393ad659c579944d12202cffb12d8e4b8114566b015f77bbc303a24cff934
-    size: 619405
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/19/28.yaml
-  original: lts-19.28
diff --git a/static/Genos-VariableFont_wght.ttf b/static/Genos-VariableFont_wght.ttf
deleted file mode 100644
index 0b96efd..0000000
--- a/static/Genos-VariableFont_wght.ttf
+++ /dev/null
diff --git a/static/Ubuntu-R.ttf b/static/Ubuntu-R.ttf
deleted file mode 100644
index d748728..0000000
--- a/static/Ubuntu-R.ttf
+++ /dev/null
diff --git a/static/style.css b/static/style.css
index b2e6db2..4d1a30e 100644
--- a/static/style.css
+++ b/static/style.css
@@ -1,23 +1,10 @@
 
-
-@font-face {
-    font-family: Ubuntu;
-    src: url(/Ubuntu-R.ttf);
-}
-
-@font-face {
-    font-family: Genos-divoc;
-    src: url(/Genos-VariableFont_wght.ttf);
-}
-
 body {
-    background-color: #57c0a2;
-    font-family: Ubuntu, sans-serif;
+    background-color: lightgray;
 }
 
 .btn {
     margin-left: 1em;
-    font-family: Ubuntu;
 }
 
 .main-content {
@@ -26,8 +13,8 @@ body {
     margin: auto;
     margin-top: 10em;
     margin-bottom: 5em;
-    max-width: 50em;
-    background-color: #ffebd8;
+    max-width: 80em;
+    background-color: white;
 }
 
 a {
@@ -72,10 +59,10 @@ ellipse {
         fill: black;
     }
     ellipse, polygon, path {
-        stroke: #a74db7;
+        stroke: lightgray;
     }
     polygon {
-        fill: #a74db7;
+        fill: lightgray;
     }
     #exitGraph {
         background-color: black;
@@ -95,28 +82,7 @@ h2 {
 h3 {
     font-size: 2rem;
 }
-h4{
-    color: #9945c5;
-}
-
-.badge-info {
-    background-color: #62c1a6;
-    color: black;
-}
 
-.badge-warning {
-    background-color: #fdbe4b;
-    color: black;
-}
-
-.badge-danger {
-    background-color: #ea4a72;
-    color: black;
-}
-
-.text-muted {
-    color: #9945c5 !important;
-}
 
 @media (prefers-color-scheme: dark) {
     body {
@@ -128,9 +94,9 @@ h4{
     }
 
     .text-muted {
-        color: #fdbe4b !important;
+        color: lightgray !important;
     }
-    h4 {
-        color: #ffebd8;
+    code {
+        color: lightgray !important;
     }
 }
diff --git a/tiled/Data/Tiled.hs b/tiled/Data/Tiled.hs
index 9256375..99c5c9d 100644
--- a/tiled/Data/Tiled.hs
+++ b/tiled/Data/Tiled.hs
@@ -1,13 +1,9 @@
-{-# LANGUAGE BangPatterns               #-}
 {-# LANGUAGE DeriveAnyClass             #-}
-{-# LANGUAGE DeriveGeneric              #-}
 {-# LANGUAGE DerivingStrategies         #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE LambdaCase                 #-}
-{-# LANGUAGE NamedFieldPuns             #-}
 {-# LANGUAGE OverloadedStrings          #-}
 {-# LANGUAGE RecordWildCards            #-}
-{-# LANGUAGE ScopedTypeVariables        #-}
 {-# LANGUAGE TemplateHaskell            #-}
 
 
diff --git a/tiled/default.nix b/tiled/default.nix
new file mode 100644
index 0000000..c112497
--- /dev/null
+++ b/tiled/default.nix
@@ -0,0 +1,13 @@
+{ mkDerivation, aeson, base, bytestring, lib, text, universum
+, vector
+}:
+mkDerivation {
+  pname = "tiled";
+  version = "0.1";
+  src = ./.;
+  libraryHaskellDepends = [
+    aeson base bytestring text universum vector
+  ];
+  homepage = "https://stuebinm.eu/git/walint";
+  license = "unknown";
+}
diff --git a/tiled/tiled.cabal b/tiled/tiled.cabal
new file mode 100644
index 0000000..2864748
--- /dev/null
+++ b/tiled/tiled.cabal
@@ -0,0 +1,24 @@
+cabal-version:  3.0
+name:           tiled
+version:        0.1
+author:         stuebinm
+maintainer:     stuebinm@disroot.org
+copyright:      2022 stuebinm
+homepage:       https://stuebinm.eu/git/walint
+
+library
+  exposed-modules:
+      Data.Tiled
+      Data.Tiled.Abstract
+      Data.Tiled.TH
+  default-extensions:
+      NoImplicitPrelude
+  ghc-options: -Wall -Wno-name-shadowing -Wno-unticked-promoted-constructors
+  build-depends:
+      aeson
+    , base
+    , bytestring
+    , text
+    , universum
+    , vector
+  default-language: GHC2021
diff --git a/src/Main.hs b/walint-cli/Main.hs
index 9628e1e..4bbc670 100644
--- a/src/Main.hs
+++ b/walint-cli/Main.hs
@@ -1,11 +1,8 @@
-{-# LANGUAGE DataKinds           #-}
-{-# LANGUAGE DeriveAnyClass      #-}
-{-# LANGUAGE DeriveGeneric       #-}
-{-# LANGUAGE LambdaCase          #-}
-{-# LANGUAGE NamedFieldPuns      #-}
-{-# LANGUAGE OverloadedStrings   #-}
-{-# LANGUAGE RecordWildCards     #-}
-{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE DeriveAnyClass    #-}
+{-# LANGUAGE LambdaCase        #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RecordWildCards   #-}
 
 module Main where
 
diff --git a/src/Version.hs b/walint-cli/Version.hs
index 1748512..1748512 100644
--- a/src/Version.hs
+++ b/walint-cli/Version.hs
diff --git a/walint-cli/default.nix b/walint-cli/default.nix
new file mode 100644
index 0000000..938bc4f
--- /dev/null
+++ b/walint-cli/default.nix
@@ -0,0 +1,18 @@
+{ mkDerivation, aeson, aeson-pretty, base, bytestring
+, getopt-generics, lib, process, template-haskell, text, universum
+, walint
+}:
+mkDerivation {
+  pname = "walint-cli";
+  version = "0.1";
+  src = ./.;
+  isLibrary = false;
+  isExecutable = true;
+  executableHaskellDepends = [
+    aeson aeson-pretty base bytestring getopt-generics process
+    template-haskell text universum walint
+  ];
+  homepage = "https://stuebinm.eu/git/walint";
+  license = "unknown";
+  mainProgram = "walint";
+}
diff --git a/walint-cli/walint-cli.cabal b/walint-cli/walint-cli.cabal
new file mode 100644
index 0000000..6ca10bd
--- /dev/null
+++ b/walint-cli/walint-cli.cabal
@@ -0,0 +1,27 @@
+cabal-version:  3.0
+name:           walint-cli
+version:        0.1
+author:         stuebinm
+maintainer:     stuebinm@disroot.org
+copyright:      2023 stuebinm
+homepage:       https://stuebinm.eu/git/walint
+
+executable walint
+  main-is: Main.hs
+  other-modules:
+      Version
+  default-extensions:
+      NoImplicitPrelude
+  ghc-options: -Wall -Wno-name-shadowing -Wno-unticked-promoted-constructors
+  build-depends:
+      aeson
+    , aeson-pretty
+    , base
+    , bytestring
+    , getopt-generics
+    , process
+    , template-haskell
+    , text
+    , universum
+    , walint
+  default-language: GHC2021
diff --git a/walint.cabal b/walint.cabal
deleted file mode 100644
index 9cfb5ee..0000000
--- a/walint.cabal
+++ /dev/null
@@ -1,160 +0,0 @@
-cabal-version: 2.0
-
--- This file has been generated from package.yaml by hpack version 0.34.7.
---
--- see: https://github.com/sol/hpack
-
-name:           walint
-version:        0.1
-homepage:       https://stuebinm.eu/git/walint
-author:         stuebinm
-maintainer:     stuebinm@disroot.org
-copyright:      2022 stuebinm
-build-type:     Simple
-
-library
-  exposed-modules:
-      CheckDir
-      CheckMap
-      WriteRepo
-      Util
-      Types
-      LintConfig
-  other-modules:
-      Badges
-      Dirgraph
-      LayerData
-      LintWriter
-      Paths
-      Properties
-      Uris
-      Paths_walint
-  autogen-modules:
-      Paths_walint
-  hs-source-dirs:
-      lib
-  default-extensions:
-      NoImplicitPrelude
-  ghc-options: -Wall -Wno-name-shadowing -Wno-unticked-promoted-constructors
-  build-depends:
-      aeson
-    , base
-    , bytestring
-    , containers
-    , deepseq
-    , dotgen
-    , either
-    , extra
-    , filepath
-    , getopt-generics
-    , network-uri
-    , regex-tdfa
-    , text
-    , text-metrics
-    , tiled
-    , transformers
-    , universum
-    , uri-encode
-    , vector
-  default-language: Haskell2010
-
-library tiled
-  exposed-modules:
-      Data.Tiled
-      Data.Tiled.Abstract
-      Data.Tiled.TH
-  other-modules:
-      Paths_walint
-  autogen-modules:
-      Paths_walint
-  hs-source-dirs:
-      tiled
-  default-extensions:
-      NoImplicitPrelude
-  ghc-options: -Wall -Wno-name-shadowing -Wno-unticked-promoted-constructors
-  build-depends:
-      aeson
-    , base
-    , bytestring
-    , text
-    , universum
-    , vector
-  default-language: Haskell2010
-
-executable walint
-  main-is: Main.hs
-  other-modules:
-      Version
-      Paths_walint
-  autogen-modules:
-      Paths_walint
-  hs-source-dirs:
-      src
-  default-extensions:
-      NoImplicitPrelude
-  ghc-options: -Wall -Wno-name-shadowing -Wno-unticked-promoted-constructors
-  build-depends:
-      aeson
-    , aeson-pretty
-    , base
-    , bytestring
-    , getopt-generics
-    , process
-    , template-haskell
-    , text
-    , universum
-    , walint
-  default-language: Haskell2010
-
-executable walint-mapserver
-  main-is: Main.hs
-  other-modules:
-      Handlers
-      HtmlOrphans
-      Server
-      Worker
-      Paths_walint
-  autogen-modules:
-      Paths_walint
-  hs-source-dirs:
-      server
-  default-extensions:
-      NoImplicitPrelude
-  ghc-options: -Wall -Wno-name-shadowing -Wno-unticked-promoted-constructors -rtsopts -threaded
-  build-depends:
-      aeson
-    , async
-    , base
-    , base-compat
-    , base64-bytestring
-    , bytestring
-    , containers
-    , cryptohash-sha1
-    , directory
-    , extra
-    , filepath
-    , fmt
-    , getopt-generics
-    , http-client
-    , http-types
-    , lucid
-    , microlens-platform
-    , monad-logger
-    , process
-    , servant
-    , servant-client
-    , servant-lucid
-    , servant-server
-    , servant-websockets
-    , stm
-    , text
-    , time
-    , tomland
-    , universum
-    , uuid
-    , wai
-    , wai-extra
-    , walint
-    , warp
-    , websockets
-  default-language: Haskell2010
diff --git a/lib/Badges.hs b/walint/Badges.hs
index d6afc43..9af34b3 100644
--- a/lib/Badges.hs
+++ b/walint/Badges.hs
@@ -1,9 +1,7 @@
-{-# LANGUAGE DeriveAnyClass             #-}
-{-# LANGUAGE DeriveGeneric              #-}
-{-# LANGUAGE DerivingStrategies         #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE OverloadedStrings          #-}
-{-# LANGUAGE RecordWildCards            #-}
+{-# LANGUAGE DeriveAnyClass     #-}
+{-# LANGUAGE DerivingStrategies #-}
+{-# LANGUAGE OverloadedStrings  #-}
+{-# LANGUAGE RecordWildCards    #-}
 
 -- | module defining Badge types and utility functions
 module Badges where
diff --git a/lib/CheckDir.hs b/walint/CheckDir.hs
index 104fdae..c82c54b 100644
--- a/lib/CheckDir.hs
+++ b/walint/CheckDir.hs
@@ -1,12 +1,7 @@
-{-# LANGUAGE BangPatterns         #-}
 {-# LANGUAGE DataKinds            #-}
 {-# LANGUAGE DeriveAnyClass       #-}
-{-# LANGUAGE DeriveGeneric        #-}
-{-# LANGUAGE FlexibleContexts     #-}
-{-# LANGUAGE FlexibleInstances    #-}
 {-# LANGUAGE LambdaCase           #-}
 {-# LANGUAGE OverloadedStrings    #-}
-{-# LANGUAGE TupleSections        #-}
 {-# LANGUAGE TypeFamilies         #-}
 {-# LANGUAGE UndecidableInstances #-}
 
diff --git a/lib/CheckMap.hs b/walint/CheckMap.hs
index a2a0f9f..ef80a7f 100644
--- a/lib/CheckMap.hs
+++ b/walint/CheckMap.hs
@@ -1,14 +1,7 @@
-{-# LANGUAGE BangPatterns         #-}
 {-# LANGUAGE DataKinds            #-}
-{-# LANGUAGE DeriveGeneric        #-}
-{-# LANGUAGE FlexibleContexts     #-}
-{-# LANGUAGE FlexibleInstances    #-}
-{-# LANGUAGE KindSignatures       #-}
 {-# LANGUAGE LambdaCase           #-}
-{-# LANGUAGE NamedFieldPuns       #-}
 {-# LANGUAGE OverloadedStrings    #-}
 {-# LANGUAGE RecordWildCards      #-}
-{-# LANGUAGE ScopedTypeVariables  #-}
 {-# LANGUAGE TypeFamilies         #-}
 {-# LANGUAGE UndecidableInstances #-}
 
diff --git a/lib/Dirgraph.hs b/walint/Dirgraph.hs
index cc140a3..831933a 100644
--- a/lib/Dirgraph.hs
+++ b/walint/Dirgraph.hs
@@ -1,6 +1,5 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE LambdaCase       #-}
-{-# LANGUAGE TupleSections    #-}
+{-# LANGUAGE LambdaCase    #-}
+{-# LANGUAGE TupleSections #-}
 
 -- | Simple directed graphs, for dependency checking
 module Dirgraph where
diff --git a/lib/LayerData.hs b/walint/LayerData.hs
index 82efbfc..82efbfc 100644
--- a/lib/LayerData.hs
+++ b/walint/LayerData.hs
diff --git a/lib/LintConfig.hs b/walint/LintConfig.hs
index b0fa3b0..8db46dd 100644
--- a/lib/LintConfig.hs
+++ b/walint/LintConfig.hs
@@ -1,16 +1,10 @@
-{-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE DeriveAnyClass        #-}
-{-# LANGUAGE DeriveGeneric         #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE LambdaCase            #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE OverloadedStrings     #-}
-{-# LANGUAGE RecordWildCards       #-}
-{-# LANGUAGE StandaloneDeriving    #-}
-{-# LANGUAGE TypeFamilies          #-}
-{-# LANGUAGE TypeOperators         #-}
-{-# LANGUAGE UndecidableInstances  #-}
+{-# LANGUAGE DataKinds            #-}
+{-# LANGUAGE DeriveAnyClass       #-}
+{-# LANGUAGE LambdaCase           #-}
+{-# LANGUAGE OverloadedStrings    #-}
+{-# LANGUAGE RecordWildCards      #-}
+{-# LANGUAGE TypeFamilies         #-}
+{-# LANGUAGE UndecidableInstances #-}
 
 -- | Module that deals with handling config options
 module LintConfig (LintConfig(..), LintConfig', ConfigKind (..), patchConfig,stuffConfig,feedConfig) where
diff --git a/lib/LintWriter.hs b/walint/LintWriter.hs
index afcec65..40d54bb 100644
--- a/lib/LintWriter.hs
+++ b/walint/LintWriter.hs
@@ -1,12 +1,6 @@
 {-# LANGUAGE DeriveAnyClass    #-}
-{-# LANGUAGE DeriveFunctor     #-}
-{-# LANGUAGE DeriveGeneric     #-}
-{-# LANGUAGE FlexibleContexts  #-}
-{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE LambdaCase        #-}
-{-# LANGUAGE NamedFieldPuns    #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE RankNTypes        #-}
 {-# LANGUAGE TupleSections     #-}
 {-# OPTIONS_GHC -Wno-missing-signatures #-}
 
diff --git a/lib/Paths.hs b/walint/Paths.hs
index f4dc3ed..f4dc3ed 100644
--- a/lib/Paths.hs
+++ b/walint/Paths.hs
diff --git a/lib/Properties.hs b/walint/Properties.hs
index e72bfd0..7b5a181 100644
--- a/lib/Properties.hs
+++ b/walint/Properties.hs
@@ -1,14 +1,9 @@
-{-# LANGUAGE DataKinds           #-}
-{-# LANGUAGE FlexibleContexts    #-}
-{-# LANGUAGE LambdaCase          #-}
-{-# LANGUAGE MultiWayIf          #-}
-{-# LANGUAGE NamedFieldPuns      #-}
-{-# LANGUAGE OverloadedStrings   #-}
-{-# LANGUAGE RecordWildCards     #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TupleSections       #-}
-{-# LANGUAGE TypeApplications    #-}
-{-# LANGUAGE TypeFamilies        #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE LambdaCase        #-}
+{-# LANGUAGE MultiWayIf        #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RecordWildCards   #-}
+{-# LANGUAGE TypeFamilies      #-}
 
 -- | Contains checks for custom ties of the map json
 module Properties (checkMap, checkTileset, checkLayer) where
diff --git a/lib/Types.hs b/walint/Types.hs
index acba99d..746fc00 100644
--- a/lib/Types.hs
+++ b/walint/Types.hs
@@ -1,7 +1,5 @@
 {-# LANGUAGE DeriveAnyClass    #-}
-{-# LANGUAGE DeriveGeneric     #-}
 {-# LANGUAGE LambdaCase        #-}
-{-# LANGUAGE NamedFieldPuns    #-}
 {-# LANGUAGE OverloadedStrings #-}
 
 
diff --git a/lib/Uris.hs b/walint/Uris.hs
index 127b7f1..cb15b47 100644
--- a/lib/Uris.hs
+++ b/walint/Uris.hs
@@ -1,10 +1,7 @@
 {-# LANGUAGE DataKinds         #-}
 {-# LANGUAGE DeriveAnyClass    #-}
-{-# LANGUAGE DeriveGeneric     #-}
-{-# LANGUAGE LambdaCase        #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RecordWildCards   #-}
-{-# LANGUAGE TypeApplications  #-}
 
 -- | Functions to deal with uris and custom uri schemes
 module Uris where
diff --git a/lib/Util.hs b/walint/Util.hs
index ef35139..ef35139 100644
--- a/lib/Util.hs
+++ b/walint/Util.hs
diff --git a/lib/WriteRepo.hs b/walint/WriteRepo.hs
index af4d4d7..325b301 100644
--- a/lib/WriteRepo.hs
+++ b/walint/WriteRepo.hs
@@ -1,6 +1,5 @@
-{-# LANGUAGE DataKinds           #-}
-{-# LANGUAGE LambdaCase          #-}
-{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE DataKinds  #-}
+{-# LANGUAGE LambdaCase #-}
 
 
 -- | Module for writing an already linted map Repository back out again.
diff --git a/walint/default.nix b/walint/default.nix
new file mode 100644
index 0000000..d36072b
--- /dev/null
+++ b/walint/default.nix
@@ -0,0 +1,17 @@
+{ mkDerivation, aeson, base, bytestring, containers, deepseq
+, dotgen, either, extra, filepath, getopt-generics, lib
+, network-uri, regex-tdfa, text, text-metrics, tiled, transformers
+, universum, uri-encode, vector
+}:
+mkDerivation {
+  pname = "walint";
+  version = "0.1";
+  src = ./.;
+  libraryHaskellDepends = [
+    aeson base bytestring containers deepseq dotgen either extra
+    filepath getopt-generics network-uri regex-tdfa text text-metrics
+    tiled transformers universum uri-encode vector
+  ];
+  homepage = "https://stuebinm.eu/git/walint";
+  license = "unknown";
+}
diff --git a/walint/walint.cabal b/walint/walint.cabal
new file mode 100644
index 0000000..3672d55
--- /dev/null
+++ b/walint/walint.cabal
@@ -0,0 +1,48 @@
+cabal-version:  3.0
+name:           walint
+version:        0.1
+author:         stuebinm
+maintainer:     stuebinm@disroot.org
+copyright:      2023 stuebinm
+homepage:       https://stuebinm.eu/git/walint
+
+library
+  exposed-modules:
+      CheckDir
+      CheckMap
+      WriteRepo
+      Util
+      Types
+      LintConfig
+  other-modules:
+      Badges
+      Dirgraph
+      LayerData
+      LintWriter
+      Paths
+      Properties
+      Uris
+  default-extensions:
+      NoImplicitPrelude
+  ghc-options: -Wall -Wno-name-shadowing -Wno-unticked-promoted-constructors
+  build-depends:
+      aeson
+    , base
+    , bytestring
+    , containers
+    , deepseq
+    , dotgen
+    , either
+    , extra
+    , filepath
+    , getopt-generics
+    , network-uri
+    , regex-tdfa
+    , text
+    , text-metrics
+    , tiled
+    , transformers
+    , universum
+    , uri-encode
+    , vector
+  default-language: GHC2021