diff options
| -rw-r--r-- | .gitignore | 2 | ||||
| -rw-r--r-- | .hlint.yaml | 1039 | ||||
| -rw-r--r-- | Readme.md | 49 | ||||
| -rw-r--r-- | cabal.project | 2 | ||||
| -rw-r--r-- | default.nix | 51 | ||||
| -rw-r--r-- | flake.lock | 27 | ||||
| -rw-r--r-- | flake.nix | 12 | ||||
| -rw-r--r-- | nix/sources.json | 38 | ||||
| -rw-r--r-- | nix/sources.nix | 174 | ||||
| -rw-r--r-- | package.yaml | 98 | ||||
| -rw-r--r-- | server/Handlers.hs | 2 | ||||
| -rw-r--r-- | server/HtmlOrphans.hs | 6 | ||||
| -rw-r--r-- | server/Main.hs | 14 | ||||
| -rw-r--r-- | server/Server.hs | 31 | ||||
| -rw-r--r-- | server/Worker.hs | 12 | ||||
| -rw-r--r-- | server/default.nix | 26 | ||||
| -rw-r--r-- | server/server.cabal | 55 | ||||
| -rw-r--r-- | stack.yaml | 36 | ||||
| -rw-r--r-- | stack.yaml.lock | 33 | ||||
| -rw-r--r-- | static/Genos-VariableFont_wght.ttf | bin | 133948 -> 0 bytes | |||
| -rw-r--r-- | static/Ubuntu-R.ttf | bin | 353824 -> 0 bytes | |||
| -rw-r--r-- | static/style.css | 50 | ||||
| -rw-r--r-- | tiled/Data/Tiled.hs | 4 | ||||
| -rw-r--r-- | tiled/default.nix | 13 | ||||
| -rw-r--r-- | tiled/tiled.cabal | 24 | ||||
| -rw-r--r-- | walint-cli/Main.hs (renamed from src/Main.hs) | 13 | ||||
| -rw-r--r-- | walint-cli/Version.hs (renamed from src/Version.hs) | 0 | ||||
| -rw-r--r-- | walint-cli/default.nix | 18 | ||||
| -rw-r--r-- | walint-cli/walint-cli.cabal | 27 | ||||
| -rw-r--r-- | walint.cabal | 160 | ||||
| -rw-r--r-- | walint/Badges.hs (renamed from lib/Badges.hs) | 10 | ||||
| -rw-r--r-- | walint/CheckDir.hs (renamed from lib/CheckDir.hs) | 5 | ||||
| -rw-r--r-- | walint/CheckMap.hs (renamed from lib/CheckMap.hs) | 7 | ||||
| -rw-r--r-- | walint/Dirgraph.hs (renamed from lib/Dirgraph.hs) | 5 | ||||
| -rw-r--r-- | walint/LayerData.hs (renamed from lib/LayerData.hs) | 0 | ||||
| -rw-r--r-- | walint/LintConfig.hs (renamed from lib/LintConfig.hs) | 20 | ||||
| -rw-r--r-- | walint/LintWriter.hs (renamed from lib/LintWriter.hs) | 6 | ||||
| -rw-r--r-- | walint/Paths.hs (renamed from lib/Paths.hs) | 0 | ||||
| -rw-r--r-- | walint/Properties.hs (renamed from lib/Properties.hs) | 17 | ||||
| -rw-r--r-- | walint/Types.hs (renamed from lib/Types.hs) | 2 | ||||
| -rw-r--r-- | walint/Uris.hs (renamed from lib/Uris.hs) | 3 | ||||
| -rw-r--r-- | walint/Util.hs (renamed from lib/Util.hs) | 0 | ||||
| -rw-r--r-- | walint/WriteRepo.hs (renamed from lib/WriteRepo.hs) | 5 | ||||
| -rw-r--r-- | walint/default.nix | 17 | ||||
| -rw-r--r-- | walint/walint.cabal | 48 |
45 files changed, 305 insertions, 1856 deletions
@@ -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" } @@ -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 Binary files differdeleted 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 Binary files differdeleted 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 |