3086 lines
87 KiB
YAML
3086 lines
87 KiB
YAML
- arguments:
|
|
- -XConstraintKinds
|
|
- -XDeriveGeneric
|
|
- -XGeneralizedNewtypeDeriving
|
|
- -XLambdaCase
|
|
- -XOverloadedStrings
|
|
- -XRecordWildCards
|
|
- -XScopedTypeVariables
|
|
- -XStandaloneDeriving
|
|
- -XTupleSections
|
|
- -XTypeApplications
|
|
- -XViewPatterns
|
|
- ignore:
|
|
name: Use head
|
|
- ignore:
|
|
name: Use Foldable.forM_
|
|
- hint:
|
|
lhs: pure ()
|
|
note: Use 'pass'
|
|
rhs: pass
|
|
- hint:
|
|
lhs: return ()
|
|
note: Use 'pass'
|
|
rhs: pass
|
|
- hint:
|
|
lhs: '(: [])'
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: (:| [])
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.Sequence.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.Text.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.Text.Lazy.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.ByteString.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.ByteString.Lazy.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.Map.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.Map.Strict.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.HashMap.Strict.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.HashMap.Lazy.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.IntMap.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.IntMap.Strict.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.Set.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.HashSet.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- hint:
|
|
lhs: Data.IntSet.singleton
|
|
note: Use `one`
|
|
rhs: one
|
|
- 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
|
|
- hint:
|
|
lhs: Control.Exception.throw
|
|
note: Use 'impureThrow'
|
|
rhs: impureThrow
|
|
- warn:
|
|
lhs: Data.Text.IO.readFile
|
|
rhs: readFileText
|
|
- warn:
|
|
lhs: Data.Text.IO.writeFile
|
|
rhs: writeFileText
|
|
- warn:
|
|
lhs: Data.Text.IO.appendFile
|
|
rhs: appendFileText
|
|
- warn:
|
|
lhs: Data.Text.Lazy.IO.readFile
|
|
rhs: readFileLText
|
|
- warn:
|
|
lhs: Data.Text.Lazy.IO.writeFile
|
|
rhs: writeFileLText
|
|
- warn:
|
|
lhs: Data.Text.Lazy.IO.appendFile
|
|
rhs: appendFileLText
|
|
- warn:
|
|
lhs: Data.ByteString.readFile
|
|
rhs: readFileBS
|
|
- warn:
|
|
lhs: Data.ByteString.writeFile
|
|
rhs: writeFileBS
|
|
- warn:
|
|
lhs: Data.ByteString.appendFile
|
|
rhs: appendFileBS
|
|
- warn:
|
|
lhs: Data.ByteString.Lazy.readFile
|
|
rhs: readFileLBS
|
|
- warn:
|
|
lhs: Data.ByteString.Lazy.writeFile
|
|
rhs: writeFileLBS
|
|
- warn:
|
|
lhs: Data.ByteString.Lazy.appendFile
|
|
rhs: appendFileLBS
|
|
- hint:
|
|
lhs: foldl' (flip f)
|
|
note: Use 'flipfoldl''
|
|
rhs: flipfoldl' f
|
|
- warn:
|
|
lhs: foldl' (+) 0
|
|
rhs: sum
|
|
- warn:
|
|
lhs: foldl' (*) 1
|
|
rhs: product
|
|
- hint:
|
|
lhs: fmap and (sequence s)
|
|
note: Applying this hint would mean that some actions that were being executed
|
|
previously would no longer be executed.
|
|
rhs: andM s
|
|
- hint:
|
|
lhs: and <$> sequence s
|
|
note: Applying this hint would mean that some actions that were being executed
|
|
previously would no longer be executed.
|
|
rhs: andM s
|
|
- hint:
|
|
lhs: fmap or (sequence s)
|
|
note: Applying this hint would mean that some actions that were being executed
|
|
previously would no longer be executed.
|
|
rhs: orM s
|
|
- hint:
|
|
lhs: or <$> sequence s
|
|
note: Applying this hint would mean that some actions that were being executed
|
|
previously would no longer be executed.
|
|
rhs: orM s
|
|
- hint:
|
|
lhs: fmap and (mapM f s)
|
|
note: Applying this hint would mean that some actions that were being executed
|
|
previously would no longer be executed.
|
|
rhs: allM f s
|
|
- hint:
|
|
lhs: and <$> mapM f s
|
|
note: Applying this hint would mean that some actions that were being executed
|
|
previously would no longer be executed.
|
|
rhs: allM f s
|
|
- hint:
|
|
lhs: fmap or (mapM f s)
|
|
note: Applying this hint would mean that some actions that were being executed
|
|
previously would no longer be executed.
|
|
rhs: anyM f s
|
|
- hint:
|
|
lhs: or <$> mapM f s
|
|
note: Applying this hint would mean that some actions that were being executed
|
|
previously would no longer be executed.
|
|
rhs: anyM f s
|
|
- warn:
|
|
lhs: getAlt (foldMap (Alt . f) xs)
|
|
rhs: asumMap xs
|
|
- warn:
|
|
lhs: getAlt . foldMap (Alt . f)
|
|
rhs: asumMap
|
|
- hint:
|
|
lhs: foldr (\x acc -> f x <|> acc) empty
|
|
note: Use 'asumMap'
|
|
rhs: asumMap f
|
|
- hint:
|
|
lhs: asum (map f xs)
|
|
note: Use 'asumMap'
|
|
rhs: asumMap f xs
|
|
- warn:
|
|
lhs: map fst &&& map snd
|
|
rhs: unzip
|
|
- hint:
|
|
lhs: fmap (fmap f) x
|
|
note: Use '(<<$>>)'
|
|
rhs: f <<$>> x
|
|
- hint:
|
|
lhs: (\f -> f x) <$> ff
|
|
note: Use flap operator
|
|
rhs: ff ?? x
|
|
- hint:
|
|
lhs: fmap (\f -> f x) ff
|
|
note: Use flap operator
|
|
rhs: ff ?? x
|
|
- hint:
|
|
lhs: fmap ($ x) ff
|
|
note: Use flap operator
|
|
rhs: ff ?? x
|
|
- hint:
|
|
lhs: ($ x) <$> ff
|
|
note: Use flap operator
|
|
rhs: ff ?? x
|
|
- warn:
|
|
lhs: fmap f (nonEmpty x)
|
|
rhs: viaNonEmpty f x
|
|
- warn:
|
|
lhs: fmap f . nonEmpty
|
|
rhs: viaNonEmpty f
|
|
- warn:
|
|
lhs: f <$> nonEmpty x
|
|
rhs: viaNonEmpty f x
|
|
- warn:
|
|
lhs: f >>= guard
|
|
rhs: guardM f
|
|
- warn:
|
|
lhs: guard =<< f
|
|
rhs: guardM f
|
|
- 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 l
|
|
- warn:
|
|
lhs: maybe (Right r) Left
|
|
rhs: maybeToLeft r
|
|
- warn:
|
|
lhs: case m of Just x -> f x; Nothing -> pure ()
|
|
rhs: whenJust m f
|
|
- warn:
|
|
lhs: case m of Just x -> f x; Nothing -> return ()
|
|
rhs: whenJust m f
|
|
- warn:
|
|
lhs: case m of Just x -> f x; Nothing -> pass
|
|
rhs: whenJust m f
|
|
- warn:
|
|
lhs: case m of Nothing -> pure () ; Just x -> f x
|
|
rhs: whenJust m f
|
|
- warn:
|
|
lhs: case m of Nothing -> return (); Just x -> f x
|
|
rhs: whenJust m f
|
|
- warn:
|
|
lhs: case m of Nothing -> pass ; Just x -> f x
|
|
rhs: whenJust m f
|
|
- warn:
|
|
lhs: maybe (pure ()) f m
|
|
rhs: whenJust m f
|
|
- warn:
|
|
lhs: maybe (return ()) f m
|
|
rhs: whenJust m f
|
|
- warn:
|
|
lhs: maybe pass f m
|
|
rhs: whenJust m f
|
|
- warn:
|
|
lhs: m >>= \a -> whenJust a f
|
|
rhs: whenJustM m f
|
|
- warn:
|
|
lhs: m >>= \case Just x -> f x; Nothing -> pure ()
|
|
rhs: whenJustM m f
|
|
- warn:
|
|
lhs: m >>= \case Just x -> f x; Nothing -> return ()
|
|
rhs: whenJustM m f
|
|
- warn:
|
|
lhs: m >>= \case Just x -> f x; Nothing -> pass
|
|
rhs: whenJustM m f
|
|
- warn:
|
|
lhs: m >>= \case Nothing -> pure () ; Just x -> f x
|
|
rhs: whenJustM m f
|
|
- warn:
|
|
lhs: m >>= \case Nothing -> return (); Just x -> f x
|
|
rhs: whenJustM m f
|
|
- warn:
|
|
lhs: m >>= \case Nothing -> pass ; Just x -> f x
|
|
rhs: whenJustM m f
|
|
- warn:
|
|
lhs: maybe (pure ()) f =<< m
|
|
rhs: whenJustM m f
|
|
- warn:
|
|
lhs: maybe (return ()) f =<< m
|
|
rhs: whenJustM m f
|
|
- warn:
|
|
lhs: maybe pass f =<< m
|
|
rhs: whenJustM m f
|
|
- warn:
|
|
lhs: m >>= maybe (pure ()) f
|
|
rhs: whenJustM m f
|
|
- warn:
|
|
lhs: m >>= maybe (return ()) f
|
|
rhs: whenJustM m f
|
|
- warn:
|
|
lhs: m >>= maybe pass f
|
|
rhs: whenJustM m f
|
|
- warn:
|
|
lhs: case m of Just _ -> pure () ; Nothing -> x
|
|
rhs: whenNothing_ m x
|
|
- warn:
|
|
lhs: case m of Just _ -> return (); Nothing -> x
|
|
rhs: whenNothing_ m x
|
|
- warn:
|
|
lhs: case m of Just _ -> pass ; Nothing -> x
|
|
rhs: whenNothing_ m x
|
|
- warn:
|
|
lhs: case m of Nothing -> x; Just _ -> pure ()
|
|
rhs: whenNothing_ m x
|
|
- warn:
|
|
lhs: case m of Nothing -> x; Just _ -> return ()
|
|
rhs: whenNothing_ m x
|
|
- warn:
|
|
lhs: case m of Nothing -> x; Just _ -> pass
|
|
rhs: whenNothing_ m x
|
|
- warn:
|
|
lhs: maybe x (\_ -> pure () ) m
|
|
rhs: whenNothing_ m x
|
|
- warn:
|
|
lhs: maybe x (\_ -> return () ) m
|
|
rhs: whenNothing_ m x
|
|
- warn:
|
|
lhs: maybe x (\_ -> pass ) m
|
|
rhs: whenNothing_ m x
|
|
- warn:
|
|
lhs: maybe x (const (pure () )) m
|
|
rhs: whenNothing_ m x
|
|
- warn:
|
|
lhs: maybe x (const (return ())) m
|
|
rhs: whenNothing_ m x
|
|
- warn:
|
|
lhs: maybe x (const pass) m
|
|
rhs: whenNothing_ m x
|
|
- warn:
|
|
lhs: m >>= \a -> whenNothing_ a x
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: m >>= \case Just _ -> pure () ; Nothing -> x
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: m >>= \case Just _ -> return (); Nothing -> x
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: m >>= \case Just _ -> pass ; Nothing -> x
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: m >>= \case Nothing -> x; Just _ -> pure ()
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: m >>= \case Nothing -> x; Just _ -> return ()
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: m >>= \case Nothing -> x; Just _ -> pass
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: maybe x (\_ -> pure () ) =<< m
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: maybe x (\_ -> return () ) =<< m
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: maybe x (\_ -> pass ) =<< m
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: maybe x (const (pure () )) =<< m
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: maybe x (const (return ())) =<< m
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: maybe x (const pass) =<< m
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: m >>= maybe x (\_ -> pure ())
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: m >>= maybe x (\_ -> return ())
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: m >>= maybe x (\_ -> pass)
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: m >>= maybe x (const (pure ()) )
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: m >>= maybe x (const (return ()))
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: m >>= maybe x (const pass)
|
|
rhs: whenNothingM_ m x
|
|
- warn:
|
|
lhs: whenLeft ()
|
|
rhs: whenLeft_
|
|
- warn:
|
|
lhs: case m of Left x -> f x; Right _ -> pure ()
|
|
rhs: whenLeft_ m f
|
|
- warn:
|
|
lhs: case m of Left x -> f x; Right _ -> return ()
|
|
rhs: whenLeft_ m f
|
|
- warn:
|
|
lhs: case m of Left x -> f x; Right _ -> pass
|
|
rhs: whenLeft_ m f
|
|
- warn:
|
|
lhs: case m of Right _ -> pure () ; Left x -> f x
|
|
rhs: whenLeft_ m f
|
|
- warn:
|
|
lhs: case m of Right _ -> return (); Left x -> f x
|
|
rhs: whenLeft_ m f
|
|
- warn:
|
|
lhs: case m of Right _ -> pass ; Left x -> f x
|
|
rhs: whenLeft_ m f
|
|
- warn:
|
|
lhs: either f (\_ -> pure () ) m
|
|
rhs: whenLeft_ m f
|
|
- warn:
|
|
lhs: either f (\_ -> return () ) m
|
|
rhs: whenLeft_ m f
|
|
- warn:
|
|
lhs: either f (\_ -> pass ) m
|
|
rhs: whenLeft_ m f
|
|
- warn:
|
|
lhs: either f (const (pure () )) m
|
|
rhs: whenLeft_ m f
|
|
- warn:
|
|
lhs: either f (const (return ())) m
|
|
rhs: whenLeft_ m f
|
|
- warn:
|
|
lhs: either f (const pass) m
|
|
rhs: whenLeft_ m f
|
|
- warn:
|
|
lhs: m >>= \a -> whenLeft_ a f
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: m >>= \case Left x -> f x; Right _ -> pure ()
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: m >>= \case Left x -> f x; Right _ -> return ()
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: m >>= \case Left x -> f x; Right _ -> pass
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: m >>= \case Right _ -> pure () ; Left x -> f x
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: m >>= \case Right _ -> return (); Left x -> f x
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: m >>= \case Right _ -> pass ; Left x -> f x
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: either f (\_ -> pure () ) =<< m
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: either f (\_ -> return () ) =<< m
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: either f (\_ -> pass ) =<< m
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: either f (const (pure () )) =<< m
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: either f (const (return ())) =<< m
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: either f (const pass) =<< m
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: m >>= either f (\_ -> pure ())
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: m >>= either f (\_ -> return ())
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: m >>= either f (\_ -> pass)
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: m >>= either f (const (pure ()) )
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: m >>= either f (const (return ()))
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: m >>= either f (const pass)
|
|
rhs: whenLeftM_ m f
|
|
- warn:
|
|
lhs: whenRight ()
|
|
rhs: whenRight_
|
|
- warn:
|
|
lhs: case m of Right x -> f x; Left _ -> pure ()
|
|
rhs: whenRight_ m f
|
|
- warn:
|
|
lhs: case m of Right x -> f x; Left _ -> return ()
|
|
rhs: whenRight_ m f
|
|
- warn:
|
|
lhs: case m of Right x -> f x; Left _ -> pass
|
|
rhs: whenRight_ m f
|
|
- warn:
|
|
lhs: case m of Left _ -> pure () ; Right x -> f x
|
|
rhs: whenRight_ m f
|
|
- warn:
|
|
lhs: case m of Left _ -> return (); Right x -> f x
|
|
rhs: whenRight_ m f
|
|
- warn:
|
|
lhs: case m of Left _ -> pass ; Right x -> f x
|
|
rhs: whenRight_ m f
|
|
- warn:
|
|
lhs: either (\_ -> pure () ) f m
|
|
rhs: whenRight_ m f
|
|
- warn:
|
|
lhs: either (\_ -> return () ) f m
|
|
rhs: whenRight_ m f
|
|
- warn:
|
|
lhs: either (\_ -> pass ) f m
|
|
rhs: whenRight_ m f
|
|
- warn:
|
|
lhs: either (const (pure () )) f m
|
|
rhs: whenRight_ m f
|
|
- warn:
|
|
lhs: either (const (return ())) f m
|
|
rhs: whenRight_ m f
|
|
- warn:
|
|
lhs: either (const pass) f m
|
|
rhs: whenRight_ m f
|
|
- warn:
|
|
lhs: m >>= \a -> whenRight_ a f
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: 'm >>= \case Right x -> f x; Left _ -> pure () '
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: m >>= \case Right x -> f x; Left _ -> return ()
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: m >>= \case Right x -> f x; Left _ -> pass
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: m >>= \case Left _ -> pure () ; Right x -> f x
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: m >>= \case Left _ -> return (); Right x -> f x
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: m >>= \case Left _ -> pass ; Right x -> f x
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: either (\_ -> pure () ) f =<< m
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: either (\_ -> return () ) f =<< m
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: either (\_ -> pass ) f =<< m
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: either (const (pure () )) f =<< m
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: either (const (return ())) f =<< m
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: either (const pass) f =<< m
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: m >>= either (\_ -> pure ()) f
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: m >>= either (\_ -> return ()) f
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: m >>= either (\_ -> pass) f
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: m >>= either (const (pure ()) ) f
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: m >>= either (const (return ())) f
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: m >>= either (const pass) f
|
|
rhs: whenRightM_ m f
|
|
- warn:
|
|
lhs: 'case m of Left x -> f x; Right _ -> pure d '
|
|
rhs: whenLeft d m f
|
|
- warn:
|
|
lhs: case m of Left x -> f x; Right _ -> return d
|
|
rhs: whenLeft d m f
|
|
- warn:
|
|
lhs: case m of Right _ -> pure d ; Left x -> f x
|
|
rhs: whenLeft d m f
|
|
- warn:
|
|
lhs: case m of Right _ -> return d; Left x -> f x
|
|
rhs: whenLeft d m f
|
|
- warn:
|
|
lhs: either f (\_ -> pure d ) m
|
|
rhs: whenLeft d m f
|
|
- warn:
|
|
lhs: either f (\_ -> return d ) m
|
|
rhs: whenLeft d m f
|
|
- warn:
|
|
lhs: either f (const (pure d )) m
|
|
rhs: whenLeft d m f
|
|
- warn:
|
|
lhs: either f (const (return d)) m
|
|
rhs: whenLeft d m f
|
|
- warn:
|
|
lhs: m >>= \a -> whenLeft d a f
|
|
rhs: whenLeftM d m f
|
|
- warn:
|
|
lhs: m >>= \case Left x -> f x; Right _ -> pure d
|
|
rhs: whenLeftM d m f
|
|
- warn:
|
|
lhs: m >>= \case Left x -> f x; Right _ -> return d
|
|
rhs: whenLeftM d m f
|
|
- warn:
|
|
lhs: m >>= \case Right _ -> pure d ; Left x -> f x
|
|
rhs: whenLeftM d m f
|
|
- warn:
|
|
lhs: m >>= \case Right _ -> return d; Left x -> f x
|
|
rhs: whenLeftM d m f
|
|
- warn:
|
|
lhs: either f (\_ -> pure d ) =<< m
|
|
rhs: whenLeftM d m f
|
|
- warn:
|
|
lhs: either f (\_ -> return d ) =<< m
|
|
rhs: whenLeftM d m f
|
|
- warn:
|
|
lhs: either f (const (pure d )) =<< m
|
|
rhs: whenLeftM d m f
|
|
- warn:
|
|
lhs: either f (const (return d)) =<< m
|
|
rhs: whenLeftM d m f
|
|
- warn:
|
|
lhs: m >>= either f (\_ -> pure d)
|
|
rhs: whenLeftM d m f
|
|
- warn:
|
|
lhs: m >>= either f (\_ -> return d)
|
|
rhs: whenLeftM d m f
|
|
- warn:
|
|
lhs: m >>= either f (const (pure d))
|
|
rhs: whenLeftM d m f
|
|
- warn:
|
|
lhs: m >>= either f (const (return d))
|
|
rhs: whenLeftM d m f
|
|
- warn:
|
|
lhs: case m of Right x -> f x; Left _ -> pure d
|
|
rhs: whenRight d m f
|
|
- warn:
|
|
lhs: case m of Right x -> f x; Left _ -> return d
|
|
rhs: whenRight d m f
|
|
- warn:
|
|
lhs: case m of Left _ -> pure d ; Right x -> f x
|
|
rhs: whenRight d m f
|
|
- warn:
|
|
lhs: case m of Left _ -> return d; Right x -> f x
|
|
rhs: whenRight d m f
|
|
- warn:
|
|
lhs: either (\_ -> pure d ) f m
|
|
rhs: whenRight d m f
|
|
- warn:
|
|
lhs: either (\_ -> return d ) f m
|
|
rhs: whenRight d m f
|
|
- warn:
|
|
lhs: either (const (pure d )) f m
|
|
rhs: whenRight d m f
|
|
- warn:
|
|
lhs: either (const (return d)) f m
|
|
rhs: whenRight d m f
|
|
- warn:
|
|
lhs: m >>= \a -> whenRight d a f
|
|
rhs: whenRightM d m f
|
|
- warn:
|
|
lhs: m >>= \case Right x -> f x; Left _ -> pure d
|
|
rhs: whenRightM d m f
|
|
- warn:
|
|
lhs: m >>= \case Right x -> f x; Left _ -> return d
|
|
rhs: whenRightM d m f
|
|
- warn:
|
|
lhs: m >>= \case Left _ -> pure d ; Right x -> f x
|
|
rhs: whenRightM d m f
|
|
- warn:
|
|
lhs: m >>= \case Left _ -> return d; Right x -> f x
|
|
rhs: whenRightM d m f
|
|
- warn:
|
|
lhs: either (\_ -> pure d ) f =<< m
|
|
rhs: whenRightM d m f
|
|
- warn:
|
|
lhs: either (\_ -> return d ) f =<< m
|
|
rhs: whenRightM d m f
|
|
- warn:
|
|
lhs: either (const (pure d )) f =<< m
|
|
rhs: whenRightM d m f
|
|
- warn:
|
|
lhs: either (const (return d)) f =<< m
|
|
rhs: whenRightM d m f
|
|
- warn:
|
|
lhs: m >>= either (\_ -> pure d) f
|
|
rhs: whenRightM d m f
|
|
- warn:
|
|
lhs: m >>= either (\_ -> return d) f
|
|
rhs: whenRightM d m f
|
|
- warn:
|
|
lhs: m >>= either (const (pure d) ) f
|
|
rhs: whenRightM d m f
|
|
- warn:
|
|
lhs: m >>= either (const (return d)) f
|
|
rhs: whenRightM d m f
|
|
- warn:
|
|
lhs: case m of [] -> return (); (x:xs) -> f (x :| xs)
|
|
rhs: whenNotNull m f
|
|
- warn:
|
|
lhs: case m of [] -> pure () ; (x:xs) -> f (x :| xs)
|
|
rhs: whenNotNull m f
|
|
- warn:
|
|
lhs: case m of [] -> pass ; (x:xs) -> f (x :| xs)
|
|
rhs: whenNotNull m f
|
|
- warn:
|
|
lhs: case m of (x:xs) -> f (x :| xs); [] -> return ()
|
|
rhs: whenNotNull m f
|
|
- warn:
|
|
lhs: 'case m of (x:xs) -> f (x :| xs); [] -> pure () '
|
|
rhs: whenNotNull m f
|
|
- warn:
|
|
lhs: 'case m of (x:xs) -> f (x :| xs); [] -> pass '
|
|
rhs: whenNotNull m f
|
|
- warn:
|
|
lhs: m >>= \case [] -> pass ; (x:xs) -> f (x :| xs)
|
|
rhs: whenNotNullM m f
|
|
- warn:
|
|
lhs: m >>= \case [] -> pure () ; (x:xs) -> f (x :| xs)
|
|
rhs: whenNotNullM m f
|
|
- warn:
|
|
lhs: m >>= \case [] -> return (); (x:xs) -> f (x :| xs)
|
|
rhs: whenNotNullM m f
|
|
- warn:
|
|
lhs: 'm >>= \case (x:xs) -> f (x :| xs); [] -> pass '
|
|
rhs: whenNotNullM m f
|
|
- warn:
|
|
lhs: 'm >>= \case (x:xs) -> f (x :| xs); [] -> pure () '
|
|
rhs: whenNotNullM m f
|
|
- warn:
|
|
lhs: m >>= \case (x:xs) -> f (x :| xs); [] -> return ()
|
|
rhs: whenNotNullM m f
|
|
- warn:
|
|
lhs: mapMaybe leftToMaybe
|
|
rhs: lefts
|
|
- warn:
|
|
lhs: mapMaybe rightToMaybe
|
|
rhs: rights
|
|
- warn:
|
|
lhs: flip runReaderT
|
|
rhs: usingReaderT
|
|
- warn:
|
|
lhs: flip runReader
|
|
rhs: usingReader
|
|
- warn:
|
|
lhs: flip runStateT
|
|
rhs: usingStateT
|
|
- warn:
|
|
lhs: flip runState
|
|
rhs: usingState
|
|
- warn:
|
|
lhs: fst <$> usingStateT s st
|
|
rhs: evaluatingStateT s st
|
|
- warn:
|
|
lhs: fst (usingState s st)
|
|
rhs: evaluatingState s st
|
|
- warn:
|
|
lhs: snd <$> usingStateT s st
|
|
rhs: executingStateT s st
|
|
- warn:
|
|
lhs: snd (usingState s st)
|
|
rhs: executingState s st
|
|
- warn:
|
|
lhs: MaybeT (pure m)
|
|
rhs: hoistMaybe m
|
|
- warn:
|
|
lhs: MaybeT (return m)
|
|
rhs: hoistMaybe m
|
|
- warn:
|
|
lhs: MaybeT . pure
|
|
rhs: hoistMaybe
|
|
- warn:
|
|
lhs: MaybeT . return
|
|
rhs: hoistMaybe
|
|
- warn:
|
|
lhs: ExceptT (pure m)
|
|
rhs: hoistEither m
|
|
- warn:
|
|
lhs: ExceptT (return m)
|
|
rhs: hoistEither m
|
|
- warn:
|
|
lhs: ExceptT . pure
|
|
rhs: hoistEither
|
|
- warn:
|
|
lhs: ExceptT . return
|
|
rhs: hoistEither
|
|
- warn:
|
|
lhs: fromMaybe mempty
|
|
rhs: maybeToMonoid
|
|
- warn:
|
|
lhs: 'm ?: mempty'
|
|
rhs: maybeToMonoid m
|
|
- warn:
|
|
lhs: Data.Map.toAscList (Data.Map.fromList x)
|
|
rhs: sortWith fst x
|
|
- warn:
|
|
lhs: Data.Map.toDescList (Data.Map.fromList x)
|
|
rhs: sortWith (Down . fst) x
|
|
- warn:
|
|
lhs: Data.Set.toList (Data.Set.fromList l)
|
|
rhs: sortNub l
|
|
- warn:
|
|
lhs: Data.Set.assocs (Data.Set.fromList l)
|
|
rhs: sortNub l
|
|
- warn:
|
|
lhs: Data.Set.toAscList (Data.Set.fromList l)
|
|
rhs: sortNub l
|
|
- warn:
|
|
lhs: Data.HashSet.toList (Data.HashSet.fromList l)
|
|
rhs: unstableNub l
|
|
- warn:
|
|
lhs: nub
|
|
note: '''nub'' is O(n^2), ''ordNub'' is O(n log n)'
|
|
rhs: ordNub
|
|
- warn:
|
|
lhs: sortBy (comparing 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.
|
|
rhs: sortWith f
|
|
- warn:
|
|
lhs: sortOn fst
|
|
note: '''sortWith'' will be faster here because it doesn''t do caching'
|
|
rhs: sortWith fst
|
|
- warn:
|
|
lhs: sortOn snd
|
|
note: '''sortWith'' will be faster here because it doesn''t do caching'
|
|
rhs: sortWith snd
|
|
- warn:
|
|
lhs: sortOn (Down . fst)
|
|
note: '''sortWith'' will be faster here because it doesn''t do caching'
|
|
rhs: sortWith (Down . fst)
|
|
- warn:
|
|
lhs: sortOn (Down . snd)
|
|
note: '''sortWith'' will be faster here because it doesn''t do caching'
|
|
rhs: sortWith (Down . snd)
|
|
- warn:
|
|
lhs: Data.Text.IO.putStr
|
|
rhs: putText
|
|
- warn:
|
|
lhs: Data.Text.IO.putStrLn
|
|
rhs: putTextLn
|
|
- warn:
|
|
lhs: Data.Text.Lazy.IO.putStr
|
|
rhs: putLText
|
|
- warn:
|
|
lhs: Data.Text.Lazy.IO.putStrLn
|
|
rhs: putLTextLn
|
|
- warn:
|
|
lhs: Data.ByteString.Char8.putStr
|
|
rhs: putBS
|
|
- warn:
|
|
lhs: Data.ByteString.Char8.putStrLn
|
|
rhs: putBSLn
|
|
- warn:
|
|
lhs: Data.ByteString.Lazy.Char8.putStr
|
|
rhs: putLBS
|
|
- warn:
|
|
lhs: Data.ByteString.Lazy.Char8.putStrLn
|
|
rhs: putLBSLn
|
|
- warn:
|
|
lhs: Data.Text.Lazy.Text
|
|
rhs: LText
|
|
- warn:
|
|
lhs: Data.ByteString.Lazy.ByteString
|
|
rhs: LByteString
|
|
- warn:
|
|
lhs: Data.ByteString.UTF8.fromString
|
|
rhs: encodeUtf8
|
|
- warn:
|
|
lhs: Data.ByteString.UTF8.toString
|
|
rhs: decodeUtf8
|
|
- warn:
|
|
lhs: Data.Text.Encoding.encodeUtf8
|
|
rhs: encodeUtf8
|
|
- warn:
|
|
lhs: Data.Text.Encoding.decodeUtf8
|
|
rhs: decodeUtf8
|
|
- warn:
|
|
lhs: Data.ByteString.Lazy.toStrict (encodeUtf8 x)
|
|
rhs: encodeUtf8 x
|
|
- warn:
|
|
lhs: toStrict (encodeUtf8 x)
|
|
rhs: encodeUtf8 x
|
|
- warn:
|
|
lhs: decodeUtf8 (Data.ByteString.Lazy.fromStrict x)
|
|
rhs: decodeUtf8 x
|
|
- warn:
|
|
lhs: decodeUtf8 (fromStrict x)
|
|
rhs: decodeUtf8 x
|
|
- warn:
|
|
lhs: Data.ByteString.Lazy.UTF8.fromString
|
|
rhs: encodeUtf8
|
|
- warn:
|
|
lhs: Data.ByteString.Lazy.UTF8.toString
|
|
rhs: decodeUtf8
|
|
- warn:
|
|
lhs: Data.ByteString.Lazy.fromStrict (Data.Text.Encoding.encodeUtf8 x)
|
|
rhs: encodeUtf8 x
|
|
- warn:
|
|
lhs: Data.ByteString.Lazy.fromStrict (encodeUtf8 x)
|
|
rhs: encodeUtf8 x
|
|
- warn:
|
|
lhs: Data.Text.Encoding.decodeUtf8 (Data.ByteString.Lazy.toStrict x)
|
|
rhs: decodeUtf8 x
|
|
- warn:
|
|
lhs: Data.Text.Encoding.decodeUtf8 (toStrict x)
|
|
rhs: decodeUtf8 x
|
|
- warn:
|
|
lhs: decodeUtf8 (Data.ByteString.Lazy.toStrict x)
|
|
rhs: decodeUtf8 x
|
|
- warn:
|
|
lhs: decodeUtf8 (toStrict x)
|
|
rhs: decodeUtf8 x
|
|
- warn:
|
|
lhs: Data.Text.pack
|
|
rhs: toText
|
|
- warn:
|
|
lhs: Data.Text.unpack
|
|
rhs: toString
|
|
- warn:
|
|
lhs: Data.Text.Lazy.pack
|
|
rhs: toLText
|
|
- warn:
|
|
lhs: Data.Text.Lazy.unpack
|
|
rhs: toString
|
|
- warn:
|
|
lhs: Data.Text.Lazy.toStrict
|
|
rhs: toText
|
|
- warn:
|
|
lhs: Data.Text.Lazy.fromStrict
|
|
rhs: toLText
|
|
- warn:
|
|
lhs: Data.Text.pack (show x)
|
|
rhs: show x
|
|
- warn:
|
|
lhs: Data.Text.Lazy.pack (show x)
|
|
rhs: show x
|
|
- warn:
|
|
lhs: Data.ByteString.Lazy.fromStrict
|
|
rhs: fromStrict
|
|
- warn:
|
|
lhs: Data.ByteString.Lazy.toStrict
|
|
rhs: toStrict
|
|
- warn:
|
|
lhs: Data.Text.Lazy.fromStrict
|
|
rhs: fromStrict
|
|
- warn:
|
|
lhs: Data.Text.Lazy.toStrict
|
|
rhs: toStrict
|
|
- warn:
|
|
lhs: Control.Applicative.Alternative
|
|
note: '''Alternative'' is already exported from Relude'
|
|
name: Use 'Alternative' from Relude
|
|
rhs: Alternative
|
|
- warn:
|
|
lhs: Control.Applicative.empty
|
|
note: '''empty'' is already exported from Relude'
|
|
name: Use 'empty' from Relude
|
|
rhs: empty
|
|
- warn:
|
|
lhs: (Control.Applicative.<|>)
|
|
note: Operator '(<|>)' is already exported from Relude
|
|
name: Use '<|>' from Relude
|
|
rhs: (<|>)
|
|
- warn:
|
|
lhs: Control.Applicative.some
|
|
note: '''some'' is already exported from Relude'
|
|
name: Use 'some' from Relude
|
|
rhs: some
|
|
- warn:
|
|
lhs: Control.Applicative.many
|
|
note: '''many'' is already exported from Relude'
|
|
name: Use 'many' from Relude
|
|
rhs: many
|
|
- warn:
|
|
lhs: Control.Applicative.Const
|
|
note: '''Const'' is already exported from Relude'
|
|
name: Use 'Const' from Relude
|
|
rhs: Const
|
|
- warn:
|
|
lhs: Control.Applicative.getConst
|
|
note: '''getConst'' is already exported from Relude'
|
|
name: Use 'getConst' from Relude
|
|
rhs: getConst
|
|
- warn:
|
|
lhs: Control.Applicative.ZipList
|
|
note: '''ZipList'' is already exported from Relude'
|
|
name: Use 'ZipList' from Relude
|
|
rhs: ZipList
|
|
- warn:
|
|
lhs: Control.Applicative.getZipList
|
|
note: '''getZipList'' is already exported from Relude'
|
|
name: Use 'getZipList' from Relude
|
|
rhs: getZipList
|
|
- warn:
|
|
lhs: Control.Applicative.liftA2
|
|
note: '''liftA2'' is already exported from Relude'
|
|
name: Use 'liftA2' from Relude
|
|
rhs: liftA2
|
|
- warn:
|
|
lhs: Control.Applicative.liftA3
|
|
note: '''liftA3'' is already exported from Relude'
|
|
name: Use 'liftA3' from Relude
|
|
rhs: liftA3
|
|
- warn:
|
|
lhs: Control.Applicative.optional
|
|
note: '''optional'' is already exported from Relude'
|
|
name: Use 'optional' from Relude
|
|
rhs: optional
|
|
- warn:
|
|
lhs: (Control.Applicative.<**>)
|
|
note: Operator '(<**>)' is already exported from Relude
|
|
name: Use '<**>' from Relude
|
|
rhs: (<**>)
|
|
- warn:
|
|
lhs: Data.Bits.xor
|
|
note: '''xor'' is already exported from Relude'
|
|
name: Use 'xor' from Relude
|
|
rhs: xor
|
|
- warn:
|
|
lhs: Data.Char.chr
|
|
note: '''chr'' is already exported from Relude'
|
|
name: Use 'chr' from Relude
|
|
rhs: chr
|
|
- warn:
|
|
lhs: Data.Int.Int8
|
|
note: '''Int8'' is already exported from Relude'
|
|
name: Use 'Int8' from Relude
|
|
rhs: Int8
|
|
- warn:
|
|
lhs: Data.Int.Int16
|
|
note: '''Int16'' is already exported from Relude'
|
|
name: Use 'Int16' from Relude
|
|
rhs: Int16
|
|
- warn:
|
|
lhs: Data.Int.Int32
|
|
note: '''Int32'' is already exported from Relude'
|
|
name: Use 'Int32' from Relude
|
|
rhs: Int32
|
|
- warn:
|
|
lhs: Data.Int.Int64
|
|
note: '''Int64'' is already exported from Relude'
|
|
name: Use 'Int64' from Relude
|
|
rhs: Int64
|
|
- warn:
|
|
lhs: Data.Word.Word8
|
|
note: '''Word8'' is already exported from Relude'
|
|
name: Use 'Word8' from Relude
|
|
rhs: Word8
|
|
- warn:
|
|
lhs: Data.Word.Word16
|
|
note: '''Word16'' is already exported from Relude'
|
|
name: Use 'Word16' from Relude
|
|
rhs: Word16
|
|
- warn:
|
|
lhs: Data.Word.Word32
|
|
note: '''Word32'' is already exported from Relude'
|
|
name: Use 'Word32' from Relude
|
|
rhs: Word32
|
|
- warn:
|
|
lhs: Data.Word.Word64
|
|
note: '''Word64'' is already exported from Relude'
|
|
name: Use 'Word64' from Relude
|
|
rhs: Word64
|
|
- warn:
|
|
lhs: Data.Word.byteSwap16
|
|
note: '''byteSwap16'' is already exported from Relude'
|
|
name: Use 'byteSwap16' from Relude
|
|
rhs: byteSwap16
|
|
- warn:
|
|
lhs: Data.Word.byteSwap32
|
|
note: '''byteSwap32'' is already exported from Relude'
|
|
name: Use 'byteSwap32' from Relude
|
|
rhs: byteSwap32
|
|
- warn:
|
|
lhs: Data.Word.byteSwap64
|
|
note: '''byteSwap64'' is already exported from Relude'
|
|
name: Use 'byteSwap64' from Relude
|
|
rhs: byteSwap64
|
|
- warn:
|
|
lhs: Numeric.Natural.Natural
|
|
note: '''Natural'' is already exported from Relude'
|
|
name: Use 'Natural' from Relude
|
|
rhs: Natural
|
|
- warn:
|
|
lhs: System.IO.Handle
|
|
note: '''Handle'' is already exported from Relude'
|
|
name: Use 'Handle' from Relude
|
|
rhs: Handle
|
|
- warn:
|
|
lhs: System.IO.IOMode
|
|
note: '''IOMode'' is already exported from Relude'
|
|
name: Use 'IOMode' from Relude
|
|
rhs: IOMode
|
|
- warn:
|
|
lhs: System.IO.ReadMode
|
|
note: '''ReadMode'' is already exported from Relude'
|
|
name: Use 'ReadMode' from Relude
|
|
rhs: ReadMode
|
|
- warn:
|
|
lhs: System.IO.WriteMode
|
|
note: '''WriteMode'' is already exported from Relude'
|
|
name: Use 'WriteMode' from Relude
|
|
rhs: WriteMode
|
|
- warn:
|
|
lhs: System.IO.AppendMode
|
|
note: '''AppendMode'' is already exported from Relude'
|
|
name: Use 'AppendMode' from Relude
|
|
rhs: AppendMode
|
|
- warn:
|
|
lhs: System.IO.ReadWriteMode
|
|
note: '''ReadWriteMode'' is already exported from Relude'
|
|
name: Use 'ReadWriteMode' from Relude
|
|
rhs: ReadWriteMode
|
|
- warn:
|
|
lhs: System.IO.stderr
|
|
note: '''stderr'' is already exported from Relude'
|
|
name: Use 'stderr' from Relude
|
|
rhs: stderr
|
|
- warn:
|
|
lhs: System.IO.stdin
|
|
note: '''stdin'' is already exported from Relude'
|
|
name: Use 'stdin' from Relude
|
|
rhs: stdin
|
|
- warn:
|
|
lhs: System.IO.stdout
|
|
note: '''stdout'' is already exported from Relude'
|
|
name: Use 'stdout' from Relude
|
|
rhs: stdout
|
|
- warn:
|
|
lhs: System.IO.withFile
|
|
note: '''withFile'' is already exported from Relude'
|
|
name: Use 'withFile' from Relude
|
|
rhs: withFile
|
|
- warn:
|
|
lhs: Data.Ord.Down
|
|
note: '''Down'' is already exported from Relude'
|
|
name: Use 'Down' from Relude
|
|
rhs: Down
|
|
- warn:
|
|
lhs: Data.Ord.comparing
|
|
note: '''comparing'' is already exported from Relude'
|
|
name: Use 'comparing' from Relude
|
|
rhs: comparing
|
|
- warn:
|
|
lhs: Data.Coerce.Coercible
|
|
note: '''Coercible'' is already exported from Relude'
|
|
name: Use 'Coercible' from Relude
|
|
rhs: Coercible
|
|
- warn:
|
|
lhs: Data.Coerce.coerce
|
|
note: '''coerce'' is already exported from Relude'
|
|
name: Use 'coerce' from Relude
|
|
rhs: coerce
|
|
- warn:
|
|
lhs: Data.Kind.Constraint
|
|
note: '''Constraint'' is already exported from Relude'
|
|
name: Use 'Constraint' from Relude
|
|
rhs: Constraint
|
|
- warn:
|
|
lhs: Data.Kind.Type
|
|
note: '''Type'' is already exported from Relude'
|
|
name: Use 'Type' from Relude
|
|
rhs: Type
|
|
- warn:
|
|
lhs: Data.Typeable.Typeable
|
|
note: '''Typeable'' is already exported from Relude'
|
|
name: Use 'Typeable' from Relude
|
|
rhs: Typeable
|
|
- warn:
|
|
lhs: Data.Proxy.Proxy
|
|
note: '''Proxy'' is already exported from Relude'
|
|
name: Use 'Proxy' from Relude
|
|
rhs: Proxy
|
|
- warn:
|
|
lhs: Data.Typeable.Typeable
|
|
note: '''Typeable'' is already exported from Relude'
|
|
name: Use 'Typeable' from Relude
|
|
rhs: Typeable
|
|
- warn:
|
|
lhs: Data.Void.Void
|
|
note: '''Void'' is already exported from Relude'
|
|
name: Use 'Void' from Relude
|
|
rhs: Void
|
|
- warn:
|
|
lhs: Data.Void.absurd
|
|
note: '''absurd'' is already exported from Relude'
|
|
name: Use 'absurd' from Relude
|
|
rhs: absurd
|
|
- warn:
|
|
lhs: Data.Void.vacuous
|
|
note: '''vacuous'' is already exported from Relude'
|
|
name: Use 'vacuous' from Relude
|
|
rhs: vacuous
|
|
- warn:
|
|
lhs: Data.Base.maxInt
|
|
note: '''maxInt'' is already exported from Relude'
|
|
name: Use 'maxInt' from Relude
|
|
rhs: maxInt
|
|
- warn:
|
|
lhs: Data.Base.minInt
|
|
note: '''minInt'' is already exported from Relude'
|
|
name: Use 'minInt' from Relude
|
|
rhs: minInt
|
|
- warn:
|
|
lhs: Data.Base.ord
|
|
note: '''ord'' is already exported from Relude'
|
|
name: Use 'ord' from Relude
|
|
rhs: ord
|
|
- warn:
|
|
lhs: GHC.Enum.boundedEnumFrom
|
|
note: '''boundedEnumFrom'' is already exported from Relude'
|
|
name: Use 'boundedEnumFrom' from Relude
|
|
rhs: boundedEnumFrom
|
|
- warn:
|
|
lhs: GHC.Enum.boundedEnumFromThen
|
|
note: '''boundedEnumFromThen'' is already exported from Relude'
|
|
name: Use 'boundedEnumFromThen' from Relude
|
|
rhs: boundedEnumFromThen
|
|
- warn:
|
|
lhs: GHC.Generics.Generic
|
|
note: '''Generic'' is already exported from Relude'
|
|
name: Use 'Generic' from Relude
|
|
rhs: Generic
|
|
- warn:
|
|
lhs: GHC.Real.Ratio
|
|
note: '''Ratio'' is already exported from Relude'
|
|
name: Use 'Ratio' from Relude
|
|
rhs: Ratio
|
|
- warn:
|
|
lhs: GHC.Real.Rational
|
|
note: '''Rational'' is already exported from Relude'
|
|
name: Use 'Rational' from Relude
|
|
rhs: Rational
|
|
- warn:
|
|
lhs: GHC.Real.denominator
|
|
note: '''denominator'' is already exported from Relude'
|
|
name: Use 'denominator' from Relude
|
|
rhs: denominator
|
|
- warn:
|
|
lhs: GHC.Real.numerator
|
|
note: '''numerator'' is already exported from Relude'
|
|
name: Use 'numerator' from Relude
|
|
rhs: numerator
|
|
- warn:
|
|
lhs: GHC.TypeNats.CmpNat
|
|
note: '''CmpNat'' is already exported from Relude'
|
|
name: Use 'CmpNat' from Relude
|
|
rhs: CmpNat
|
|
- warn:
|
|
lhs: GHC.TypeNats.KnownNat
|
|
note: '''KnownNat'' is already exported from Relude'
|
|
name: Use 'KnownNat' from Relude
|
|
rhs: KnownNat
|
|
- warn:
|
|
lhs: GHC.TypeNats.Nat
|
|
note: '''Nat'' is already exported from Relude'
|
|
name: Use 'Nat' from Relude
|
|
rhs: Nat
|
|
- warn:
|
|
lhs: GHC.TypeNats.SomeNat
|
|
note: '''SomeNat'' is already exported from Relude'
|
|
name: Use 'SomeNat' from Relude
|
|
rhs: SomeNat
|
|
- warn:
|
|
lhs: GHC.TypeNats.natVal
|
|
note: '''natVal'' is already exported from Relude'
|
|
name: Use 'natVal' from Relude
|
|
rhs: natVal
|
|
- warn:
|
|
lhs: GHC.TypeNats.someNatVal
|
|
note: '''someNatVal'' is already exported from Relude'
|
|
name: Use 'someNatVal' from Relude
|
|
rhs: someNatVal
|
|
- warn:
|
|
lhs: GHC.TypeLits.CmpNat
|
|
note: '''CmpNat'' is already exported from Relude'
|
|
name: Use 'CmpNat' from Relude
|
|
rhs: CmpNat
|
|
- warn:
|
|
lhs: GHC.TypeLits.KnownNat
|
|
note: '''KnownNat'' is already exported from Relude'
|
|
name: Use 'KnownNat' from Relude
|
|
rhs: KnownNat
|
|
- warn:
|
|
lhs: GHC.TypeLits.Nat
|
|
note: '''Nat'' is already exported from Relude'
|
|
name: Use 'Nat' from Relude
|
|
rhs: Nat
|
|
- warn:
|
|
lhs: GHC.TypeLits.SomeNat
|
|
note: '''SomeNat'' is already exported from Relude'
|
|
name: Use 'SomeNat' from Relude
|
|
rhs: SomeNat
|
|
- warn:
|
|
lhs: GHC.TypeLits.natVal
|
|
note: '''natVal'' is already exported from Relude'
|
|
name: Use 'natVal' from Relude
|
|
rhs: natVal
|
|
- warn:
|
|
lhs: GHC.TypeLits.someNatVal
|
|
note: '''someNatVal'' is already exported from Relude'
|
|
name: Use 'someNatVal' from Relude
|
|
rhs: someNatVal
|
|
- warn:
|
|
lhs: GHC.ExecutionStack.getStackTrace
|
|
note: '''getStackTrace'' is already exported from Relude'
|
|
name: Use 'getStackTrace' from Relude
|
|
rhs: getStackTrace
|
|
- warn:
|
|
lhs: GHC.ExecutionStack.showStackTrace
|
|
note: '''showStackTrace'' is already exported from Relude'
|
|
name: Use 'showStackTrace' from Relude
|
|
rhs: showStackTrace
|
|
- warn:
|
|
lhs: GHC.OverloadedLabels.IsLabel
|
|
note: '''IsLabel'' is already exported from Relude'
|
|
name: Use 'IsLabel' from Relude
|
|
rhs: IsLabel
|
|
- warn:
|
|
lhs: GHC.OverloadedLabels.fromLabel
|
|
note: '''fromLabel'' is already exported from Relude'
|
|
name: Use 'fromLabel' from Relude
|
|
rhs: fromLabel
|
|
- warn:
|
|
lhs: GHC.Stack.CallStack
|
|
note: '''CallStack'' is already exported from Relude'
|
|
name: Use 'CallStack' from Relude
|
|
rhs: CallStack
|
|
- warn:
|
|
lhs: GHC.Stack.HasCallStack
|
|
note: '''HasCallStack'' is already exported from Relude'
|
|
name: Use 'HasCallStack' from Relude
|
|
rhs: HasCallStack
|
|
- warn:
|
|
lhs: GHC.Stack.callStack
|
|
note: '''callStack'' is already exported from Relude'
|
|
name: Use 'callStack' from Relude
|
|
rhs: callStack
|
|
- warn:
|
|
lhs: GHC.Stack.currentCallStack
|
|
note: '''currentCallStack'' is already exported from Relude'
|
|
name: Use 'currentCallStack' from Relude
|
|
rhs: currentCallStack
|
|
- warn:
|
|
lhs: GHC.Stack.getCallStack
|
|
note: '''getCallStack'' is already exported from Relude'
|
|
name: Use 'getCallStack' from Relude
|
|
rhs: getCallStack
|
|
- warn:
|
|
lhs: GHC.Stack.prettyCallStack
|
|
note: '''prettyCallStack'' is already exported from Relude'
|
|
name: Use 'prettyCallStack' from Relude
|
|
rhs: prettyCallStack
|
|
- warn:
|
|
lhs: GHC.Stack.prettySrcLoc
|
|
note: '''prettySrcLoc'' is already exported from Relude'
|
|
name: Use 'prettySrcLoc' from Relude
|
|
rhs: prettySrcLoc
|
|
- warn:
|
|
lhs: GHC.Stack.withFrozenCallStack
|
|
note: '''withFrozenCallStack'' is already exported from Relude'
|
|
name: Use 'withFrozenCallStack' from Relude
|
|
rhs: withFrozenCallStack
|
|
- warn:
|
|
lhs: Data.Bifoldable.Bifoldable
|
|
note: '''Bifoldable'' is already exported from Relude'
|
|
name: Use 'Bifoldable' from Relude
|
|
rhs: Bifoldable
|
|
- warn:
|
|
lhs: Data.Bifoldable.bifold
|
|
note: '''bifold'' is already exported from Relude'
|
|
name: Use 'bifold' from Relude
|
|
rhs: bifold
|
|
- warn:
|
|
lhs: Data.Bifoldable.bifoldMap
|
|
note: '''bifoldMap'' is already exported from Relude'
|
|
name: Use 'bifoldMap' from Relude
|
|
rhs: bifoldMap
|
|
- warn:
|
|
lhs: Data.Bifoldable.bifoldr
|
|
note: '''bifoldr'' is already exported from Relude'
|
|
name: Use 'bifoldr' from Relude
|
|
rhs: bifoldr
|
|
- warn:
|
|
lhs: Data.Bifoldable.bifoldl
|
|
note: '''bifoldl'' is already exported from Relude'
|
|
name: Use 'bifoldl' from Relude
|
|
rhs: bifoldl
|
|
- warn:
|
|
lhs: Data.Bifoldable.bifoldl'
|
|
note: '''bifoldl'''' is already exported from Relude'
|
|
name: Use 'bifoldl'' from Relude
|
|
rhs: bifoldl'
|
|
- warn:
|
|
lhs: Data.Bifoldable.bifoldlM
|
|
note: '''bifoldlM'' is already exported from Relude'
|
|
name: Use 'bifoldlM' from Relude
|
|
rhs: bifoldlM
|
|
- warn:
|
|
lhs: Data.Bifoldable.bifoldr'
|
|
note: '''bifoldr'''' is already exported from Relude'
|
|
name: Use 'bifoldr'' from Relude
|
|
rhs: bifoldr'
|
|
- warn:
|
|
lhs: Data.Bifoldable.bifoldrM
|
|
note: '''bifoldrM'' is already exported from Relude'
|
|
name: Use 'bifoldrM' from Relude
|
|
rhs: bifoldrM
|
|
- warn:
|
|
lhs: Data.Bifoldable.bitraverse_
|
|
note: '''bitraverse_'' is already exported from Relude'
|
|
name: Use 'bitraverse_' from Relude
|
|
rhs: bitraverse_
|
|
- warn:
|
|
lhs: Data.Bifoldable.bifor_
|
|
note: '''bifor_'' is already exported from Relude'
|
|
name: Use 'bifor_' from Relude
|
|
rhs: bifor_
|
|
- warn:
|
|
lhs: Data.Bifoldable.biasum
|
|
note: '''biasum'' is already exported from Relude'
|
|
name: Use 'biasum' from Relude
|
|
rhs: biasum
|
|
- warn:
|
|
lhs: Data.Bifoldable.bisequence_
|
|
note: '''bisequence_'' is already exported from Relude'
|
|
name: Use 'bisequence_' from Relude
|
|
rhs: bisequence_
|
|
- warn:
|
|
lhs: Data.Bifoldable.biList
|
|
note: '''biList'' is already exported from Relude'
|
|
name: Use 'biList' from Relude
|
|
rhs: biList
|
|
- warn:
|
|
lhs: Data.Bifoldable.binull
|
|
note: '''binull'' is already exported from Relude'
|
|
name: Use 'binull' from Relude
|
|
rhs: binull
|
|
- warn:
|
|
lhs: Data.Bifoldable.bilength
|
|
note: '''bilength'' is already exported from Relude'
|
|
name: Use 'bilength' from Relude
|
|
rhs: bilength
|
|
- warn:
|
|
lhs: Data.Bifoldable.bielem
|
|
note: '''bielem'' is already exported from Relude'
|
|
name: Use 'bielem' from Relude
|
|
rhs: bielem
|
|
- warn:
|
|
lhs: Data.Bifoldable.biand
|
|
note: '''biand'' is already exported from Relude'
|
|
name: Use 'biand' from Relude
|
|
rhs: biand
|
|
- warn:
|
|
lhs: Data.Bifoldable.bior
|
|
note: '''bior'' is already exported from Relude'
|
|
name: Use 'bior' from Relude
|
|
rhs: bior
|
|
- warn:
|
|
lhs: Data.Bifoldable.biany
|
|
note: '''biany'' is already exported from Relude'
|
|
name: Use 'biany' from Relude
|
|
rhs: biany
|
|
- warn:
|
|
lhs: Data.Bifoldable.biall
|
|
note: '''biall'' is already exported from Relude'
|
|
name: Use 'biall' from Relude
|
|
rhs: biall
|
|
- warn:
|
|
lhs: Data.Bifoldable.bifind
|
|
note: '''bifind'' is already exported from Relude'
|
|
name: Use 'bifind' from Relude
|
|
rhs: bifind
|
|
- warn:
|
|
lhs: Data.Bitraversable.Bitraversable
|
|
note: '''Bitraversable'' is already exported from Relude'
|
|
name: Use 'Bitraversable' from Relude
|
|
rhs: Bitraversable
|
|
- warn:
|
|
lhs: Data.Bitraversable.bitraverse
|
|
note: '''bitraverse'' is already exported from Relude'
|
|
name: Use 'bitraverse' from Relude
|
|
rhs: bitraverse
|
|
- warn:
|
|
lhs: Data.Bitraversable.bisequence
|
|
note: '''bisequence'' is already exported from Relude'
|
|
name: Use 'bisequence' from Relude
|
|
rhs: bisequence
|
|
- warn:
|
|
lhs: Data.Bitraversable.bifor
|
|
note: '''bifor'' is already exported from Relude'
|
|
name: Use 'bifor' from Relude
|
|
rhs: bifor
|
|
- warn:
|
|
lhs: Data.Bitraversable.bimapDefault
|
|
note: '''bimapDefault'' is already exported from Relude'
|
|
name: Use 'bimapDefault' from Relude
|
|
rhs: bimapDefault
|
|
- warn:
|
|
lhs: Data.Bitraversable.bifoldMapDefault
|
|
note: '''bifoldMapDefault'' is already exported from Relude'
|
|
name: Use 'bifoldMapDefault' from Relude
|
|
rhs: bifoldMapDefault
|
|
- warn:
|
|
lhs: Control.Monad.guard
|
|
note: '''guard'' is already exported from Relude'
|
|
name: Use 'guard' from Relude
|
|
rhs: guard
|
|
- warn:
|
|
lhs: Control.Monad.unless
|
|
note: '''unless'' is already exported from Relude'
|
|
name: Use 'unless' from Relude
|
|
rhs: unless
|
|
- warn:
|
|
lhs: Control.Monad.when
|
|
note: '''when'' is already exported from Relude'
|
|
name: Use 'when' from Relude
|
|
rhs: when
|
|
- warn:
|
|
lhs: Data.Bool.bool
|
|
note: '''bool'' is already exported from Relude'
|
|
name: Use 'bool' from Relude
|
|
rhs: bool
|
|
- warn:
|
|
lhs: Data.Hashable.Hashable
|
|
note: '''Hashable'' is already exported from Relude'
|
|
name: Use 'Hashable' from Relude
|
|
rhs: Hashable
|
|
- warn:
|
|
lhs: Data.Hashable.hashWithSalt
|
|
note: '''hashWithSalt'' is already exported from Relude'
|
|
name: Use 'hashWithSalt' from Relude
|
|
rhs: hashWithSalt
|
|
- warn:
|
|
lhs: Data.HashMap.Strict.HashMap
|
|
note: '''HashMap'' is already exported from Relude'
|
|
name: Use 'HashMap' from Relude
|
|
rhs: HashMap
|
|
- warn:
|
|
lhs: Data.HashSet.HashSet
|
|
note: '''HashSet'' is already exported from Relude'
|
|
name: Use 'HashSet' from Relude
|
|
rhs: HashSet
|
|
- warn:
|
|
lhs: Data.IntMap.Strict.IntMap
|
|
note: '''IntMap'' is already exported from Relude'
|
|
name: Use 'IntMap' from Relude
|
|
rhs: IntMap
|
|
- warn:
|
|
lhs: Data.IntSet.IntSet
|
|
note: '''IntSet'' is already exported from Relude'
|
|
name: Use 'IntSet' from Relude
|
|
rhs: IntSet
|
|
- warn:
|
|
lhs: Data.Map.Strict.Map
|
|
note: '''Map'' is already exported from Relude'
|
|
name: Use 'Map' from Relude
|
|
rhs: Map
|
|
- warn:
|
|
lhs: Data.Sequence.Sequence
|
|
note: '''Sequence'' is already exported from Relude'
|
|
name: Use 'Sequence' from Relude
|
|
rhs: Sequence
|
|
- warn:
|
|
lhs: Data.Set.Set
|
|
note: '''Set'' is already exported from Relude'
|
|
name: Use 'Set' from Relude
|
|
rhs: Set
|
|
- warn:
|
|
lhs: Data.Tuple.swap
|
|
note: '''swap'' is already exported from Relude'
|
|
name: Use 'swap' from Relude
|
|
rhs: swap
|
|
- warn:
|
|
lhs: Data.Vector.Vector
|
|
note: '''Vector'' is already exported from Relude'
|
|
name: Use 'Vector' from Relude
|
|
rhs: Vector
|
|
- warn:
|
|
lhs: GHC.Exts.IsList
|
|
note: '''IsList'' is already exported from Relude'
|
|
name: Use 'IsList' from Relude
|
|
rhs: IsList
|
|
- warn:
|
|
lhs: GHC.Exts.fromList
|
|
note: '''fromList'' is already exported from Relude'
|
|
name: Use 'fromList' from Relude
|
|
rhs: fromList
|
|
- warn:
|
|
lhs: GHC.Exts.fromListN
|
|
note: '''fromListN'' is already exported from Relude'
|
|
name: Use 'fromListN' from Relude
|
|
rhs: fromListN
|
|
- warn:
|
|
lhs: Debug.Trace.trace
|
|
note: '''trace'' is already exported from Relude'
|
|
name: Use 'trace' from Relude
|
|
rhs: trace
|
|
- warn:
|
|
lhs: Debug.Trace.traceShow
|
|
note: '''traceShow'' is already exported from Relude'
|
|
name: Use 'traceShow' from Relude
|
|
rhs: traceShow
|
|
- warn:
|
|
lhs: Debug.Trace.traceShowId
|
|
note: '''traceShowId'' is already exported from Relude'
|
|
name: Use 'traceShowId' from Relude
|
|
rhs: traceShowId
|
|
- warn:
|
|
lhs: Debug.Trace.traceShowM
|
|
note: '''traceShowM'' is already exported from Relude'
|
|
name: Use 'traceShowM' from Relude
|
|
rhs: traceShowM
|
|
- warn:
|
|
lhs: Debug.Trace.traceM
|
|
note: '''traceM'' is already exported from Relude'
|
|
name: Use 'traceM' from Relude
|
|
rhs: traceM
|
|
- warn:
|
|
lhs: Debug.Trace.traceId
|
|
note: '''traceId'' is already exported from Relude'
|
|
name: Use 'traceId' from Relude
|
|
rhs: traceId
|
|
- warn:
|
|
lhs: Control.DeepSeq.NFData
|
|
note: '''NFData'' is already exported from Relude'
|
|
name: Use 'NFData' from Relude
|
|
rhs: NFData
|
|
- warn:
|
|
lhs: Control.DeepSeq.rnf
|
|
note: '''rnf'' is already exported from Relude'
|
|
name: Use 'rnf' from Relude
|
|
rhs: rnf
|
|
- warn:
|
|
lhs: Control.DeepSeq.deepseq
|
|
note: '''deepseq'' is already exported from Relude'
|
|
name: Use 'deepseq' from Relude
|
|
rhs: deepseq
|
|
- warn:
|
|
lhs: Control.DeepSeq.force
|
|
note: '''force'' is already exported from Relude'
|
|
name: Use 'force' from Relude
|
|
rhs: force
|
|
- warn:
|
|
lhs: (Control.DeepSeq.$!!)
|
|
note: Operator '($!!)' is already exported from Relude
|
|
name: Use '$!!' from Relude
|
|
rhs: ($!!)
|
|
- warn:
|
|
lhs: Control.Exception.Exception
|
|
note: '''Exception'' is already exported from Relude'
|
|
name: Use 'Exception' from Relude
|
|
rhs: Exception
|
|
- warn:
|
|
lhs: Control.Exception.SomeException
|
|
note: '''SomeException'' is already exported from Relude'
|
|
name: Use 'SomeException' from Relude
|
|
rhs: SomeException
|
|
- warn:
|
|
lhs: Control.Exception.toException
|
|
note: '''toException'' is already exported from Relude'
|
|
name: Use 'toException' from Relude
|
|
rhs: toException
|
|
- warn:
|
|
lhs: Control.Exception.fromException
|
|
note: '''fromException'' is already exported from Relude'
|
|
name: Use 'fromException' from Relude
|
|
rhs: fromException
|
|
- warn:
|
|
lhs: Control.Exception.displayException
|
|
note: '''displayException'' is already exported from Relude'
|
|
name: Use 'displayException' from Relude
|
|
rhs: displayException
|
|
- warn:
|
|
lhs: Data.Foldable.asum
|
|
note: '''asum'' is already exported from Relude'
|
|
name: Use 'asum' from Relude
|
|
rhs: asum
|
|
- warn:
|
|
lhs: Data.Foldable.find
|
|
note: '''find'' is already exported from Relude'
|
|
name: Use 'find' from Relude
|
|
rhs: find
|
|
- warn:
|
|
lhs: Data.Foldable.find
|
|
note: '''find'' is already exported from Relude'
|
|
name: Use 'find' from Relude
|
|
rhs: find
|
|
- warn:
|
|
lhs: Data.Foldable.fold
|
|
note: '''fold'' is already exported from Relude'
|
|
name: Use 'fold' from Relude
|
|
rhs: fold
|
|
- warn:
|
|
lhs: Data.Foldable.foldl'
|
|
note: '''foldl'''' is already exported from Relude'
|
|
name: Use 'foldl'' from Relude
|
|
rhs: foldl'
|
|
- warn:
|
|
lhs: Data.Foldable.foldrM
|
|
note: '''foldrM'' is already exported from Relude'
|
|
name: Use 'foldrM' from Relude
|
|
rhs: foldrM
|
|
- warn:
|
|
lhs: Data.Foldable.forM_
|
|
note: '''forM_'' is already exported from Relude'
|
|
name: Use 'forM_' from Relude
|
|
rhs: forM_
|
|
- warn:
|
|
lhs: Data.Foldable.for_
|
|
note: '''for_'' is already exported from Relude'
|
|
name: Use 'for_' from Relude
|
|
rhs: for_
|
|
- warn:
|
|
lhs: Data.Foldable.sequenceA_
|
|
note: '''sequenceA_'' is already exported from Relude'
|
|
name: Use 'sequenceA_' from Relude
|
|
rhs: sequenceA_
|
|
- warn:
|
|
lhs: Data.Foldable.toList
|
|
note: '''toList'' is already exported from Relude'
|
|
name: Use 'toList' from Relude
|
|
rhs: toList
|
|
- warn:
|
|
lhs: Data.Foldable.traverse_
|
|
note: '''traverse_'' is already exported from Relude'
|
|
name: Use 'traverse_' from Relude
|
|
rhs: traverse_
|
|
- warn:
|
|
lhs: Data.Traversable.forM
|
|
note: '''forM'' is already exported from Relude'
|
|
name: Use 'forM' from Relude
|
|
rhs: forM
|
|
- warn:
|
|
lhs: Data.Traversable.mapAccumL
|
|
note: '''mapAccumL'' is already exported from Relude'
|
|
name: Use 'mapAccumL' from Relude
|
|
rhs: mapAccumL
|
|
- warn:
|
|
lhs: Data.Traversable.mapAccumR
|
|
note: '''mapAccumR'' is already exported from Relude'
|
|
name: Use 'mapAccumR' from Relude
|
|
rhs: mapAccumR
|
|
- warn:
|
|
lhs: (Control.Arrow.&&&)
|
|
note: Operator '(&&&)' is already exported from Relude
|
|
name: Use '&&&' from Relude
|
|
rhs: (&&&)
|
|
- warn:
|
|
lhs: (Control.Category.>>>)
|
|
note: Operator '(>>>)' is already exported from Relude
|
|
name: Use '>>>' from Relude
|
|
rhs: (>>>)
|
|
- warn:
|
|
lhs: (Control.Category.<<<)
|
|
note: Operator '(<<<)' is already exported from Relude
|
|
name: Use '<<<' from Relude
|
|
rhs: (<<<)
|
|
- warn:
|
|
lhs: Data.Function.fix
|
|
note: '''fix'' is already exported from Relude'
|
|
name: Use 'fix' from Relude
|
|
rhs: fix
|
|
- warn:
|
|
lhs: Data.Function.on
|
|
note: '''on'' is already exported from Relude'
|
|
name: Use 'on' from Relude
|
|
rhs: 'on'
|
|
- warn:
|
|
lhs: Data.Bifunctor.Bifunctor
|
|
note: '''Bifunctor'' is already exported from Relude'
|
|
name: Use 'Bifunctor' from Relude
|
|
rhs: Bifunctor
|
|
- warn:
|
|
lhs: Data.Bifunctor.bimap
|
|
note: '''bimap'' is already exported from Relude'
|
|
name: Use 'bimap' from Relude
|
|
rhs: bimap
|
|
- warn:
|
|
lhs: Data.Bifunctor.first
|
|
note: '''first'' is already exported from Relude'
|
|
name: Use 'first' from Relude
|
|
rhs: first
|
|
- warn:
|
|
lhs: Data.Bifunctor.second
|
|
note: '''second'' is already exported from Relude'
|
|
name: Use 'second' from Relude
|
|
rhs: second
|
|
- warn:
|
|
lhs: Data.Functor.void
|
|
note: '''void'' is already exported from Relude'
|
|
name: Use 'void' from Relude
|
|
rhs: void
|
|
- warn:
|
|
lhs: (Data.Functor.$>)
|
|
note: Operator '($>)' is already exported from Relude
|
|
name: Use '$>' from Relude
|
|
rhs: ($>)
|
|
- warn:
|
|
lhs: (Data.Functor.<&>)
|
|
note: Operator '(<&>)' is already exported from Relude
|
|
name: Use '<&>' from Relude
|
|
rhs: (<&>)
|
|
- warn:
|
|
lhs: Data.Functor.Compose.Compose
|
|
note: '''Compose'' is already exported from Relude'
|
|
name: Use 'Compose' from Relude
|
|
rhs: Compose
|
|
- warn:
|
|
lhs: Data.Functor.Compose.getCompose
|
|
note: '''getCompose'' is already exported from Relude'
|
|
name: Use 'getCompose' from Relude
|
|
rhs: getCompose
|
|
- warn:
|
|
lhs: Data.Functor.Identity.Identity
|
|
note: '''Identity'' is already exported from Relude'
|
|
name: Use 'Identity' from Relude
|
|
rhs: Identity
|
|
- warn:
|
|
lhs: Data.Functor.Identity.runIdentity
|
|
note: '''runIdentity'' is already exported from Relude'
|
|
name: Use 'runIdentity' from Relude
|
|
rhs: runIdentity
|
|
- warn:
|
|
lhs: Control.Concurrent.MVar.MVar
|
|
note: '''MVar'' is already exported from Relude'
|
|
name: Use 'MVar' from Relude
|
|
rhs: MVar
|
|
- warn:
|
|
lhs: Control.Concurrent.MVar.newEmptyMVar
|
|
note: '''newEmptyMVar'' is already exported from Relude'
|
|
name: Use 'newEmptyMVar' from Relude
|
|
rhs: newEmptyMVar
|
|
- warn:
|
|
lhs: Control.Concurrent.MVar.newMVar
|
|
note: '''newMVar'' is already exported from Relude'
|
|
name: Use 'newMVar' from Relude
|
|
rhs: newMVar
|
|
- warn:
|
|
lhs: Control.Concurrent.MVar.putMVar
|
|
note: '''putMVar'' is already exported from Relude'
|
|
name: Use 'putMVar' from Relude
|
|
rhs: putMVar
|
|
- warn:
|
|
lhs: Control.Concurrent.MVar.readMVar
|
|
note: '''readMVar'' is already exported from Relude'
|
|
name: Use 'readMVar' from Relude
|
|
rhs: readMVar
|
|
- warn:
|
|
lhs: Control.Concurrent.MVar.swapMVar
|
|
note: '''swapMVar'' is already exported from Relude'
|
|
name: Use 'swapMVar' from Relude
|
|
rhs: swapMVar
|
|
- warn:
|
|
lhs: Control.Concurrent.MVar.takeMVar
|
|
note: '''takeMVar'' is already exported from Relude'
|
|
name: Use 'takeMVar' from Relude
|
|
rhs: takeMVar
|
|
- warn:
|
|
lhs: Control.Concurrent.MVar.tryPutMVar
|
|
note: '''tryPutMVar'' is already exported from Relude'
|
|
name: Use 'tryPutMVar' from Relude
|
|
rhs: tryPutMVar
|
|
- warn:
|
|
lhs: Control.Concurrent.MVar.tryReadMVar
|
|
note: '''tryReadMVar'' is already exported from Relude'
|
|
name: Use 'tryReadMVar' from Relude
|
|
rhs: tryReadMVar
|
|
- warn:
|
|
lhs: Control.Concurrent.MVar.tryTakeMVar
|
|
note: '''tryTakeMVar'' is already exported from Relude'
|
|
name: Use 'tryTakeMVar' from Relude
|
|
rhs: tryTakeMVar
|
|
- warn:
|
|
lhs: Control.Monad.STM.STM
|
|
note: '''STM'' is already exported from Relude'
|
|
name: Use 'STM' from Relude
|
|
rhs: STM
|
|
- warn:
|
|
lhs: Control.Monad.STM.atomically
|
|
note: '''atomically'' is already exported from Relude'
|
|
name: Use 'atomically' from Relude
|
|
rhs: atomically
|
|
- warn:
|
|
lhs: Control.Concurrent.STM.TVar.TVar
|
|
note: '''TVar'' is already exported from Relude'
|
|
name: Use 'TVar' from Relude
|
|
rhs: TVar
|
|
- warn:
|
|
lhs: Control.Concurrent.STM.TVar.newTVarIO
|
|
note: '''newTVarIO'' is already exported from Relude'
|
|
name: Use 'newTVarIO' from Relude
|
|
rhs: newTVarIO
|
|
- warn:
|
|
lhs: Control.Concurrent.STM.TVar.readTVarIO
|
|
note: '''readTVarIO'' is already exported from Relude'
|
|
name: Use 'readTVarIO' from Relude
|
|
rhs: readTVarIO
|
|
- warn:
|
|
lhs: Control.Concurrent.STM.TVar.modifyTVar'
|
|
note: '''modifyTVar'''' is already exported from Relude'
|
|
name: Use 'modifyTVar'' from Relude
|
|
rhs: modifyTVar'
|
|
- warn:
|
|
lhs: Control.Concurrent.STM.TVar.newTVar
|
|
note: '''newTVar'' is already exported from Relude'
|
|
name: Use 'newTVar' from Relude
|
|
rhs: newTVar
|
|
- warn:
|
|
lhs: Control.Concurrent.STM.TVar.readTVar
|
|
note: '''readTVar'' is already exported from Relude'
|
|
name: Use 'readTVar' from Relude
|
|
rhs: readTVar
|
|
- warn:
|
|
lhs: Control.Concurrent.STM.TVar.writeTVar
|
|
note: '''writeTVar'' is already exported from Relude'
|
|
name: Use 'writeTVar' from Relude
|
|
rhs: writeTVar
|
|
- warn:
|
|
lhs: Data.IORef.IORef
|
|
note: '''IORef'' is already exported from Relude'
|
|
name: Use 'IORef' from Relude
|
|
rhs: IORef
|
|
- warn:
|
|
lhs: Data.IORef.atomicModifyIORef
|
|
note: '''atomicModifyIORef'' is already exported from Relude'
|
|
name: Use 'atomicModifyIORef' from Relude
|
|
rhs: atomicModifyIORef
|
|
- warn:
|
|
lhs: Data.IORef.atomicModifyIORef'
|
|
note: '''atomicModifyIORef'''' is already exported from Relude'
|
|
name: Use 'atomicModifyIORef'' from Relude
|
|
rhs: atomicModifyIORef'
|
|
- warn:
|
|
lhs: Data.IORef.atomicWriteIORef
|
|
note: '''atomicWriteIORef'' is already exported from Relude'
|
|
name: Use 'atomicWriteIORef' from Relude
|
|
rhs: atomicWriteIORef
|
|
- warn:
|
|
lhs: Data.IORef.modifyIORef
|
|
note: '''modifyIORef'' is already exported from Relude'
|
|
name: Use 'modifyIORef' from Relude
|
|
rhs: modifyIORef
|
|
- warn:
|
|
lhs: Data.IORef.modifyIORef'
|
|
note: '''modifyIORef'''' is already exported from Relude'
|
|
name: Use 'modifyIORef'' from Relude
|
|
rhs: modifyIORef'
|
|
- warn:
|
|
lhs: Data.IORef.newIORef
|
|
note: '''newIORef'' is already exported from Relude'
|
|
name: Use 'newIORef' from Relude
|
|
rhs: newIORef
|
|
- warn:
|
|
lhs: Data.IORef.readIORef
|
|
note: '''readIORef'' is already exported from Relude'
|
|
name: Use 'readIORef' from Relude
|
|
rhs: readIORef
|
|
- warn:
|
|
lhs: Data.IORef.writeIORef
|
|
note: '''writeIORef'' is already exported from Relude'
|
|
name: Use 'writeIORef' from Relude
|
|
rhs: writeIORef
|
|
- warn:
|
|
lhs: Data.Text.IO.getLine
|
|
note: '''getLine'' is already exported from Relude'
|
|
name: Use 'getLine' from Relude
|
|
rhs: getLine
|
|
- warn:
|
|
lhs: Data.List.genericDrop
|
|
note: '''genericDrop'' is already exported from Relude'
|
|
name: Use 'genericDrop' from Relude
|
|
rhs: genericDrop
|
|
- warn:
|
|
lhs: Data.List.genericLength
|
|
note: '''genericLength'' is already exported from Relude'
|
|
name: Use 'genericLength' from Relude
|
|
rhs: genericLength
|
|
- warn:
|
|
lhs: Data.List.genericReplicate
|
|
note: '''genericReplicate'' is already exported from Relude'
|
|
name: Use 'genericReplicate' from Relude
|
|
rhs: genericReplicate
|
|
- warn:
|
|
lhs: Data.List.genericSplitAt
|
|
note: '''genericSplitAt'' is already exported from Relude'
|
|
name: Use 'genericSplitAt' from Relude
|
|
rhs: genericSplitAt
|
|
- warn:
|
|
lhs: Data.List.genericTake
|
|
note: '''genericTake'' is already exported from Relude'
|
|
name: Use 'genericTake' from Relude
|
|
rhs: genericTake
|
|
- warn:
|
|
lhs: Data.List.group
|
|
note: '''group'' is already exported from Relude'
|
|
name: Use 'group' from Relude
|
|
rhs: group
|
|
- warn:
|
|
lhs: Data.List.inits
|
|
note: '''inits'' is already exported from Relude'
|
|
name: Use 'inits' from Relude
|
|
rhs: inits
|
|
- warn:
|
|
lhs: Data.List.intercalate
|
|
note: '''intercalate'' is already exported from Relude'
|
|
name: Use 'intercalate' from Relude
|
|
rhs: intercalate
|
|
- warn:
|
|
lhs: Data.List.intersperse
|
|
note: '''intersperse'' is already exported from Relude'
|
|
name: Use 'intersperse' from Relude
|
|
rhs: intersperse
|
|
- warn:
|
|
lhs: Data.List.isPrefixOf
|
|
note: '''isPrefixOf'' is already exported from Relude'
|
|
name: Use 'isPrefixOf' from Relude
|
|
rhs: isPrefixOf
|
|
- warn:
|
|
lhs: Data.List.permutations
|
|
note: '''permutations'' is already exported from Relude'
|
|
name: Use 'permutations' from Relude
|
|
rhs: permutations
|
|
- warn:
|
|
lhs: Data.List.sort
|
|
note: '''sort'' is already exported from Relude'
|
|
name: Use 'sort' from Relude
|
|
rhs: sort
|
|
- warn:
|
|
lhs: Data.List.sortBy
|
|
note: '''sortBy'' is already exported from Relude'
|
|
name: Use 'sortBy' from Relude
|
|
rhs: sortBy
|
|
- warn:
|
|
lhs: Data.List.sortOn
|
|
note: '''sortOn'' is already exported from Relude'
|
|
name: Use 'sortOn' from Relude
|
|
rhs: sortOn
|
|
- warn:
|
|
lhs: Data.List.subsequences
|
|
note: '''subsequences'' is already exported from Relude'
|
|
name: Use 'subsequences' from Relude
|
|
rhs: subsequences
|
|
- warn:
|
|
lhs: Data.List.tails
|
|
note: '''tails'' is already exported from Relude'
|
|
name: Use 'tails' from Relude
|
|
rhs: tails
|
|
- warn:
|
|
lhs: Data.List.transpose
|
|
note: '''transpose'' is already exported from Relude'
|
|
name: Use 'transpose' from Relude
|
|
rhs: transpose
|
|
- warn:
|
|
lhs: Data.List.uncons
|
|
note: '''uncons'' is already exported from Relude'
|
|
name: Use 'uncons' from Relude
|
|
rhs: uncons
|
|
- warn:
|
|
lhs: Data.List.unfoldr
|
|
note: '''unfoldr'' is already exported from Relude'
|
|
name: Use 'unfoldr' from Relude
|
|
rhs: unfoldr
|
|
- warn:
|
|
lhs: Data.List.NonEmpty.NonEmpty
|
|
note: '''NonEmpty'' is already exported from Relude'
|
|
name: Use 'NonEmpty' from Relude
|
|
rhs: NonEmpty
|
|
- warn:
|
|
lhs: (Data.List.NonEmpty.:|)
|
|
note: Operator '(:|)' is already exported from Relude
|
|
name: Use ':|' from Relude
|
|
rhs: (:|)
|
|
- warn:
|
|
lhs: Data.List.NonEmpty.nonEmpty
|
|
note: '''nonEmpty'' is already exported from Relude'
|
|
name: Use 'nonEmpty' from Relude
|
|
rhs: nonEmpty
|
|
- warn:
|
|
lhs: Data.List.NonEmpty.head
|
|
note: '''head'' is already exported from Relude'
|
|
name: Use 'head' from Relude
|
|
rhs: head
|
|
- warn:
|
|
lhs: Data.List.NonEmpty.init
|
|
note: '''init'' is already exported from Relude'
|
|
name: Use 'init' from Relude
|
|
rhs: init
|
|
- warn:
|
|
lhs: Data.List.NonEmpty.last
|
|
note: '''last'' is already exported from Relude'
|
|
name: Use 'last' from Relude
|
|
rhs: last
|
|
- warn:
|
|
lhs: Data.List.NonEmpty.tail
|
|
note: '''tail'' is already exported from Relude'
|
|
name: Use 'tail' from Relude
|
|
rhs: tail
|
|
- warn:
|
|
lhs: GHC.Exts.sortWith
|
|
note: '''sortWith'' is already exported from Relude'
|
|
name: Use 'sortWith' from Relude
|
|
rhs: sortWith
|
|
- warn:
|
|
lhs: Control.Monad.Except.ExceptT
|
|
note: '''ExceptT'' is already exported from Relude'
|
|
name: Use 'ExceptT' from Relude
|
|
rhs: ExceptT
|
|
- warn:
|
|
lhs: Control.Monad.Except.runExceptT
|
|
note: '''runExceptT'' is already exported from Relude'
|
|
name: Use 'runExceptT' from Relude
|
|
rhs: runExceptT
|
|
- warn:
|
|
lhs: Control.Monad.Reader.MonadReader
|
|
note: '''MonadReader'' is already exported from Relude'
|
|
name: Use 'MonadReader' from Relude
|
|
rhs: MonadReader
|
|
- warn:
|
|
lhs: Control.Monad.Reader.Reader
|
|
note: '''Reader'' is already exported from Relude'
|
|
name: Use 'Reader' from Relude
|
|
rhs: Reader
|
|
- warn:
|
|
lhs: Control.Monad.Reader.ReaderT
|
|
note: '''ReaderT'' is already exported from Relude'
|
|
name: Use 'ReaderT' from Relude
|
|
rhs: ReaderT
|
|
- warn:
|
|
lhs: Control.Monad.Reader.runReaderT
|
|
note: '''runReaderT'' is already exported from Relude'
|
|
name: Use 'runReaderT' from Relude
|
|
rhs: runReaderT
|
|
- warn:
|
|
lhs: Control.Monad.Reader.ask
|
|
note: '''ask'' is already exported from Relude'
|
|
name: Use 'ask' from Relude
|
|
rhs: ask
|
|
- warn:
|
|
lhs: Control.Monad.Reader.asks
|
|
note: '''asks'' is already exported from Relude'
|
|
name: Use 'asks' from Relude
|
|
rhs: asks
|
|
- warn:
|
|
lhs: Control.Monad.Reader.local
|
|
note: '''local'' is already exported from Relude'
|
|
name: Use 'local' from Relude
|
|
rhs: local
|
|
- warn:
|
|
lhs: Control.Monad.Reader.reader
|
|
note: '''reader'' is already exported from Relude'
|
|
name: Use 'reader' from Relude
|
|
rhs: reader
|
|
- warn:
|
|
lhs: Control.Monad.Reader.runReader
|
|
note: '''runReader'' is already exported from Relude'
|
|
name: Use 'runReader' from Relude
|
|
rhs: runReader
|
|
- warn:
|
|
lhs: Control.Monad.Reader.withReader
|
|
note: '''withReader'' is already exported from Relude'
|
|
name: Use 'withReader' from Relude
|
|
rhs: withReader
|
|
- warn:
|
|
lhs: Control.Monad.Reader.withReaderT
|
|
note: '''withReaderT'' is already exported from Relude'
|
|
name: Use 'withReaderT' from Relude
|
|
rhs: withReaderT
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.MonadState
|
|
note: '''MonadState'' is already exported from Relude'
|
|
name: Use 'MonadState' from Relude
|
|
rhs: MonadState
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.State
|
|
note: '''State'' is already exported from Relude'
|
|
name: Use 'State' from Relude
|
|
rhs: State
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.StateT
|
|
note: '''StateT'' is already exported from Relude'
|
|
name: Use 'StateT' from Relude
|
|
rhs: StateT
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.runStateT
|
|
note: '''runStateT'' is already exported from Relude'
|
|
name: Use 'runStateT' from Relude
|
|
rhs: runStateT
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.evalState
|
|
note: '''evalState'' is already exported from Relude'
|
|
name: Use 'evalState' from Relude
|
|
rhs: evalState
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.evalStateT
|
|
note: '''evalStateT'' is already exported from Relude'
|
|
name: Use 'evalStateT' from Relude
|
|
rhs: evalStateT
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.execState
|
|
note: '''execState'' is already exported from Relude'
|
|
name: Use 'execState' from Relude
|
|
rhs: execState
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.execStateT
|
|
note: '''execStateT'' is already exported from Relude'
|
|
name: Use 'execStateT' from Relude
|
|
rhs: execStateT
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.get
|
|
note: '''get'' is already exported from Relude'
|
|
name: Use 'get' from Relude
|
|
rhs: get
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.gets
|
|
note: '''gets'' is already exported from Relude'
|
|
name: Use 'gets' from Relude
|
|
rhs: gets
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.modify
|
|
note: '''modify'' is already exported from Relude'
|
|
name: Use 'modify' from Relude
|
|
rhs: modify
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.modify'
|
|
note: '''modify'''' is already exported from Relude'
|
|
name: Use 'modify'' from Relude
|
|
rhs: modify'
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.put
|
|
note: '''put'' is already exported from Relude'
|
|
name: Use 'put' from Relude
|
|
rhs: put
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.runState
|
|
note: '''runState'' is already exported from Relude'
|
|
name: Use 'runState' from Relude
|
|
rhs: runState
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.state
|
|
note: '''state'' is already exported from Relude'
|
|
name: Use 'state' from Relude
|
|
rhs: state
|
|
- warn:
|
|
lhs: Control.Monad.State.Strict.withState
|
|
note: '''withState'' is already exported from Relude'
|
|
name: Use 'withState' from Relude
|
|
rhs: withState
|
|
- warn:
|
|
lhs: Control.Monad.Trans.MonadIO
|
|
note: '''MonadIO'' is already exported from Relude'
|
|
name: Use 'MonadIO' from Relude
|
|
rhs: MonadIO
|
|
- warn:
|
|
lhs: Control.Monad.Trans.MonadTrans
|
|
note: '''MonadTrans'' is already exported from Relude'
|
|
name: Use 'MonadTrans' from Relude
|
|
rhs: MonadTrans
|
|
- warn:
|
|
lhs: Control.Monad.Trans.lift
|
|
note: '''lift'' is already exported from Relude'
|
|
name: Use 'lift' from Relude
|
|
rhs: lift
|
|
- warn:
|
|
lhs: Control.Monad.Trans.liftIO
|
|
note: '''liftIO'' is already exported from Relude'
|
|
name: Use 'liftIO' from Relude
|
|
rhs: liftIO
|
|
- warn:
|
|
lhs: Control.Monad.Trans.Identity.IdentityT
|
|
note: '''IdentityT'' is already exported from Relude'
|
|
name: Use 'IdentityT' from Relude
|
|
rhs: IdentityT
|
|
- warn:
|
|
lhs: Control.Monad.Trans.Identity.runIdentityT
|
|
note: '''runIdentityT'' is already exported from Relude'
|
|
name: Use 'runIdentityT' from Relude
|
|
rhs: runIdentityT
|
|
- warn:
|
|
lhs: Control.Monad.Trans.Maybe.MaybeT
|
|
note: '''MaybeT'' is already exported from Relude'
|
|
name: Use 'MaybeT' from Relude
|
|
rhs: MaybeT
|
|
- warn:
|
|
lhs: Control.Monad.Trans.Maybe.maybeToExceptT
|
|
note: '''maybeToExceptT'' is already exported from Relude'
|
|
name: Use 'maybeToExceptT' from Relude
|
|
rhs: maybeToExceptT
|
|
- warn:
|
|
lhs: Control.Monad.Trans.Maybe.exceptToMaybeT
|
|
note: '''exceptToMaybeT'' is already exported from Relude'
|
|
name: Use 'exceptToMaybeT' from Relude
|
|
rhs: exceptToMaybeT
|
|
- warn:
|
|
lhs: Control.Monad.MonadPlus
|
|
note: '''MonadPlus'' is already exported from Relude'
|
|
name: Use 'MonadPlus' from Relude
|
|
rhs: MonadPlus
|
|
- warn:
|
|
lhs: Control.Monad.mzero
|
|
note: '''mzero'' is already exported from Relude'
|
|
name: Use 'mzero' from Relude
|
|
rhs: mzero
|
|
- warn:
|
|
lhs: Control.Monad.mplus
|
|
note: '''mplus'' is already exported from Relude'
|
|
name: Use 'mplus' from Relude
|
|
rhs: mplus
|
|
- warn:
|
|
lhs: Control.Monad.filterM
|
|
note: '''filterM'' is already exported from Relude'
|
|
name: Use 'filterM' from Relude
|
|
rhs: filterM
|
|
- warn:
|
|
lhs: Control.Monad.forever
|
|
note: '''forever'' is already exported from Relude'
|
|
name: Use 'forever' from Relude
|
|
rhs: forever
|
|
- warn:
|
|
lhs: Control.Monad.join
|
|
note: '''join'' is already exported from Relude'
|
|
name: Use 'join' from Relude
|
|
rhs: join
|
|
- warn:
|
|
lhs: Control.Monad.mapAndUnzipM
|
|
note: '''mapAndUnzipM'' is already exported from Relude'
|
|
name: Use 'mapAndUnzipM' from Relude
|
|
rhs: mapAndUnzipM
|
|
- warn:
|
|
lhs: Control.Monad.mfilter
|
|
note: '''mfilter'' is already exported from Relude'
|
|
name: Use 'mfilter' from Relude
|
|
rhs: mfilter
|
|
- warn:
|
|
lhs: Control.Monad.replicateM
|
|
note: '''replicateM'' is already exported from Relude'
|
|
name: Use 'replicateM' from Relude
|
|
rhs: replicateM
|
|
- warn:
|
|
lhs: Control.Monad.replicateM_
|
|
note: '''replicateM_'' is already exported from Relude'
|
|
name: Use 'replicateM_' from Relude
|
|
rhs: replicateM_
|
|
- warn:
|
|
lhs: Control.Monad.zipWithM
|
|
note: '''zipWithM'' is already exported from Relude'
|
|
name: Use 'zipWithM' from Relude
|
|
rhs: zipWithM
|
|
- warn:
|
|
lhs: Control.Monad.zipWithM_
|
|
note: '''zipWithM_'' is already exported from Relude'
|
|
name: Use 'zipWithM_' from Relude
|
|
rhs: zipWithM_
|
|
- warn:
|
|
lhs: (Control.Monad.<$!>)
|
|
note: Operator '(<$!>)' is already exported from Relude
|
|
name: Use '<$!>' from Relude
|
|
rhs: (<$!>)
|
|
- warn:
|
|
lhs: (Control.Monad.<=<)
|
|
note: Operator '(<=<)' is already exported from Relude
|
|
name: Use '<=<' from Relude
|
|
rhs: (<=<)
|
|
- warn:
|
|
lhs: (Control.Monad.=<<)
|
|
note: Operator '(=<<)' is already exported from Relude
|
|
name: Use '=<<' from Relude
|
|
rhs: (=<<)
|
|
- warn:
|
|
lhs: (Control.Monad.>=>)
|
|
note: Operator '(>=>)' is already exported from Relude
|
|
name: Use '>=>' from Relude
|
|
rhs: (>=>)
|
|
- warn:
|
|
lhs: Control.Monad.Fail.MonadFail
|
|
note: '''MonadFail'' is already exported from Relude'
|
|
name: Use 'MonadFail' from Relude
|
|
rhs: MonadFail
|
|
- warn:
|
|
lhs: Data.Maybe.catMaybes
|
|
note: '''catMaybes'' is already exported from Relude'
|
|
name: Use 'catMaybes' from Relude
|
|
rhs: catMaybes
|
|
- warn:
|
|
lhs: Data.Maybe.fromMaybe
|
|
note: '''fromMaybe'' is already exported from Relude'
|
|
name: Use 'fromMaybe' from Relude
|
|
rhs: fromMaybe
|
|
- warn:
|
|
lhs: Data.Maybe.isJust
|
|
note: '''isJust'' is already exported from Relude'
|
|
name: Use 'isJust' from Relude
|
|
rhs: isJust
|
|
- warn:
|
|
lhs: Data.Maybe.isNothing
|
|
note: '''isNothing'' is already exported from Relude'
|
|
name: Use 'isNothing' from Relude
|
|
rhs: isNothing
|
|
- warn:
|
|
lhs: Data.Maybe.listToMaybe
|
|
note: '''listToMaybe'' is already exported from Relude'
|
|
name: Use 'listToMaybe' from Relude
|
|
rhs: listToMaybe
|
|
- warn:
|
|
lhs: Data.Maybe.mapMaybe
|
|
note: '''mapMaybe'' is already exported from Relude'
|
|
name: Use 'mapMaybe' from Relude
|
|
rhs: mapMaybe
|
|
- warn:
|
|
lhs: Data.Maybe.maybeToList
|
|
note: '''maybeToList'' is already exported from Relude'
|
|
name: Use 'maybeToList' from Relude
|
|
rhs: maybeToList
|
|
- warn:
|
|
lhs: Data.Either.isLeft
|
|
note: '''isLeft'' is already exported from Relude'
|
|
name: Use 'isLeft' from Relude
|
|
rhs: isLeft
|
|
- warn:
|
|
lhs: Data.Either.isRight
|
|
note: '''isRight'' is already exported from Relude'
|
|
name: Use 'isRight' from Relude
|
|
rhs: isRight
|
|
- warn:
|
|
lhs: Data.Either.lefts
|
|
note: '''lefts'' is already exported from Relude'
|
|
name: Use 'lefts' from Relude
|
|
rhs: lefts
|
|
- warn:
|
|
lhs: Data.Either.partitionEithers
|
|
note: '''partitionEithers'' is already exported from Relude'
|
|
name: Use 'partitionEithers' from Relude
|
|
rhs: partitionEithers
|
|
- warn:
|
|
lhs: Data.Either.rights
|
|
note: '''rights'' is already exported from Relude'
|
|
name: Use 'rights' from Relude
|
|
rhs: rights
|
|
- warn:
|
|
lhs: Data.Monoid.All
|
|
note: '''All'' is already exported from Relude'
|
|
name: Use 'All' from Relude
|
|
rhs: All
|
|
- warn:
|
|
lhs: Data.Monoid.getAll
|
|
note: '''getAll'' is already exported from Relude'
|
|
name: Use 'getAll' from Relude
|
|
rhs: getAll
|
|
- warn:
|
|
lhs: Data.Monoid.Alt
|
|
note: '''Alt'' is already exported from Relude'
|
|
name: Use 'Alt' from Relude
|
|
rhs: Alt
|
|
- warn:
|
|
lhs: Data.Monoid.getAlt
|
|
note: '''getAlt'' is already exported from Relude'
|
|
name: Use 'getAlt' from Relude
|
|
rhs: getAlt
|
|
- warn:
|
|
lhs: Data.Monoid.Any
|
|
note: '''Any'' is already exported from Relude'
|
|
name: Use 'Any' from Relude
|
|
rhs: Any
|
|
- warn:
|
|
lhs: Data.Monoid.getAny
|
|
note: '''getAny'' is already exported from Relude'
|
|
name: Use 'getAny' from Relude
|
|
rhs: getAny
|
|
- warn:
|
|
lhs: Data.Monoid.Ap
|
|
note: '''Ap'' is already exported from Relude'
|
|
name: Use 'Ap' from Relude
|
|
rhs: Ap
|
|
- warn:
|
|
lhs: Data.Monoid.getAp
|
|
note: '''getAp'' is already exported from Relude'
|
|
name: Use 'getAp' from Relude
|
|
rhs: getAp
|
|
- warn:
|
|
lhs: Data.Monoid.Dual
|
|
note: '''Dual'' is already exported from Relude'
|
|
name: Use 'Dual' from Relude
|
|
rhs: Dual
|
|
- warn:
|
|
lhs: Data.Monoid.getDual
|
|
note: '''getDual'' is already exported from Relude'
|
|
name: Use 'getDual' from Relude
|
|
rhs: getDual
|
|
- warn:
|
|
lhs: Data.Monoid.Endo
|
|
note: '''Endo'' is already exported from Relude'
|
|
name: Use 'Endo' from Relude
|
|
rhs: Endo
|
|
- warn:
|
|
lhs: Data.Monoid.appEndo
|
|
note: '''appEndo'' is already exported from Relude'
|
|
name: Use 'appEndo' from Relude
|
|
rhs: appEndo
|
|
- warn:
|
|
lhs: Data.Monoid.First
|
|
note: '''First'' is already exported from Relude'
|
|
name: Use 'First' from Relude
|
|
rhs: First
|
|
- warn:
|
|
lhs: Data.Monoid.getFirst
|
|
note: '''getFirst'' is already exported from Relude'
|
|
name: Use 'getFirst' from Relude
|
|
rhs: getFirst
|
|
- warn:
|
|
lhs: Data.Monoid.Last
|
|
note: '''Last'' is already exported from Relude'
|
|
name: Use 'Last' from Relude
|
|
rhs: Last
|
|
- warn:
|
|
lhs: Data.Monoid.getLast
|
|
note: '''getLast'' is already exported from Relude'
|
|
name: Use 'getLast' from Relude
|
|
rhs: getLast
|
|
- warn:
|
|
lhs: Data.Monoid.Product
|
|
note: '''Product'' is already exported from Relude'
|
|
name: Use 'Product' from Relude
|
|
rhs: Product
|
|
- warn:
|
|
lhs: Data.Monoid.getProduct
|
|
note: '''getProduct'' is already exported from Relude'
|
|
name: Use 'getProduct' from Relude
|
|
rhs: getProduct
|
|
- warn:
|
|
lhs: Data.Monoid.Sum
|
|
note: '''Sum'' is already exported from Relude'
|
|
name: Use 'Sum' from Relude
|
|
rhs: Sum
|
|
- warn:
|
|
lhs: Data.Monoid.getSum
|
|
note: '''getSum'' is already exported from Relude'
|
|
name: Use 'getSum' from Relude
|
|
rhs: getSum
|
|
- warn:
|
|
lhs: Data.Semigroup.Option
|
|
note: '''Option'' is already exported from Relude'
|
|
name: Use 'Option' from Relude
|
|
rhs: Option
|
|
- warn:
|
|
lhs: Data.Semigroup.getOption
|
|
note: '''getOption'' is already exported from Relude'
|
|
name: Use 'getOption' from Relude
|
|
rhs: getOption
|
|
- warn:
|
|
lhs: Data.Semigroup.Semigroup
|
|
note: '''Semigroup'' is already exported from Relude'
|
|
name: Use 'Semigroup' from Relude
|
|
rhs: Semigroup
|
|
- warn:
|
|
lhs: Data.Semigroup.sconcat
|
|
note: '''sconcat'' is already exported from Relude'
|
|
name: Use 'sconcat' from Relude
|
|
rhs: sconcat
|
|
- warn:
|
|
lhs: Data.Semigroup.stimes
|
|
note: '''stimes'' is already exported from Relude'
|
|
name: Use 'stimes' from Relude
|
|
rhs: stimes
|
|
- warn:
|
|
lhs: (Data.Semigroup.<>)
|
|
note: Operator '(<>)' is already exported from Relude
|
|
name: Use '<>' from Relude
|
|
rhs: (<>)
|
|
- warn:
|
|
lhs: Data.Semigroup.WrappedMonoid
|
|
note: '''WrappedMonoid'' is already exported from Relude'
|
|
name: Use 'WrappedMonoid' from Relude
|
|
rhs: WrappedMonoid
|
|
- warn:
|
|
lhs: Data.Semigroup.cycle1
|
|
note: '''cycle1'' is already exported from Relude'
|
|
name: Use 'cycle1' from Relude
|
|
rhs: cycle1
|
|
- warn:
|
|
lhs: Data.Semigroup.mtimesDefault
|
|
note: '''mtimesDefault'' is already exported from Relude'
|
|
name: Use 'mtimesDefault' from Relude
|
|
rhs: mtimesDefault
|
|
- warn:
|
|
lhs: Data.Semigroup.stimesIdempotent
|
|
note: '''stimesIdempotent'' is already exported from Relude'
|
|
name: Use 'stimesIdempotent' from Relude
|
|
rhs: stimesIdempotent
|
|
- warn:
|
|
lhs: Data.Semigroup.stimesIdempotentMonoid
|
|
note: '''stimesIdempotentMonoid'' is already exported from Relude'
|
|
name: Use 'stimesIdempotentMonoid' from Relude
|
|
rhs: stimesIdempotentMonoid
|
|
- warn:
|
|
lhs: Data.Semigroup.stimesMonoid
|
|
note: '''stimesMonoid'' is already exported from Relude'
|
|
name: Use 'stimesMonoid' from Relude
|
|
rhs: stimesMonoid
|
|
- warn:
|
|
lhs: Data.ByteString.ByteString
|
|
note: '''ByteString'' is already exported from Relude'
|
|
name: Use 'ByteString' from Relude
|
|
rhs: ByteString
|
|
- warn:
|
|
lhs: Data.ByteString.Short.ShortByteString
|
|
note: '''ShortByteString'' is already exported from Relude'
|
|
name: Use 'ShortByteString' from Relude
|
|
rhs: ShortByteString
|
|
- warn:
|
|
lhs: Data.ByteString.Short.toShort
|
|
note: '''toShort'' is already exported from Relude'
|
|
name: Use 'toShort' from Relude
|
|
rhs: toShort
|
|
- warn:
|
|
lhs: Data.ByteString.Short.fromShort
|
|
note: '''fromShort'' is already exported from Relude'
|
|
name: Use 'fromShort' from Relude
|
|
rhs: fromShort
|
|
- warn:
|
|
lhs: Data.String.IsString
|
|
note: '''IsString'' is already exported from Relude'
|
|
name: Use 'IsString' from Relude
|
|
rhs: IsString
|
|
- warn:
|
|
lhs: Data.String.fromString
|
|
note: '''fromString'' is already exported from Relude'
|
|
name: Use 'fromString' from Relude
|
|
rhs: fromString
|
|
- warn:
|
|
lhs: Data.Text.Text
|
|
note: '''Text'' is already exported from Relude'
|
|
name: Use 'Text' from Relude
|
|
rhs: Text
|
|
- warn:
|
|
lhs: Data.Text.lines
|
|
note: '''lines'' is already exported from Relude'
|
|
name: Use 'lines' from Relude
|
|
rhs: lines
|
|
- warn:
|
|
lhs: Data.Text.unlines
|
|
note: '''unlines'' is already exported from Relude'
|
|
name: Use 'unlines' from Relude
|
|
rhs: unlines
|
|
- warn:
|
|
lhs: Data.Text.words
|
|
note: '''words'' is already exported from Relude'
|
|
name: Use 'words' from Relude
|
|
rhs: words
|
|
- warn:
|
|
lhs: Data.Text.unwords
|
|
note: '''unwords'' is already exported from Relude'
|
|
name: Use 'unwords' from Relude
|
|
rhs: unwords
|
|
- warn:
|
|
lhs: Data.Text.Encoding.decodeUtf8'
|
|
note: '''decodeUtf8'''' is already exported from Relude'
|
|
name: Use 'decodeUtf8'' from Relude
|
|
rhs: decodeUtf8'
|
|
- warn:
|
|
lhs: Data.Text.Encoding.decodeUtf8With
|
|
note: '''decodeUtf8With'' is already exported from Relude'
|
|
name: Use 'decodeUtf8With' from Relude
|
|
rhs: decodeUtf8With
|
|
- warn:
|
|
lhs: Data.Text.Encoding.Error.OnDecodeError
|
|
note: '''OnDecodeError'' is already exported from Relude'
|
|
name: Use 'OnDecodeError' from Relude
|
|
rhs: OnDecodeError
|
|
- warn:
|
|
lhs: Data.Text.Encoding.Error.OnError
|
|
note: '''OnError'' is already exported from Relude'
|
|
name: Use 'OnError' from Relude
|
|
rhs: OnError
|
|
- warn:
|
|
lhs: Data.Text.Encoding.Error.UnicodeException
|
|
note: '''UnicodeException'' is already exported from Relude'
|
|
name: Use 'UnicodeException' from Relude
|
|
rhs: UnicodeException
|
|
- warn:
|
|
lhs: Data.Text.Encoding.Error.lenientDecode
|
|
note: '''lenientDecode'' is already exported from Relude'
|
|
name: Use 'lenientDecode' from Relude
|
|
rhs: lenientDecode
|
|
- warn:
|
|
lhs: Data.Text.Encoding.Error.strictDecode
|
|
note: '''strictDecode'' is already exported from Relude'
|
|
name: Use 'strictDecode' from Relude
|
|
rhs: strictDecode
|
|
- warn:
|
|
lhs: Text.Read.Read
|
|
note: '''Read'' is already exported from Relude'
|
|
name: Use 'Read' from Relude
|
|
rhs: Read
|
|
- warn:
|
|
lhs: Text.Read.readMaybe
|
|
note: '''readMaybe'' is already exported from Relude'
|
|
name: Use 'readMaybe' from Relude
|
|
rhs: readMaybe
|
|
- warn:
|
|
lhs: (liftIO (newEmptyMVar ))
|
|
note: If you import 'newEmptyMVar' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: newEmptyMVar
|
|
- warn:
|
|
lhs: (liftIO (newMVar x))
|
|
note: If you import 'newMVar' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: newMVar
|
|
- warn:
|
|
lhs: (liftIO (putMVar x y))
|
|
note: If you import 'putMVar' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: putMVar
|
|
- warn:
|
|
lhs: (liftIO (readMVar x))
|
|
note: If you import 'readMVar' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: readMVar
|
|
- warn:
|
|
lhs: (liftIO (swapMVar x y))
|
|
note: If you import 'swapMVar' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: swapMVar
|
|
- warn:
|
|
lhs: (liftIO (takeMVar x))
|
|
note: If you import 'takeMVar' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: takeMVar
|
|
- warn:
|
|
lhs: (liftIO (tryPutMVar x y))
|
|
note: If you import 'tryPutMVar' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: tryPutMVar
|
|
- warn:
|
|
lhs: (liftIO (tryReadMVar x))
|
|
note: If you import 'tryReadMVar' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: tryReadMVar
|
|
- warn:
|
|
lhs: (liftIO (tryTakeMVar x))
|
|
note: If you import 'tryTakeMVar' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: tryTakeMVar
|
|
- warn:
|
|
lhs: (liftIO (atomically x))
|
|
note: If you import 'atomically' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: atomically
|
|
- warn:
|
|
lhs: (liftIO (newTVarIO x))
|
|
note: If you import 'newTVarIO' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: newTVarIO
|
|
- warn:
|
|
lhs: (liftIO (readTVarIO x))
|
|
note: If you import 'readTVarIO' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: readTVarIO
|
|
- warn:
|
|
lhs: (liftIO (exitWith x))
|
|
note: If you import 'exitWith' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: exitWith
|
|
- warn:
|
|
lhs: (liftIO (exitFailure ))
|
|
note: If you import 'exitFailure' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: exitFailure
|
|
- warn:
|
|
lhs: (liftIO (exitSuccess ))
|
|
note: If you import 'exitSuccess' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: exitSuccess
|
|
- warn:
|
|
lhs: (liftIO (die x))
|
|
note: If you import 'die' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: die
|
|
- warn:
|
|
lhs: (liftIO (readFile x))
|
|
note: If you import 'readFile' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: readFile
|
|
- warn:
|
|
lhs: (liftIO (writeFile x y))
|
|
note: If you import 'writeFile' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: writeFile
|
|
- warn:
|
|
lhs: (liftIO (appendFile x y))
|
|
note: If you import 'appendFile' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: appendFile
|
|
- warn:
|
|
lhs: (liftIO (readFileText x))
|
|
note: If you import 'readFileText' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: readFileText
|
|
- warn:
|
|
lhs: (liftIO (writeFileText x y))
|
|
note: If you import 'writeFileText' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: writeFileText
|
|
- warn:
|
|
lhs: (liftIO (appendFileText x y))
|
|
note: If you import 'appendFileText' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: appendFileText
|
|
- warn:
|
|
lhs: (liftIO (readFileLText x))
|
|
note: If you import 'readFileLText' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: readFileLText
|
|
- warn:
|
|
lhs: (liftIO (writeFileLText x y))
|
|
note: If you import 'writeFileLText' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: writeFileLText
|
|
- warn:
|
|
lhs: (liftIO (appendFileLText x y))
|
|
note: If you import 'appendFileLText' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: appendFileLText
|
|
- warn:
|
|
lhs: (liftIO (readFileBS x))
|
|
note: If you import 'readFileBS' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: readFileBS
|
|
- warn:
|
|
lhs: (liftIO (writeFileBS x y))
|
|
note: If you import 'writeFileBS' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: writeFileBS
|
|
- warn:
|
|
lhs: (liftIO (appendFileBS x y))
|
|
note: If you import 'appendFileBS' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: appendFileBS
|
|
- warn:
|
|
lhs: (liftIO (readFileLBS x))
|
|
note: If you import 'readFileLBS' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: readFileLBS
|
|
- warn:
|
|
lhs: (liftIO (writeFileLBS x y))
|
|
note: If you import 'writeFileLBS' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: writeFileLBS
|
|
- warn:
|
|
lhs: (liftIO (appendFileLBS x y))
|
|
note: If you import 'appendFileLBS' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: appendFileLBS
|
|
- warn:
|
|
lhs: (liftIO (newIORef x))
|
|
note: If you import 'newIORef' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: newIORef
|
|
- warn:
|
|
lhs: (liftIO (readIORef x))
|
|
note: If you import 'readIORef' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: readIORef
|
|
- warn:
|
|
lhs: (liftIO (writeIORef x y))
|
|
note: If you import 'writeIORef' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: writeIORef
|
|
- warn:
|
|
lhs: (liftIO (modifyIORef x y))
|
|
note: If you import 'modifyIORef' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: modifyIORef
|
|
- warn:
|
|
lhs: (liftIO (modifyIORef' x y))
|
|
note: If you import 'modifyIORef'' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: modifyIORef'
|
|
- warn:
|
|
lhs: (liftIO (atomicModifyIORef x y))
|
|
note: If you import 'atomicModifyIORef' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: atomicModifyIORef
|
|
- warn:
|
|
lhs: (liftIO (atomicModifyIORef' x y))
|
|
note: If you import 'atomicModifyIORef'' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: atomicModifyIORef'
|
|
- warn:
|
|
lhs: (liftIO (atomicWriteIORef x y))
|
|
note: If you import 'atomicWriteIORef' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: atomicWriteIORef
|
|
- warn:
|
|
lhs: (liftIO (getLine ))
|
|
note: If you import 'getLine' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: getLine
|
|
- warn:
|
|
lhs: (liftIO (print x))
|
|
note: If you import 'print' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: print
|
|
- warn:
|
|
lhs: (liftIO (putStr x))
|
|
note: If you import 'putStr' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: putStr
|
|
- warn:
|
|
lhs: (liftIO (putStrLn x))
|
|
note: If you import 'putStrLn' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: putStrLn
|
|
- warn:
|
|
lhs: (liftIO (putText x))
|
|
note: If you import 'putText' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: putText
|
|
- warn:
|
|
lhs: (liftIO (putTextLn x))
|
|
note: If you import 'putTextLn' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: putTextLn
|
|
- warn:
|
|
lhs: (liftIO (putLText x))
|
|
note: If you import 'putLText' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: putLText
|
|
- warn:
|
|
lhs: (liftIO (putLTextLn x))
|
|
note: If you import 'putLTextLn' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: putLTextLn
|
|
- warn:
|
|
lhs: (liftIO (putBS x))
|
|
note: If you import 'putBS' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: putBS
|
|
- warn:
|
|
lhs: (liftIO (putBSLn x))
|
|
note: If you import 'putBSLn' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: putBSLn
|
|
- warn:
|
|
lhs: (liftIO (putLBS x))
|
|
note: If you import 'putLBS' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: putLBS
|
|
- warn:
|
|
lhs: (liftIO (putLBSLn x))
|
|
note: If you import 'putLBSLn' from Relude, it's already lifted
|
|
name: '''liftIO'' is not needed'
|
|
rhs: putLBSLn
|
|
- hint:
|
|
lhs: fmap (bimap f g)
|
|
note: Use `bimapF` from `Relude.Extra.Bifunctor`
|
|
rhs: bimapF f g
|
|
- hint:
|
|
lhs: bimap f g <$> x
|
|
note: Use `bimapF` from `Relude.Extra.Bifunctor`
|
|
rhs: bimapF f g x
|
|
- hint:
|
|
lhs: fmap (first f)
|
|
note: Use `firstF` from `Relude.Extra.Bifunctor`
|
|
rhs: firstF f
|
|
- hint:
|
|
lhs: fmap . first
|
|
note: Use `firstF` from `Relude.Extra.Bifunctor`
|
|
rhs: firstF
|
|
- hint:
|
|
lhs: fmap (second f)
|
|
note: Use `secondF` from `Relude.Extra.Bifunctor`
|
|
rhs: secondF f
|
|
- hint:
|
|
lhs: fmap . second
|
|
note: Use `secondF` from `Relude.Extra.Bifunctor`
|
|
rhs: secondF
|
|
- hint:
|
|
lhs: '[minBound .. maxBound]'
|
|
note: Use `universe` from `Relude.Extra.Enum`
|
|
rhs: universe
|
|
- hint:
|
|
lhs: succ
|
|
note: '`succ` from `Prelude` is a pure function but it may throw exception. Consider
|
|
using `next` from `Relude.Extra.Enum` instead.'
|
|
rhs: next
|
|
- hint:
|
|
lhs: pred
|
|
note: '`pred` from `Prelude` is a pure function but it may throw exception. Consider
|
|
using `prev` from `Relude.Extra.Enum` instead.'
|
|
rhs: prev
|
|
- hint:
|
|
lhs: toEnum
|
|
note: '`toEnum` from `Prelude` is a pure function but it may throw exception.
|
|
Consider using `safeToEnum` from `Relude.Extra.Enum` instead.'
|
|
rhs: safeToEnum
|
|
- hint:
|
|
lhs: fmap (,a) (f a)
|
|
note: Use `traverseToFst` from `Relude.Extra.Tuple`
|
|
rhs: traverseToFst f a
|
|
- hint:
|
|
lhs: fmap (flip (,) a) (f a)
|
|
note: Use `traverseToFst` from `Relude.Extra.Tuple`
|
|
rhs: traverseToFst f a
|
|
- hint:
|
|
lhs: (,a) <$> f a
|
|
note: Use `traverseToFst` from `Relude.Extra.Tuple`
|
|
rhs: traverseToFst f a
|
|
- hint:
|
|
lhs: flip (,) a <$> f a
|
|
note: Use `traverseToFst` from `Relude.Extra.Tuple`
|
|
rhs: traverseToFst f a
|
|
- hint:
|
|
lhs: fmap (a,) (f a)
|
|
note: Use `traverseToSnd` from `Relude.Extra.Tuple`
|
|
rhs: traverseToSnd f a
|
|
- hint:
|
|
lhs: fmap ((,) a) (f a)
|
|
note: Use `traverseToSnd` from `Relude.Extra.Tuple`
|
|
rhs: traverseToSnd f a
|
|
- hint:
|
|
lhs: (a,) <$> f a
|
|
note: Use `traverseToSnd` from `Relude.Extra.Tuple`
|
|
rhs: traverseToSnd f a
|
|
- hint:
|
|
lhs: (,) a <$> f a
|
|
note: Use `traverseToSnd` from `Relude.Extra.Tuple`
|
|
rhs: traverseToSnd f a
|