Created
February 17, 2021 03:30
-
-
Save seagreen/414897bad0e1abee242636eb19c5e64f to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| src/EasyTest.hs:213:1: error: bool is unused | |
| 211 ┃ | |
| 212 ┃ bool :: Test Bool | |
| 213 ┃ bool = random | |
| 214 ┃ | |
| 215 ┃ word8 :: Test Word8 | |
| Delete this definition or add ‘EasyTest.bool’ as a root to fix this error. | |
| src/EasyTest.hs:220:1: error: char is unused | |
| 218 ┃ -- | Generate a random `Char` | |
| 219 ┃ char :: Test Char | |
| 220 ┃ char = random | |
| 221 ┃ | |
| 222 ┃ -- | Generate a random `Int` | |
| Delete this definition or add ‘EasyTest.char’ as a root to fix this error. | |
| src/EasyTest.hs:242:1: error: char' is unused | |
| 240 ┃ -- Note: `char' 'a' 'z'` includes both `'a'` and `'z'`. | |
| 241 ┃ char' :: Char -> Char -> Test Char | |
| 242 ┃ char' = random' | |
| 243 ┃ | |
| 244 ┃ -- | Generate a random `Double` in the given range | |
| Delete this definition or add ‘EasyTest.char'’ as a root to fix this error. | |
| src/EasyTest.hs:228:1: error: double is unused | |
| 226 ┃ -- | Generate a random `Double` | |
| 227 ┃ double :: Test Double | |
| 228 ┃ double = random | |
| 229 ┃ | |
| 230 ┃ -- | Generate a random `Word` | |
| Delete this definition or add ‘EasyTest.double’ as a root to fix this error. | |
| src/EasyTest.hs:247:1: error: double' is unused | |
| 245 ┃ -- Note: `double' 0 1` includes both `0` and `1`. | |
| 246 ┃ double' :: Double -> Double -> Test Double | |
| 247 ┃ double' = random' | |
| 248 ┃ | |
| 249 ┃ -- | Generate a random `Double` in the given range | |
| Delete this definition or add ‘EasyTest.double'’ as a root to fix this error. | |
| src/EasyTest.hs:72:1: error: expectJust is unused | |
| 70 ┃ | |
| 71 ┃ expectJust :: HasCallStack => Maybe a -> Test a | |
| 72 ┃ expectJust Nothing = crash "expected Just, got Nothing" | |
| 73 ┃ expectJust (Just a) = ok >> pure a | |
| 74 ┃ | |
| Delete this definition or add ‘EasyTest.expectJust’ as a root to fix this error. | |
| src/EasyTest.hs:76:1: error: expectRight is unused | |
| 74 ┃ | |
| 75 ┃ expectRight :: HasCallStack => Either e a -> Test a | |
| 76 ┃ expectRight (Left _) = crash "expected Right, got Left" | |
| 77 ┃ expectRight (Right a) = ok >> pure a | |
| 78 ┃ | |
| Delete this definition or add ‘EasyTest.expectRight’ as a root to fix this error. | |
| src/EasyTest.hs:439:1: error: fork is unused | |
| 437 ┃ -- | Run a test in a separate thread, not blocking for its result. | |
| 438 ┃ fork :: Test a -> Test () | |
| 439 ┃ fork t = void (fork' t) | |
| 440 ┃ | |
| 441 ┃ -- | Run a test in a separate thread, return a future which can be used | |
| Delete this definition or add ‘EasyTest.fork’ as a root to fix this error. | |
| src/EasyTest.hs:444:1: error: fork' is unused | |
| 442 ┃ -- to block on its result. | |
| 443 ┃ fork' :: Test a -> Test (Test a) | |
| 444 ┃ fork' (Test t) = do | |
| 445 ┃ env <- ask | |
| 446 ┃ tmvar <- liftIO newEmptyTMVarIO | |
| Delete this definition or add ‘EasyTest.fork'’ as a root to fix this error. | |
| src/EasyTest.hs:224:1: error: int is unused | |
| 222 ┃ -- | Generate a random `Int` | |
| 223 ┃ int :: Test Int | |
| 224 ┃ int = random | |
| 225 ┃ | |
| 226 ┃ -- | Generate a random `Double` | |
| Delete this definition or add ‘EasyTest.int’ as a root to fix this error. | |
| src/EasyTest.hs:292:1: error: mapOf is unused | |
| 290 ┃ -- | Generate a `Data.Map k v` of the given size. | |
| 291 ┃ mapOf :: Ord k => Int -> Test k -> Test v -> Test (Map k v) | |
| 292 ┃ mapOf n k v = Map.fromList <$> listOf n (pair k v) | |
| 293 ┃ | |
| 294 ┃ -- | Generate a `[Data.Map k v]` of the given sizes. | |
| Delete this definition or add ‘EasyTest.mapOf’ as a root to fix this error. | |
| src/EasyTest.hs:296:1: error: mapsOf is unused | |
| 294 ┃ -- | Generate a `[Data.Map k v]` of the given sizes. | |
| 295 ┃ mapsOf :: Ord k => [Int] -> Test k -> Test v -> Test [Map k v] | |
| 296 ┃ mapsOf sizes k v = sizes `forM` \n -> mapOf n k v | |
| 297 ┃ | |
| 298 ┃ -- | Catch all exceptions that could occur in the given `Test` | |
| Delete this definition or add ‘EasyTest.mapsOf’ as a root to fix this error. | |
| src/EasyTest.hs:190:1: error: note' is unused | |
| 188 ┃ -- | Log a showable value | |
| 189 ┃ note' :: Show s => s -> Test () | |
| 190 ┃ note' = note . show | |
| 191 ┃ | |
| 192 ┃ -- | Generate a random value | |
| Delete this definition or add ‘EasyTest.note'’ as a root to fix this error. | |
| src/EasyTest.hs:288:1: error: pair is unused | |
| 286 ┃ -- | Alias for `liftA2 (,)`. | |
| 287 ┃ pair :: Test a -> Test b -> Test (a,b) | |
| 288 ┃ pair = liftA2 (,) | |
| 289 ┃ | |
| 290 ┃ -- | Generate a `Data.Map k v` of the given size. | |
| Delete this definition or add ‘EasyTest.pair’ as a root to fix this error. | |
| src/EasyTest.hs:103:1: error: rerun is unused | |
| 101 ┃ | |
| 102 ┃ rerun :: Int -> Test a -> IO () | |
| 103 ┃ rerun seed = rerunOnly seed [] | |
| 104 ┃ | |
| 105 ┃ run' :: Int -> (String -> IO ()) -> String -> Test a -> IO () | |
| Delete this definition or add ‘EasyTest.rerun’ as a root to fix this error. | |
| src/EasyTest.hs:344:1: error: skip is unused | |
| 342 ┃ -- | Explicitly skip this test | |
| 343 ┃ skip :: Test () | |
| 344 ┃ skip = Test (Nothing <$ putResult Skipped) | |
| 345 ┃ | |
| 346 ┃ -- | Record a failure at the current scope | |
| Delete this definition or add ‘EasyTest.skip’ as a root to fix this error. | |
| src/EasyTest.hs:316:1: error: using is unused | |
| 314 ┃ -- | A test with a setup and teardown | |
| 315 ┃ using :: IO r -> (r -> IO ()) -> (r -> Test a) -> Test a | |
| 316 ┃ using r cleanup use = Test $ do | |
| 317 ┃ r <- liftIO r | |
| 318 ┃ env <- ask | |
| Delete this definition or add ‘EasyTest.using’ as a root to fix this error. | |
| src/EasyTest.hs:232:1: error: word is unused | |
| 230 ┃ -- | Generate a random `Word` | |
| 231 ┃ word :: Test Word | |
| 232 ┃ word = random | |
| 233 ┃ | |
| 234 ┃ -- | Generate a random `Int` in the given range | |
| Delete this definition or add ‘EasyTest.word’ as a root to fix this error. | |
| src/EasyTest.hs:252:1: error: word' is unused | |
| 250 ┃ -- Note: `word' 0 10` includes both `0` and `10`. | |
| 251 ┃ word' :: Word -> Word -> Test Word | |
| 252 ┃ word' = random' | |
| 253 ┃ | |
| 254 ┃ -- | Generate a random `Double` in the given range | |
| Delete this definition or add ‘EasyTest.word'’ as a root to fix this error. | |
| src/EasyTest.hs:257:1: error: word8' is unused | |
| 255 ┃ -- Note: `word8' 0 10` includes both `0` and `10`. | |
| 256 ┃ word8' :: Word8 -> Word8 -> Test Word8 | |
| 257 ┃ word8' = random' | |
| 258 ┃ | |
| 259 ┃ -- | Sample uniformly from the given list of possibilities | |
| Delete this definition or add ‘EasyTest.word8'’ as a root to fix this error. | |
| src/Unison/ABT.hs:206:1: error: absr is unused | |
| 204 ┃ | |
| 205 ┃ absr :: (Functor f, Foldable f, Var v) => v -> Term f (V v) () -> Term f (V v) () | |
| 206 ┃ absr = absr' () | |
| 207 ┃ | |
| 208 ┃ -- | Rebuild an `abs`, renaming `v` to avoid capturing any `Free v` in `body`. | |
| Delete this definition or add ‘Unison.ABT.absr’ as a root to fix this error. | |
| src/Unison/ABT.hs:210:1: error: absr' is unused | |
| 208 ┃ -- | Rebuild an `abs`, renaming `v` to avoid capturing any `Free v` in `body`. | |
| 209 ┃ absr' :: (Functor f, Foldable f, Var v) => a -> v -> Term f (V v) a -> Term f (V v) a | |
| 210 ┃ absr' a v body = wrap' v body $ \v body -> abs' a v body | |
| 211 ┃ | |
| 212 ┃ absChain :: Ord v => [v] -> Term f v () -> Term f v () | |
| Delete this definition or add ‘Unison.ABT.absr'’ as a root to fix this error. | |
| src/Unison/ABT.hs:77:1: error: at is unused | |
| 75 ┃ | |
| 76 ┃ at :: Path s t a b m -> s -> Maybe a | |
| 77 ┃ at p s = (\(a,_,_) -> a) <$> focus p s | |
| 78 ┃ | |
| 79 ┃ modify' :: Path s t a b m -> (m -> a -> b) -> s -> Maybe t | |
| Delete this definition or add ‘Unison.ABT.at’ as a root to fix this error. | |
| src/Unison/ABT.hs:122:1: error: bound is unused | |
| 120 ┃ -- | Return the set of all variables bound by this ABT | |
| 121 ┃ bound :: (Ord v, Foldable f) => Term f v a -> Set v | |
| 122 ┃ bound t = Set.fromList (bound' t) | |
| 123 ┃ | |
| 124 ┃ -- | `True` if the term has no free variables, `False` otherwise | |
| Delete this definition or add ‘Unison.ABT.bound’ as a root to fix this error. | |
| src/Unison/ABT.hs:94:1: error: bound' is unused | |
| 92 ┃ -- | Return the list of all variables bound by this ABT | |
| 93 ┃ bound' :: Foldable f => Term f v a -> [v] | |
| 94 ┃ bound' t = case out t of | |
| 95 ┃ Abs v t -> v : bound' t | |
| 96 ┃ Cycle t -> bound' t | |
| Delete this definition or add ‘Unison.ABT.bound'’ as a root to fix this error. | |
| src/Unison/ABT.hs:70:1: error: compose is unused | |
| 68 ┃ | |
| 69 ┃ compose :: Monoid m => Path s t a b m -> Path a b a' b' m -> Path s t a' b' m | |
| 70 ┃ compose (Path p1) (Path p2) = Path p3 where | |
| 71 ┃ p3 s = do | |
| 72 ┃ (get1,set1,m1) <- p1 s | |
| Delete this definition or add ‘Unison.ABT.compose’ as a root to fix this error. | |
| src/Unison/ABT.hs:238:1: error: cycler is unused | |
| 236 ┃ | |
| 237 ┃ cycler :: (Functor f, Foldable f, Var v) => [v] -> Term f (V v) () -> Term f (V v) () | |
| 238 ┃ cycler = cycler' () | |
| 239 ┃ | |
| 240 ┃ into :: (Foldable f, Ord v) => ABT f v (Term f v ()) -> Term f v () | |
| Delete this definition or add ‘Unison.ABT.cycler’ as a root to fix this error. | |
| src/Unison/ABT.hs:235:1: error: cycler' is unused | |
| 233 ┃ | |
| 234 ┃ cycler' :: (Functor f, Foldable f, Var v) => a -> [v] -> Term f (V v) a -> Term f (V v) a | |
| 235 ┃ cycler' a vs t = cycle' a $ foldr (absr' a) t vs | |
| 236 ┃ | |
| 237 ┃ cycler :: (Functor f, Foldable f, Var v) => [v] -> Term f (V v) () -> Term f (V v) () | |
| Delete this definition or add ‘Unison.ABT.cycler'’ as a root to fix this error. | |
| src/Unison/ABT.hs:704:1: error: distinct is unused | |
| 702 ┃ => proxy h | |
| 703 ┃ -> [Term f v a] -> [Term f v a] | |
| 704 ┃ distinct _ ts = fst <$> sortOn snd m | |
| 705 ┃ where m = Map.elems (Map.fromList (hashes `zip` (ts `zip` [0 :: Int .. 1]))) | |
| 706 ┃ hashes = map hash ts :: [h] | |
| Delete this definition or add ‘Unison.ABT.distinct’ as a root to fix this error. | |
| src/Unison/ABT.hs:546:1: error: find' is unused | |
| 544 ┃ -> Term f v a | |
| 545 ┃ -> [Term f v a] | |
| 546 ┃ find' p = Unison.ABT.find (\t -> if p t then Found t else Continue) | |
| 547 ┃ | |
| 548 ┃ instance (Foldable f, Functor f, Eq1 f, Var v) => Eq (Term f v a) where | |
| Delete this definition or add ‘Unison.ABT.find'’ as a root to fix this error. | |
| src/Unison/ABT.hs:291:1: error: freshEverywhere is unused | |
| 289 ┃ | |
| 290 ┃ freshEverywhere :: (Foldable f, Var v) => Term f v a -> v -> v | |
| 291 ┃ freshEverywhere t = freshIn . Set.fromList $ allVars t | |
| 292 ┃ | |
| 293 ┃ allVars :: Foldable f => Term f v a -> [v] | |
| Delete this definition or add ‘Unison.ABT.freshEverywhere’ as a root to fix this error. | |
| src/Unison/ABT.hs:301:1: error: freshes is unused | |
| 299 ┃ | |
| 300 ┃ freshes :: Var v => Term f v a -> [v] -> [v] | |
| 301 ┃ freshes = freshes' . freeVars | |
| 302 ┃ | |
| 303 ┃ freshes' :: Var v => Set v -> [v] -> [v] | |
| Delete this definition or add ‘Unison.ABT.freshes’ as a root to fix this error. | |
| src/Unison/ABT.hs:304:1: error: freshes' is unused | |
| 302 ┃ | |
| 303 ┃ freshes' :: Var v => Set v -> [v] -> [v] | |
| 304 ┃ freshes' used vs = evalState (traverse freshenS vs) used | |
| 305 ┃ | |
| 306 ┃ -- | Freshens the given variable wrt. the set of used variables | |
| Delete this definition or add ‘Unison.ABT.freshes'’ as a root to fix this error. | |
| src/Unison/ABT.hs:57:1: error: here is unused | |
| 55 ┃ | |
| 56 ┃ here :: Monoid m => Path s t s t m | |
| 57 ┃ here = Path $ \s -> Just (s, Just, mempty) | |
| 58 ┃ | |
| 59 ┃ instance Semigroup (Path s t a b m) where | |
| Delete this definition or add ‘Unison.ABT.here’ as a root to fix this error. | |
| src/Unison/ABT.hs:241:1: error: into is unused | |
| 239 ┃ | |
| 240 ┃ into :: (Foldable f, Ord v) => ABT f v (Term f v ()) -> Term f v () | |
| 241 ┃ into = into' () | |
| 242 ┃ | |
| 243 ┃ into' :: (Foldable f, Ord v) => a -> ABT f v (Term f v a) -> Term f v a | |
| Delete this definition or add ‘Unison.ABT.into’ as a root to fix this error. | |
| src/Unison/ABT.hs:244:1: error: into' is unused | |
| 242 ┃ | |
| 243 ┃ into' :: (Foldable f, Ord v) => a -> ABT f v (Term f v a) -> Term f v a | |
| 244 ┃ into' a abt = case abt of | |
| 245 ┃ Var x -> annotatedVar a x | |
| 246 ┃ Cycle t -> cycle' a t | |
| Delete this definition or add ‘Unison.ABT.into'’ as a root to fix this error. | |
| src/Unison/ABT.hs:126:1: error: isClosed is unused | |
| 124 ┃ -- | `True` if the term has no free variables, `False` otherwise | |
| 125 ┃ isClosed :: Term f v a -> Bool | |
| 126 ┃ isClosed t = Set.null (freeVars t) | |
| 127 ┃ | |
| 128 ┃ -- | `True` if `v` is a member of the set of free variables of `t` | |
| Delete this definition or add ‘Unison.ABT.isClosed’ as a root to fix this error. | |
| src/Unison/ABT.hs:80:1: error: modify' is unused | |
| 78 ┃ | |
| 79 ┃ modify' :: Path s t a b m -> (m -> a -> b) -> s -> Maybe t | |
| 80 ┃ modify' p f s = focus p s >>= \(get,set,m) -> set (f m get) | |
| 81 ┃ | |
| 82 ┃ wrap :: (Functor f, Foldable f, Var v) => v -> Term f (V v) a -> (V v, Term f (V v) a) | |
| Delete this definition or add ‘Unison.ABT.modify'’ as a root to fix this error. | |
| src/Unison/ABT.hs:493:1: error: reabs is unused | |
| 491 ┃ | |
| 492 ┃ reabs :: Ord v => [v] -> Term f v () -> Term f v () | |
| 493 ┃ reabs vs t = foldr abs t vs | |
| 494 ┃ | |
| 495 ┃ transform :: (Ord v, Foldable g, Functor f) | |
| Delete this definition or add ‘Unison.ABT.reabs’ as a root to fix this error. | |
| src/Unison/ABT.hs:712:1: error: subtract is unused | |
| 710 ┃ => proxy h | |
| 711 ┃ -> [Term f v a] -> [Term f v a] -> [Term f v a] | |
| 712 ┃ subtract _ t1s t2s = | |
| 713 ┃ let skips = Set.fromList (map hash t2s :: [h]) | |
| 714 ┃ in filter (\t -> Set.notMember (hash t) skips) t1s | |
| Delete this definition or add ‘Unison.ABT.subtract’ as a root to fix this error. | |
| src/Unison/ABT.hs:481:1: error: unabs1 is unused | |
| 479 ┃ | |
| 480 ┃ unabs1 :: (Foldable f, Functor f, Var v) => Term f v a -> Maybe (Subst f v a) | |
| 481 ┃ unabs1 (Term _ _ (Abs v body)) = Just (Subst freshen bind bindInheritAnnotation v) where | |
| 482 ┃ freshen f = f v | |
| 483 ┃ bind x = subst v x body | |
| Delete this definition or add ‘Unison.ABT.unabs1’ as a root to fix this error. | |
| src/Unison/ABT.hs:189:1: error: unabs1A is unused | |
| 187 ┃ | |
| 188 ┃ unabs1A :: Term f v a -> Maybe ([(a,v)], Term f v a) | |
| 189 ┃ unabs1A t = case unabsA t of | |
| 190 ┃ ([], _) -> Nothing | |
| 191 ┃ x -> Just x | |
| Delete this definition or add ‘Unison.ABT.unabs1A’ as a root to fix this error. | |
| src/Unison/ABT.hs:184:1: error: unabsA is unused | |
| 182 ┃ | |
| 183 ┃ unabsA :: Term f v a -> ([(a,v)], Term f v a) | |
| 184 ┃ unabsA (Term _ a (Abs hd body)) = | |
| 185 ┃ let (tl, body') = unabsA body in ((a,hd) : tl, body') | |
| 186 ┃ unabsA t = ([], t) | |
| Delete this definition or add ‘Unison.ABT.unabsA’ as a root to fix this error. | |
| src/Unison/ABT.hs:83:1: error: wrap is unused | |
| 81 ┃ | |
| 82 ┃ wrap :: (Functor f, Foldable f, Var v) => v -> Term f (V v) a -> (V v, Term f (V v) a) | |
| 83 ┃ wrap v t = | |
| 84 ┃ if Set.member (Free v) (freeVars t) | |
| 85 ┃ then let v' = fresh t (Bound v) in (v', rename (Bound v) v' t) | |
| Delete this definition or add ‘Unison.ABT.wrap’ as a root to fix this error. | |
| src/Unison/ABT.hs:90:1: error: wrap' is unused | |
| 88 ┃ wrap' :: (Functor f, Foldable f, Var v) | |
| 89 ┃ => v -> Term f (V v) a -> (V v -> Term f (V v) a -> c) -> c | |
| 90 ┃ wrap' v t f = uncurry f (wrap v t) | |
| 91 ┃ | |
| 92 ┃ -- | Return the list of all variables bound by this ABT | |
| Delete this definition or add ‘Unison.ABT.wrap'’ as a root to fix this error. | |
| src/Unison/ABT/Normalized.hs:133:1: error: transform is unused | |
| 131 ┃ => (forall a b. f a b -> g a b) | |
| 132 ┃ -> Term f v -> Term g v | |
| 133 ┃ transform phi (TTm body) = TTm . second (transform phi) $ phi body | |
| 134 ┃ transform phi (TAbs u body) = TAbs u $ transform phi body | |
| Delete this definition or add ‘Unison.ABT.Normalized.transform’ as a root to fix this error. | |
| src/Unison/ABT/Normalized.hs:72:1: error: unabss is unused | |
| 70 ┃ | |
| 71 ┃ unabss :: Var v => Term f v -> ([v], Term f v) | |
| 72 ┃ unabss (TAbs v (unabss -> (vs, bd))) = (v:vs, bd) | |
| 73 ┃ unabss bd = ([], bd) | |
| 74 ┃ | |
| Delete this definition or add ‘Unison.ABT.Normalized.unabss’ as a root to fix this error. | |
| src/Unison/Builtin.hs:85:1: error: constructorType is unused | |
| 83 ┃ | |
| 84 ┃ constructorType :: R.Reference -> Maybe CT.ConstructorType | |
| 85 ┃ constructorType r = TL.constructorType (typeLookup @Symbol) r | |
| 86 ┃ <|> Map.lookup r builtinConstructorType | |
| 87 ┃ | |
| Delete this definition or add ‘Unison.Builtin.constructorType’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:68:1: error: constructorId is unused | |
| 66 ┃ | |
| 67 ┃ constructorId :: Reference -> Text -> Maybe Int | |
| 68 ┃ constructorId ref name = do | |
| 69 ┃ (_,_,dd) <- find (\(_,r,_) -> Reference.DerivedId r == ref) (builtinDataDecls @Symbol) | |
| 70 ┃ elemIndex name $ DD.constructorNames dd | |
| Delete this definition or add ‘Unison.Builtin.Decls.constructorId’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:58:1: error: filePathRef is unused | |
| 56 ┃ fileModeRef, filePathRef, bufferModeRef, seekModeRef, seqViewRef :: Reference | |
| 57 ┃ fileModeRef = lookupDeclRef "io2.FileMode" | |
| 58 ┃ filePathRef = lookupDeclRef "io2.FilePath" | |
| 59 ┃ bufferModeRef = lookupDeclRef "io2.BufferMode" | |
| 60 ┃ seekModeRef = lookupDeclRef "io2.SeekMode" | |
| Delete this definition or add ‘Unison.Builtin.Decls.filePathRef’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:325:1: error: filePathType is unused | |
| 323 ┃ ioErrorType a = Type.ref a ioErrorRef | |
| 324 ┃ fileModeType a = Type.ref a fileModeRef | |
| 325 ┃ filePathType a = Type.ref a filePathRef | |
| 326 ┃ bufferModeType a = Type.ref a bufferModeRef | |
| 327 ┃ seekModeType a = Type.ref a seekModeRef | |
| Delete this definition or add ‘Unison.Builtin.Decls.filePathType’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:50:1: error: ioErrorRef is unused | |
| 48 ┃ linkRef = lookupDeclRef "Link" | |
| 49 ┃ docRef = lookupDeclRef "Doc" | |
| 50 ┃ ioErrorRef = lookupDeclRef "io2.IOError" | |
| 51 ┃ stdHandleRef = lookupDeclRef "io2.StdHandle" | |
| 52 ┃ failureRef = lookupDeclRef "io2.Failure" | |
| Delete this definition or add ‘Unison.Builtin.Decls.ioErrorRef’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:323:1: error: ioErrorType is unused | |
| 321 ┃ optionalType a = Type.ref a optionalRef | |
| 322 ┃ eitherType a = Type.ref a eitherRef | |
| 323 ┃ ioErrorType a = Type.ref a ioErrorRef | |
| 324 ┃ fileModeType a = Type.ref a fileModeRef | |
| 325 ┃ filePathType a = Type.ref a filePathRef | |
| Delete this definition or add ‘Unison.Builtin.Decls.ioErrorType’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:54:1: error: tlsPrivateKeyRef is unused | |
| 52 ┃ failureRef = lookupDeclRef "io2.Failure" | |
| 53 ┃ tlsSignedCertRef = lookupDeclRef "io2.Tls.SignedCert" | |
| 54 ┃ tlsPrivateKeyRef = lookupDeclRef "io2.Tls.PrivateKey" | |
| 55 ┃ | |
| 56 ┃ fileModeRef, filePathRef, bufferModeRef, seekModeRef, seqViewRef :: Reference | |
| Delete this definition or add ‘Unison.Builtin.Decls.tlsPrivateKeyRef’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:53:1: error: tlsSignedCertRef is unused | |
| 51 ┃ stdHandleRef = lookupDeclRef "io2.StdHandle" | |
| 52 ┃ failureRef = lookupDeclRef "io2.Failure" | |
| 53 ┃ tlsSignedCertRef = lookupDeclRef "io2.Tls.SignedCert" | |
| 54 ┃ tlsPrivateKeyRef = lookupDeclRef "io2.Tls.PrivateKey" | |
| 55 ┃ | |
| Delete this definition or add ‘Unison.Builtin.Decls.tlsSignedCertRef’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:332:1: error: tlsSignedCertType is unused | |
| 330 ┃ | |
| 331 ┃ tlsSignedCertType :: Var v => a -> Type v a | |
| 332 ┃ tlsSignedCertType a = Type.ref a tlsSignedCertRef | |
| 333 ┃ | |
| 334 ┃ unitTerm :: Var v => a -> Term v a | |
| Delete this definition or add ‘Unison.Builtin.Decls.tlsSignedCertType’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:379:1: error: unOptionalRef is unused | |
| 377 ┃ unUnitRef = (== unitRef) | |
| 378 ┃ unPairRef = (== pairRef) | |
| 379 ┃ unOptionalRef = (== optionalRef) | |
| 380 ┃ | |
| Delete this definition or add ‘Unison.Builtin.Decls.unOptionalRef’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:378:1: error: unPairRef is unused | |
| 376 ┃ unUnitRef,unPairRef,unOptionalRef:: Reference -> Bool | |
| 377 ┃ unUnitRef = (== unitRef) | |
| 378 ┃ unPairRef = (== pairRef) | |
| 379 ┃ unOptionalRef = (== optionalRef) | |
| 380 ┃ | |
| Delete this definition or add ‘Unison.Builtin.Decls.unPairRef’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:371:1: error: unTuplePattern is unused | |
| 369 ┃ | |
| 370 ┃ unTuplePattern :: Pattern.Pattern loc -> Maybe [Pattern.Pattern loc] | |
| 371 ┃ unTuplePattern p = case p of | |
| 372 ┃ Pattern.Constructor _ PairRef 0 [fst, snd] -> (fst : ) <$> unTuplePattern snd | |
| 373 ┃ Pattern.Constructor _ UnitRef 0 [] -> Just [] | |
| Delete this definition or add ‘Unison.Builtin.Decls.unTuplePattern’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:358:1: error: unTupleTerm is unused | |
| 356 ┃ :: Term.Term2 vt at ap v a | |
| 357 ┃ -> Maybe [Term.Term2 vt at ap v a] | |
| 358 ┃ unTupleTerm t = case t of | |
| 359 ┃ Term.Apps' (Term.Constructor' PairRef 0) [fst, snd] -> | |
| 360 ┃ (fst :) <$> unTupleTerm snd | |
| Delete this definition or add ‘Unison.Builtin.Decls.unTupleTerm’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:365:1: error: unTupleType is unused | |
| 363 ┃ | |
| 364 ┃ unTupleType :: Var v => Type v a -> Maybe [Type v a] | |
| 365 ┃ unTupleType t = case t of | |
| 366 ┃ Type.Apps' (Type.Ref' PairRef) [fst, snd] -> (fst :) <$> unTupleType snd | |
| 367 ┃ Type.Ref' UnitRef -> Just [] | |
| Delete this definition or add ‘Unison.Builtin.Decls.unTupleType’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:377:1: error: unUnitRef is unused | |
| 375 ┃ | |
| 376 ┃ unUnitRef,unPairRef,unOptionalRef:: Reference -> Bool | |
| 377 ┃ unUnitRef = (== unitRef) | |
| 378 ┃ unPairRef = (== pairRef) | |
| 379 ┃ unOptionalRef = (== optionalRef) | |
| Delete this definition or add ‘Unison.Builtin.Decls.unUnitRef’ as a root to fix this error. | |
| src/Unison/Builtin/Decls.hs:65:1: error: unitCtorRef is unused | |
| 63 ┃ pairCtorRef, unitCtorRef :: Referent | |
| 64 ┃ pairCtorRef = Referent.Con pairRef 0 CT.Data | |
| 65 ┃ unitCtorRef = Referent.Con unitRef 0 CT.Data | |
| 66 ┃ | |
| 67 ┃ constructorId :: Reference -> Text -> Maybe Int | |
| Delete this definition or add ‘Unison.Builtin.Decls.unitCtorRef’ as a root to fix this error. | |
| src/Unison/Codebase.hs:126:1: error: getTypeOfConstructor is unused | |
| 124 ┃ getTypeOfConstructor :: | |
| 125 ┃ (Monad m, Ord v) => Codebase m v a -> Reference -> Int -> m (Maybe (Type v a)) | |
| 126 ┃ getTypeOfConstructor codebase (Reference.DerivedId r) cid = do | |
| 127 ┃ maybeDecl <- getTypeDeclaration codebase r | |
| 128 ┃ pure $ case maybeDecl of | |
| Delete this definition or add ‘Unison.Codebase.getTypeOfConstructor’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:219:1: error: childrenR is unused | |
| 217 ┃ makeLenses ''Branch | |
| 218 ┃ makeLensesFor [("_edits", "edits")] ''Branch0 | |
| 219 ┃ makeLenses ''Raw | |
| 220 ┃ | |
| 221 ┃ toNames0 :: Branch0 m -> Names0 | |
| Delete this definition or add ‘Unison.Codebase.Branch.childrenR’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:455:1: error: debugPaths is unused | |
| 453 ┃ | |
| 454 ┃ debugPaths :: Branch m -> Set (Path, Hash) | |
| 455 ┃ debugPaths = go Path.empty where | |
| 456 ┃ go p b = Set.insert (p, headHash b) . Set.unions $ | |
| 457 ┃ [ go (Path.snoc p seg) b | (seg, b) <- Map.toList $ _children (head b) ] | |
| Delete this definition or add ‘Unison.Codebase.Branch.debugPaths’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:608:1: error: deleteAt is unused | |
| 606 ┃ | |
| 607 ┃ deleteAt :: Applicative m => Path -> Branch m -> Branch m | |
| 608 ┃ deleteAt path = setAt path empty | |
| 609 ┃ | |
| 610 ┃ -- returns `Nothing` if no Branch at `path` or if Branch is empty at `path` | |
| Delete this definition or add ‘Unison.Codebase.Branch.deleteAt’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:219:1: error: editsR is unused | |
| 217 ┃ makeLenses ''Branch | |
| 218 ┃ makeLensesFor [("_edits", "edits")] ''Branch0 | |
| 219 ┃ makeLenses ''Raw | |
| 220 ┃ | |
| 221 ┃ toNames0 :: Branch0 m -> Names0 | |
| Delete this definition or add ‘Unison.Codebase.Branch.editsR’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:229:1: error: findHistoricalSHs is unused | |
| 227 ┃ findHistoricalSHs | |
| 228 ┃ :: Monad m => Set ShortHash -> Branch m -> m (Set ShortHash, Names0) | |
| 229 ┃ findHistoricalSHs = findInHistory | |
| 230 ┃ (\sh r _n -> sh `SH.isPrefixOf` Referent.toShortHash r) | |
| 231 ┃ (\sh r _n -> sh `SH.isPrefixOf` Reference.toShortHash r) | |
| Delete this definition or add ‘Unison.Codebase.Branch.findHistoricalSHs’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:571:1: error: fork is unused | |
| 569 ┃ -> Branch m | |
| 570 ┃ -> Either ForkFailure (Branch m) | |
| 571 ┃ fork src dest root = case getAt src root of | |
| 572 ┃ Nothing -> Left SrcNotFound | |
| 573 ┃ Just src' -> case setIfNotExists dest src' root of | |
| Delete this definition or add ‘Unison.Codebase.Branch.fork’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:841:1: error: lca is unused | |
| 839 ┃ | |
| 840 ┃ lca :: Monad m => Branch m -> Branch m -> m (Maybe (Branch m)) | |
| 841 ┃ lca (Branch a) (Branch b) = fmap Branch <$> Causal.lca a b | |
| 842 ┃ | |
| 843 ┃ diff0 :: Monad m => Branch0 m -> Branch0 m -> m BranchDiff | |
| Delete this definition or add ‘Unison.Codebase.Branch.lca’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:747:1: error: modifyAt is unused | |
| 745 ┃ modifyAt :: Applicative m | |
| 746 ┃ => Path -> (Branch m -> Branch m) -> Branch m -> Branch m | |
| 747 ┃ modifyAt path f = runIdentity . modifyAtM path (pure . f) | |
| 748 ┃ | |
| 749 ┃ -- Modify the Branch at `path` with `f`, after creating it if necessary. | |
| Delete this definition or add ‘Unison.Codebase.Branch.modifyAt’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:585:1: error: move is unused | |
| 583 ┃ -> Branch m | |
| 584 ┃ -> Either ForkFailure (Branch m) | |
| 585 ┃ move src dest root = case getAt src root of | |
| 586 ┃ Nothing -> Left SrcNotFound | |
| 587 ┃ Just src' -> | |
| Delete this definition or add ‘Unison.Codebase.Branch.move’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:475:1: error: numHashChars is unused | |
| 473 ┃ -- could move a Names0 to a read-only field in Branch0 until it gets too big | |
| 474 ┃ numHashChars :: Branch m -> Int | |
| 475 ┃ numHashChars _b = 3 | |
| 476 ┃ | |
| 477 ┃ -- This type is a little ugly, so we wrap it up with a nice type alias for | |
| Delete this definition or add ‘Unison.Codebase.Branch.numHashChars’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:452:1: error: printDebugPaths is unused | |
| 450 ┃ | |
| 451 ┃ printDebugPaths :: Branch m -> String | |
| 452 ┃ printDebugPaths = unlines . map show . Set.toList . debugPaths | |
| 453 ┃ | |
| 454 ┃ debugPaths :: Branch m -> Set (Path, Hash) | |
| Delete this definition or add ‘Unison.Codebase.Branch.printDebugPaths’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:605:1: error: setAt is unused | |
| 603 ┃ | |
| 604 ┃ setAt :: Applicative m => Path -> Branch m -> Branch m -> Branch m | |
| 605 ┃ setAt path b = modifyAt path (const b) | |
| 606 ┃ | |
| 607 ┃ deleteAt :: Applicative m => Path -> Branch m -> Branch m | |
| Delete this definition or add ‘Unison.Codebase.Branch.setAt’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:600:1: error: setIfNotExists is unused | |
| 598 ┃ setIfNotExists | |
| 599 ┃ :: Applicative m => Path -> Branch m -> Branch m -> Maybe (Branch m) | |
| 600 ┃ setIfNotExists dest b root = case getAt dest root of | |
| 601 ┃ Just _destExists -> Nothing | |
| 602 ┃ Nothing -> Just $ setAt dest b root | |
| Delete this definition or add ‘Unison.Codebase.Branch.setIfNotExists’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:669:1: error: stepAt is unused | |
| 667 ┃ -> (Branch0 m -> Branch0 m) | |
| 668 ┃ -> Branch m -> Branch m | |
| 669 ┃ stepAt p f = modifyAt p g where | |
| 670 ┃ g :: Branch m -> Branch m | |
| 671 ┃ g (Branch b) = Branch . Causal.consDistinct (f (Causal.head b)) $ b | |
| Delete this definition or add ‘Unison.Codebase.Branch.stepAt’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:681:1: error: stepAtM is unused | |
| 679 ┃ stepAtM :: forall n m. (Functor n, Applicative m) | |
| 680 ┃ => Path -> (Branch0 m -> n (Branch0 m)) -> Branch m -> n (Branch m) | |
| 681 ┃ stepAtM p f = modifyAtM p g where | |
| 682 ┃ g :: Branch m -> n (Branch m) | |
| 683 ┃ g (Branch b) = do | |
| Delete this definition or add ‘Unison.Codebase.Branch.stepAtM’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:219:1: error: termsR is unused | |
| 217 ┃ makeLenses ''Branch | |
| 218 ┃ makeLensesFor [("_edits", "edits")] ''Branch0 | |
| 219 ┃ makeLenses ''Raw | |
| 220 ┃ | |
| 221 ┃ toNames0 :: Branch0 m -> Names0 | |
| Delete this definition or add ‘Unison.Codebase.Branch.termsR’ as a root to fix this error. | |
| src/Unison/Codebase/Branch.hs:219:1: error: typesR is unused | |
| 217 ┃ makeLenses ''Branch | |
| 218 ┃ makeLensesFor [("_edits", "edits")] ''Branch0 | |
| 219 ┃ makeLenses ''Raw | |
| 220 ┃ | |
| 221 ┃ toNames0 :: Branch0 m -> Names0 | |
| Delete this definition or add ‘Unison.Codebase.Branch.typesR’ as a root to fix this error. | |
| src/Unison/Codebase/BranchUtil.hs:95:1: error: getTypeByShortHash is unused | |
| 93 ┃ | |
| 94 ┃ getTypeByShortHash :: SH.ShortHash -> Branch0 m -> Set Reference | |
| 95 ┃ getTypeByShortHash sh b = filter sh $ Branch.deepTypeReferences b | |
| 96 ┃ where | |
| 97 ┃ filter sh = Set.filter (SH.isPrefixOf sh . Reference.toShortHash) | |
| Delete this definition or add ‘Unison.Codebase.BranchUtil.getTypeByShortHash’ as a root to fix this error. | |
| src/Unison/Codebase/BranchUtil.hs:35:1: error: hashesFromNames0 is unused | |
| 33 ┃ -- can produce a pure value because there's no history to traverse | |
| 34 ┃ hashesFromNames0 :: Monad m => Names0 -> Map Branch.Hash (Branch m) | |
| 35 ┃ hashesFromNames0 = deepHashes . fromNames0 where | |
| 36 ┃ deepHashes :: Branch m -> Map Branch.Hash (Branch m) | |
| 37 ┃ deepHashes b = Map.singleton (Branch.headHash b) b | |
| Delete this definition or add ‘Unison.Codebase.BranchUtil.hashesFromNames0’ as a root to fix this error. | |
| src/Unison/Codebase/Causal.hs:98:1: error: rawHead is unused | |
| 96 ┃ | |
| 97 ┃ rawHead :: Raw h e -> e | |
| 98 ┃ rawHead (RawOne e ) = e | |
| 99 ┃ rawHead (RawCons e _) = e | |
| 100 ┃ rawHead (RawMerge e _) = e | |
| Delete this definition or add ‘Unison.Codebase.Causal.rawHead’ as a root to fix this error. | |
| src/Unison/Codebase/Causal.hs:270:1: error: step is unused | |
| 268 ┃ | |
| 269 ┃ step :: (Applicative m, Hashable e) => (e -> e) -> Causal m h e -> Causal m h e | |
| 270 ┃ step f c = f (head c) `cons` c | |
| 271 ┃ | |
| 272 ┃ stepDistinct :: (Applicative m, Eq e, Hashable e) => (e -> e) -> Causal m h e -> Causal m h e | |
| Delete this definition or add ‘Unison.Codebase.Causal.step’ as a root to fix this error. | |
| src/Unison/Codebase/Causal.hs:281:1: error: stepIf is unused | |
| 279 ┃ -> Causal m h e | |
| 280 ┃ -> Causal m h e | |
| 281 ┃ stepIf cond f c = if cond (head c) then step f c else c | |
| 282 ┃ | |
| 283 ┃ stepM | |
| Delete this definition or add ‘Unison.Codebase.Causal.stepIf’ as a root to fix this error. | |
| src/Unison/Codebase/Causal.hs:285:1: error: stepM is unused | |
| 283 ┃ stepM | |
| 284 ┃ :: (Applicative m, Hashable e) => (e -> m e) -> Causal m h e -> m (Causal m h e) | |
| 285 ┃ stepM f c = (`cons` c) <$> f (head c) | |
| 286 ┃ | |
| 287 ┃ stepDistinctM | |
| Delete this definition or add ‘Unison.Codebase.Causal.stepM’ as a root to fix this error. | |
| src/Unison/Codebase/Causal.hs:75:1: error: toGraph is unused | |
| 73 ┃ -> Causal m h e | |
| 74 ┃ -> m (Seq (RawHash h, RawHash h)) | |
| 75 ┃ toGraph seen c = case c of | |
| 76 ┃ One _ _ -> pure Seq.empty | |
| 77 ┃ Cons h1 _ (h2, m) -> if Set.notMember h1 seen | |
| Delete this definition or add ‘Unison.Codebase.Causal.toGraph’ as a root to fix this error. | |
| src/Unison/Codebase/Editor/HandleInput.hs:141:1: error: _liftToAction is unused | |
| 139 ┃ | |
| 140 ┃ _liftToAction :: m a -> Action m i v a | |
| 141 ┃ _liftToAction = lift . lift . Free.eval . Eval | |
| 142 ┃ | |
| 143 ┃ data LoopState m v | |
| Delete this definition or add ‘Unison.Codebase.Editor.HandleInput._liftToAction’ as a root to fix this error. | |
| src/Unison/Codebase/Editor/HandleInput.hs:2084:1: error: _searchBranchPrefix is unused | |
| 2082 ┃ -- return `name` and `name.<everything>...` | |
| 2083 ┃ _searchBranchPrefix :: Branch m -> Name -> [SearchResult] | |
| 2084 ┃ _searchBranchPrefix b n = case Path.unsnoc (Path.fromName n) of | |
| 2085 ┃ Nothing -> [] | |
| 2086 ┃ Just (init, last) -> case Branch.getAt init b of | |
| Delete this definition or add ‘Unison.Codebase.Editor.HandleInput._searchBranchPrefix’ as a root to fix this error. | |
| src/Unison/Codebase/Editor/SlurpComponent.hs:24:1: error: empty is unused | |
| 22 ┃ | |
| 23 ┃ empty :: Ord v => SlurpComponent v | |
| 24 ┃ empty = SlurpComponent mempty mempty | |
| 25 ┃ | |
| 26 ┃ difference :: Ord v => SlurpComponent v -> SlurpComponent v -> SlurpComponent v | |
| Delete this definition or add ‘Unison.Codebase.Editor.SlurpComponent.empty’ as a root to fix this error. | |
| src/Unison/Codebase/Editor/SlurpResult.hs:369:1: error: ex is unused | |
| 367 ┃ -- λ> putStrLn $ toANSI 80 ex | |
| 368 ┃ ex :: P.Pretty P.ColorText | |
| 369 ┃ ex = P.indentN 2 $ P.lines ["", | |
| 370 ┃ P.green "⣠I've added these definitions: ", "", | |
| 371 ┃ P.indentN 2 . P.column2 $ [("a", "Nat"), ("map", "(a -> b) -> [a] -> [b]")], | |
| Delete this definition or add ‘Unison.Codebase.Editor.SlurpResult.ex’ as a root to fix this error. | |
| src/Unison/Codebase/Editor/SlurpResult.hs:134:1: error: isFailure is unused | |
| 132 ┃ | |
| 133 ┃ isFailure :: Status -> Bool | |
| 134 ┃ isFailure s = case s of | |
| 135 ┃ TermExistingConstructorCollision -> True | |
| 136 ┃ ConstructorExistingTermCollision -> True | |
| Delete this definition or add ‘Unison.Codebase.Editor.SlurpResult.isFailure’ as a root to fix this error. | |
| src/Unison/Codebase/Editor/TodoOutput.hs:36:1: error: labeledDependencies is unused | |
| 34 ┃ | |
| 35 ┃ labeledDependencies :: Ord v => TodoOutput v a -> Set LabeledDependency | |
| 36 ┃ labeledDependencies TodoOutput{..} = Set.fromList ( | |
| 37 ┃ -- term refs | |
| 38 ┃ [LD.termRef r | (r, _) <- fst todoFrontier] <> | |
| Delete this definition or add ‘Unison.Codebase.Editor.TodoOutput.labeledDependencies’ as a root to fix this error. | |
| src/Unison/Codebase/FileCodebase/Common.hs:418:1: error: doFileOnce is unused | |
| 416 ┃ -> (h -> m ()) -- do! | |
| 417 ┃ -> h -> m () | |
| 418 ┃ doFileOnce destPath l getFilename f h = | |
| 419 ┃ unlessM (use (l . to (Set.member h))) $ do | |
| 420 ┃ l %= Set.insert h | |
| Delete this definition or add ‘Unison.Codebase.FileCodebase.Common.doFileOnce’ as a root to fix this error. | |
| src/Unison/Codebase/MainTerm.hs:95:1: error: mainTypes is unused | |
| 93 ┃ | |
| 94 ┃ mainTypes :: Var v => a -> [Type v a] | |
| 95 ┃ mainTypes a = [nullaryMain a] | |
| Delete this definition or add ‘Unison.Codebase.MainTerm.mainTypes’ as a root to fix this error. | |
| src/Unison/Codebase/Metadata.hs:63:1: error: append is unused | |
| 61 ┃ -- sequential composition, right-biased | |
| 62 ┃ append :: Metadata -> Metadata -> Metadata | |
| 63 ┃ append = Map.unionWith (flip const) | |
| 64 ┃ | |
| 65 ┃ empty :: Metadata | |
| Delete this definition or add ‘Unison.Codebase.Metadata.append’ as a root to fix this error. | |
| src/Unison/Codebase/Metadata.hs:33:1: error: hasMetadata is unused | |
| 31 ┃ | |
| 32 ┃ hasMetadata :: Ord a => a -> Type -> Value -> Star a n -> Bool | |
| 33 ┃ hasMetadata a t v = Set.member (t, v) . R.lookupDom a . Star3.d3 | |
| 34 ┃ | |
| 35 ┃ inserts :: (Ord a, Ord n) => [(a, Type, Value)] -> Star a n -> Star a n | |
| Delete this definition or add ‘Unison.Codebase.Metadata.hasMetadata’ as a root to fix this error. | |
| src/Unison/Codebase/Metadata.hs:59:1: error: merge is unused | |
| 57 ┃ -- parallel composition - commutative and associative | |
| 58 ┃ merge :: Metadata -> Metadata -> Metadata | |
| 59 ┃ merge = Map.unionWith (<>) | |
| 60 ┃ | |
| 61 ┃ -- sequential composition, right-biased | |
| Delete this definition or add ‘Unison.Codebase.Metadata.merge’ as a root to fix this error. | |
| src/Unison/Codebase/Metadata.hs:72:1: error: toRelation is unused | |
| 70 ┃ | |
| 71 ┃ toRelation :: Star3 a n x y -> Relation a n | |
| 72 ┃ toRelation = Star3.d1 | |
| Delete this definition or add ‘Unison.Codebase.Metadata.toRelation’ as a root to fix this error. | |
| src/Unison/Codebase/Patch.hs:64:1: error: allReferences is unused | |
| 62 ┃ | |
| 63 ┃ allReferences :: Patch -> Set Reference | |
| 64 ┃ allReferences p = typeReferences p <> termReferences p where | |
| 65 ┃ typeReferences p = Set.fromList | |
| 66 ┃ [ r | (old, TypeEdit.Replace new) <- R.toList (_typeEdits p) | |
| Delete this definition or add ‘Unison.Codebase.Patch.allReferences’ as a root to fix this error. | |
| src/Unison/Codebase/Patch.hs:61:1: error: isEmpty is unused | |
| 59 ┃ | |
| 60 ┃ isEmpty :: Patch -> Bool | |
| 61 ┃ isEmpty p = p == empty | |
| 62 ┃ | |
| 63 ┃ allReferences :: Patch -> Set Reference | |
| Delete this definition or add ‘Unison.Codebase.Patch.isEmpty’ as a root to fix this error. | |
| src/Unison/Codebase/Path.hs:234:1: error: fromSplit' is unused | |
| 232 ┃ | |
| 233 ┃ fromSplit' :: (Path', a) -> (Path, a) | |
| 234 ┃ fromSplit' (Path' (Left (Absolute p)), a) = (p, a) | |
| 235 ┃ fromSplit' (Path' (Right (Relative p)), a) = (p, a) | |
| 236 ┃ | |
| Delete this definition or add ‘Unison.Codebase.Path.fromSplit'’ as a root to fix this error. | |
| src/Unison/Codebase/Path.hs:144:1: error: optionalWordyNameSegment is unused | |
| 142 ┃ | |
| 143 ┃ optionalWordyNameSegment :: String -> Either String NameSegment | |
| 144 ┃ optionalWordyNameSegment "" = Right $ NameSegment "" | |
| 145 ┃ optionalWordyNameSegment s = wordyNameSegment s | |
| 146 ┃ | |
| Delete this definition or add ‘Unison.Codebase.Path.optionalWordyNameSegment’ as a root to fix this error. | |
| src/Unison/Codebase/Path.hs:247:1: error: relativeSingleton is unused | |
| 245 ┃ | |
| 246 ┃ relativeSingleton :: NameSegment -> Relative | |
| 247 ┃ relativeSingleton = Relative . Path . Seq.singleton | |
| 248 ┃ | |
| 249 ┃ toPath' :: Path -> Path' | |
| Delete this definition or add ‘Unison.Codebase.Path.relativeSingleton’ as a root to fix this error. | |
| src/Unison/Codebase/Path.hs:329:1: error: relativeToAncestor is unused | |
| 327 ┃ -- two inputs relativized to that ancestor. | |
| 328 ┃ relativeToAncestor :: Path -> Path -> (Path, Path, Path) | |
| 329 ┃ relativeToAncestor (Path a) (Path b) = case (a, b) of | |
| 330 ┃ (ha :<| ta, hb :<| tb) | ha == hb -> | |
| 331 ┃ let (ancestor, relA, relB) = relativeToAncestor (Path ta) (Path tb) | |
| Delete this definition or add ‘Unison.Codebase.Path.relativeToAncestor’ as a root to fix this error. | |
| src/Unison/Codebase/Path.hs:250:1: error: toPath' is unused | |
| 248 ┃ | |
| 249 ┃ toPath' :: Path -> Path' | |
| 250 ┃ toPath' = \case | |
| 251 ┃ Path (NameSegment "" :<| tail) -> Path' . Left . Absolute . Path $ tail | |
| 252 ┃ p -> Path' . Right . Relative $ p | |
| Delete this definition or add ‘Unison.Codebase.Path.toPath'’ as a root to fix this error. | |
| src/Unison/Codebase/SearchResult.hs:77:1: error: _fromNames is unused | |
| 75 ┃ | |
| 76 ┃ _fromNames :: Names0 -> [SearchResult] | |
| 77 ┃ _fromNames n0@(Names terms types) = typeResults <> termResults where | |
| 78 ┃ typeResults = | |
| 79 ┃ [ typeResult (Names._hqTypeName n0 name r) r (Names._hqTypeAliases n0 name r) | |
| Delete this definition or add ‘Unison.Codebase.SearchResult._fromNames’ as a root to fix this error. | |
| src/Unison/Codebase/SearchResult.hs:56:1: error: aliases is unused | |
| 54 ┃ | |
| 55 ┃ aliases :: SearchResult -> Set HashQualified | |
| 56 ┃ aliases = \case | |
| 57 ┃ Tm t -> termAliases t | |
| 58 ┃ Tp t -> typeAliases t | |
| Delete this definition or add ‘Unison.Codebase.SearchResult.aliases’ as a root to fix this error. | |
| src/Unison/Codebase/SearchResult.hs:66:1: error: truncateAliases is unused | |
| 64 ┃ | |
| 65 ┃ truncateAliases :: Int -> SearchResult -> SearchResult | |
| 66 ┃ truncateAliases n = \case | |
| 67 ┃ Tm (TermResult hq r as) -> termResult hq r (Set.map (HQ.take n) as) | |
| 68 ┃ Tp (TypeResult hq r as) -> typeResult hq r (Set.map (HQ.take n) as) | |
| Delete this definition or add ‘Unison.Codebase.SearchResult.truncateAliases’ as a root to fix this error. | |
| src/Unison/Codebase/Serialization/V1.hs:309:1: error: getFolded is unused | |
| 307 ┃ | |
| 308 ┃ getFolded :: MonadGet m => (b -> a -> b) -> b -> m a -> m b | |
| 309 ┃ getFolded f z a = | |
| 310 ┃ foldl' f z <$> getList a | |
| 311 ┃ | |
| Delete this definition or add ‘Unison.Codebase.Serialization.V1.getFolded’ as a root to fix this error. | |
| src/Unison/Codebase/Serialization/V1.hs:674:1: error: putLink is unused | |
| 672 ┃ | |
| 673 ┃ putLink :: MonadPut m => (Hash, mb) -> m () | |
| 674 ┃ putLink (h, _) = do | |
| 675 ┃ -- 0 means local; later we may have remote links with other ids | |
| 676 ┃ putWord8 0 | |
| Delete this definition or add ‘Unison.Codebase.Serialization.V1.putLink’ as a root to fix this error. | |
| src/Unison/Codebase/Serialization/V1.hs:580:1: error: putPair'' is unused | |
| 578 ┃ -> (a, b) | |
| 579 ┃ -> n (m ()) | |
| 580 ┃ putPair'' putA putBn (a, b) = pure (putA a) *> putBn b | |
| 581 ┃ | |
| 582 ┃ getPair :: MonadGet m => m a -> m b -> m (a,b) | |
| Delete this definition or add ‘Unison.Codebase.Serialization.V1.putPair''’ as a root to fix this error. | |
| src/Unison/Codebase/ShortBranchHash.hs:25:1: error: fullFromHash is unused | |
| 23 ┃ | |
| 24 ┃ fullFromHash :: Branch.Hash -> ShortBranchHash | |
| 25 ┃ fullFromHash = ShortBranchHash . Hash.base32Hex . Causal.unRawHash | |
| 26 ┃ | |
| 27 ┃ -- abc -> SBH abc | |
| Delete this definition or add ‘Unison.Codebase.ShortBranchHash.fullFromHash’ as a root to fix this error. | |
| src/Unison/Codebase/ShortBranchHash.hs:18:1: error: toHash is unused | |
| 16 ┃ | |
| 17 ┃ toHash :: ShortBranchHash -> Maybe Branch.Hash | |
| 18 ┃ toHash = fmap Causal.RawHash . Hash.fromBase32Hex . toText | |
| 19 ┃ | |
| 20 ┃ fromHash :: Int -> Branch.Hash -> ShortBranchHash | |
| Delete this definition or add ‘Unison.Codebase.ShortBranchHash.toHash’ as a root to fix this error. | |
| src/Unison/Codebase/TermEdit.hs:43:1: error: isSame is unused | |
| 41 ┃ | |
| 42 ┃ isSame :: TermEdit -> Bool | |
| 43 ┃ isSame e = case e of | |
| 44 ┃ Replace _ Same -> True | |
| 45 ┃ _ -> False | |
| Delete this definition or add ‘Unison.Codebase.TermEdit.isSame’ as a root to fix this error. | |
| src/Unison/Codebase/TermEdit.hs:37:1: error: isTypePreserving is unused | |
| 35 ┃ | |
| 36 ┃ isTypePreserving :: TermEdit -> Bool | |
| 37 ┃ isTypePreserving e = case e of | |
| 38 ┃ Replace _ Same -> True | |
| 39 ┃ Replace _ Subtype -> True | |
| Delete this definition or add ‘Unison.Codebase.TermEdit.isTypePreserving’ as a root to fix this error. | |
| src/Unison/Codecs.hs:282:1: error: lengthEncode is unused | |
| 280 ┃ | |
| 281 ┃ lengthEncode :: MonadPut m => Text -> m () | |
| 282 ┃ lengthEncode text = do | |
| 283 ┃ let bs = encodeUtf8 text | |
| 284 ┃ putLength $ B.length bs | |
| Delete this definition or add ‘Unison.Codecs.lengthEncode’ as a root to fix this error. | |
| src/Unison/Codecs.hs:269:1: error: putBackref is unused | |
| 267 ┃ | |
| 268 ┃ putBackref :: MonadPut m => Pos -> m () | |
| 269 ┃ putBackref = BS.serialize . VarInt | |
| 270 ┃ | |
| 271 ┃ putLength :: (MonadPut m, Integral n, Integral (Unsigned n), | |
| Delete this definition or add ‘Unison.Codecs.putBackref’ as a root to fix this error. | |
| src/Unison/Codecs.hs:274:1: error: putLength is unused | |
| 272 ┃ Bits n, Bits (Unsigned n)) | |
| 273 ┃ => n -> m () | |
| 274 ┃ putLength = BS.serialize . VarInt | |
| 275 ┃ | |
| 276 ┃ serializeMaybe :: (MonadPut m) => (a -> m ()) -> Maybe a -> m () | |
| Delete this definition or add ‘Unison.Codecs.putLength’ as a root to fix this error. | |
| src/Unison/Codecs.hs:252:1: error: serializeBoolean is unused | |
| 250 ┃ | |
| 251 ┃ serializeBoolean :: MonadPut m => Bool -> m () | |
| 252 ┃ serializeBoolean False = putWord64be 0 *> putWord8 0 | |
| 253 ┃ serializeBoolean True = putWord64be 1 *> putWord8 0 | |
| 254 ┃ | |
| Delete this definition or add ‘Unison.Codecs.serializeBoolean’ as a root to fix this error. | |
| src/Unison/Codecs.hs:263:1: error: serializeCase1 is unused | |
| 261 ┃ serializeCase1 :: (Var v, MonadPut m, MonadState Pos m) | |
| 262 ┃ => MatchCase p (Term v a) -> m (MatchCase p Pos) | |
| 263 ┃ serializeCase1 (MatchCase p guard body) = do | |
| 264 ┃ posg <- traverse serializeTerm guard | |
| 265 ┃ posb <- serializeTerm body | |
| Delete this definition or add ‘Unison.Codecs.serializeCase1’ as a root to fix this error. | |
| src/Unison/Codecs.hs:256:1: error: serializeCase2 is unused | |
| 254 ┃ | |
| 255 ┃ serializeCase2 :: MonadPut m => MatchCase loc Pos -> m () | |
| 256 ┃ serializeCase2 (MatchCase p guard body) = do | |
| 257 ┃ serializePattern p | |
| 258 ┃ serializeMaybe putBackref guard | |
| Delete this definition or add ‘Unison.Codecs.serializeCase2’ as a root to fix this error. | |
| src/Unison/Codecs.hs:321:1: error: serializeConstructorArities is unused | |
| 319 ┃ | |
| 320 ┃ serializeConstructorArities :: MonadPut m => Reference -> [Int] -> m () | |
| 321 ┃ serializeConstructorArities r constructorArities = do | |
| 322 ┃ serializeReference r | |
| 323 ┃ serializeFoldable (putWord32be . fromIntegral) constructorArities | |
| Delete this definition or add ‘Unison.Codecs.serializeConstructorArities’ as a root to fix this error. | |
| src/Unison/Codecs.hs:302:1: error: serializeConstructorType is unused | |
| 300 ┃ | |
| 301 ┃ serializeConstructorType :: MonadPut m => ConstructorType.ConstructorType -> m () | |
| 302 ┃ serializeConstructorType ct = case ct of | |
| 303 ┃ ConstructorType.Data -> putWord8 0 | |
| 304 ┃ ConstructorType.Effect -> putWord8 1 | |
| Delete this definition or add ‘Unison.Codecs.serializeConstructorType’ as a root to fix this error. | |
| src/Unison/Codecs.hs:328:1: error: serializeFile is unused | |
| 326 ┃ :: (MonadPut m, MonadState Pos m, Monoid a, Var v) | |
| 327 ┃ => UnisonFile v a -> Term v a -> m () | |
| 328 ┃ serializeFile uf@(UnisonFile dataDecls effectDecls _ _) tm = do | |
| 329 ┃ let body = UF.uberTerm' uf tm | |
| 330 ┃ let dataDecls' = second DD.constructorArities <$> toList dataDecls | |
| Delete this definition or add ‘Unison.Codecs.serializeFile’ as a root to fix this error. | |
| src/Unison/Codecs.hs:237:1: error: serializeFloat is unused | |
| 235 ┃ | |
| 236 ┃ serializeFloat :: MonadPut m => Double -> m () | |
| 237 ┃ serializeFloat n = do | |
| 238 ┃ putByteString . BL.toStrict . toLazyByteString $ doubleBE n | |
| 239 ┃ putWord8 3 | |
| Delete this definition or add ‘Unison.Codecs.serializeFloat’ as a root to fix this error. | |
| src/Unison/Codecs.hs:288:1: error: serializeFoldable is unused | |
| 286 ┃ | |
| 287 ┃ serializeFoldable :: (MonadPut m, Foldable f) => (a -> m ()) -> f a -> m () | |
| 288 ┃ serializeFoldable f fa = do | |
| 289 ┃ putLength $ length fa | |
| 290 ┃ traverse_ f fa | |
| Delete this definition or add ‘Unison.Codecs.serializeFoldable’ as a root to fix this error. | |
| src/Unison/Codecs.hs:247:1: error: serializeInt is unused | |
| 245 ┃ | |
| 246 ┃ serializeInt :: MonadPut m => Int64 -> m () | |
| 247 ┃ serializeInt n = do | |
| 248 ┃ putByteString . BL.toStrict . toLazyByteString $ int64BE n | |
| 249 ┃ putWord8 1 | |
| Delete this definition or add ‘Unison.Codecs.serializeInt’ as a root to fix this error. | |
| src/Unison/Codecs.hs:277:1: error: serializeMaybe is unused | |
| 275 ┃ | |
| 276 ┃ serializeMaybe :: (MonadPut m) => (a -> m ()) -> Maybe a -> m () | |
| 277 ┃ serializeMaybe f b = case b of | |
| 278 ┃ Nothing -> putWord8 0 | |
| 279 ┃ Just x -> putWord8 1 *> f x | |
| Delete this definition or add ‘Unison.Codecs.serializeMaybe’ as a root to fix this error. | |
| src/Unison/Codecs.hs:242:1: error: serializeNat is unused | |
| 240 ┃ | |
| 241 ┃ serializeNat :: MonadPut m => Word64 -> m () | |
| 242 ┃ serializeNat n = do | |
| 243 ┃ putWord64be n | |
| 244 ┃ putWord8 2 | |
| Delete this definition or add ‘Unison.Codecs.serializeNat’ as a root to fix this error. | |
| src/Unison/Codecs.hs:207:1: error: serializePattern is unused | |
| 205 ┃ | |
| 206 ┃ serializePattern :: MonadPut m => Pattern a -> m () | |
| 207 ┃ serializePattern p = case p of | |
| 208 ┃ -- note: the putWord8 0 is the tag before any unboxed pattern | |
| 209 ┃ Pattern.Boolean _ b -> putWord8 0 *> serializeBoolean b | |
| Delete this definition or add ‘Unison.Codecs.serializePattern’ as a root to fix this error. | |
| src/Unison/Codecs.hs:307:1: error: serializeReference is unused | |
| 305 ┃ | |
| 306 ┃ serializeReference :: MonadPut m => Reference -> m () | |
| 307 ┃ serializeReference ref = case ref of | |
| 308 ┃ Builtin text -> do | |
| 309 ┃ putWord8 0 | |
| Delete this definition or add ‘Unison.Codecs.serializeReference’ as a root to fix this error. | |
| src/Unison/Codecs.hs:293:1: error: serializeReferent is unused | |
| 291 ┃ | |
| 292 ┃ serializeReferent :: MonadPut m => Referent.Referent -> m () | |
| 293 ┃ serializeReferent r = case r of | |
| 294 ┃ Referent.Ref r -> putWord8 0 *> serializeReference r | |
| 295 ┃ Referent.Con r cid ct -> do | |
| Delete this definition or add ‘Unison.Codecs.serializeReferent’ as a root to fix this error. | |
| src/Unison/Codecs.hs:39:1: error: serializeTerm is unused | |
| 37 ┃ => Term v a | |
| 38 ┃ -> m Pos | |
| 39 ┃ serializeTerm x = do | |
| 40 ┃ let putTag = do putWord8 111; putWord8 0 | |
| 41 ┃ let incPosition = do pos <- get; modify' (+1); pure pos | |
| Delete this definition or add ‘Unison.Codecs.serializeTerm’ as a root to fix this error. | |
| src/Unison/CommandLine.hs:136:1: error: completion is unused | |
| 134 ┃ | |
| 135 ┃ completion :: String -> Line.Completion | |
| 136 ┃ completion s = Line.Completion s s True | |
| 137 ┃ | |
| 138 ┃ completion' :: String -> Line.Completion | |
| Delete this definition or add ‘Unison.CommandLine.completion’ as a root to fix this error. | |
| src/Unison/CommandLine.hs:139:1: error: completion' is unused | |
| 137 ┃ | |
| 138 ┃ completion' :: String -> Line.Completion | |
| 139 ┃ completion' s = Line.Completion s s False | |
| 140 ┃ | |
| 141 ┃ prettyCompletion :: (String, P.Pretty P.ColorText) -> Line.Completion | |
| Delete this definition or add ‘Unison.CommandLine.completion'’ as a root to fix this error. | |
| src/Unison/CommandLine.hs:155:1: error: fuzzyCompleteHashQualified is unused | |
| 153 ┃ | |
| 154 ┃ fuzzyCompleteHashQualified :: Names0 -> String -> [Line.Completion] | |
| 155 ┃ fuzzyCompleteHashQualified b q0@(HQ.fromString -> query) = case query of | |
| 156 ┃ Nothing -> [] | |
| 157 ┃ Just query -> | |
| Delete this definition or add ‘Unison.CommandLine.fuzzyCompleteHashQualified’ as a root to fix this error. | |
| src/Unison/CommandLine.hs:133:1: error: nothingTodo is unused | |
| 131 ┃ | |
| 132 ┃ nothingTodo :: (ListLike s Char, IsString s) => P.Pretty s -> P.Pretty s | |
| 133 ┃ nothingTodo = emojiNote "ð¶" | |
| 134 ┃ | |
| 135 ┃ completion :: String -> Line.Completion | |
| Delete this definition or add ‘Unison.CommandLine.nothingTodo’ as a root to fix this error. | |
| src/Unison/CommandLine.hs:215:1: error: plural is unused | |
| 213 ┃ -- `plural ["meow", "meow"] "cat" "cats" = "cats"` | |
| 214 ┃ plural :: Foldable f => f a -> b -> b -> b | |
| 215 ┃ plural items one other = case toList items of | |
| 216 ┃ [_] -> one | |
| 217 ┃ _ -> other | |
| Delete this definition or add ‘Unison.CommandLine.plural’ as a root to fix this error. | |
| src/Unison/CommandLine.hs:220:1: error: plural' is unused | |
| 218 ┃ | |
| 219 ┃ plural' :: Integral a => a -> b -> b -> b | |
| 220 ┃ plural' 1 one _other = one | |
| 221 ┃ plural' _ _one other = other | |
| Delete this definition or add ‘Unison.CommandLine.plural'’ as a root to fix this error. | |
| src/Unison/CommandLine.hs:145:1: error: prettyCompletion is unused | |
| 143 ┃ -- prettyCompletion (s, p) = Line.Completion s (P.toPlainUnbroken p) True | |
| 144 ┃ -- preserves formatting, but Haskeline doesn't know how to align | |
| 145 ┃ prettyCompletion (s, p) = Line.Completion s (P.toAnsiUnbroken p) True | |
| 146 ┃ | |
| 147 ┃ -- avoids adding a space after successful completion | |
| Delete this definition or add ‘Unison.CommandLine.prettyCompletion’ as a root to fix this error. | |
| src/Unison/CommandLine.hs:124:1: error: problem is unused | |
| 122 ┃ | |
| 123 ┃ problem :: (ListLike s Char, IsString s) => P.Pretty s -> P.Pretty s | |
| 124 ┃ problem = emojiNote "âï¸" | |
| 125 ┃ | |
| 126 ┃ bigproblem :: (ListLike s Char, IsString s) => P.Pretty s -> P.Pretty s | |
| Delete this definition or add ‘Unison.CommandLine.problem’ as a root to fix this error. | |
| src/Unison/CommandLine.hs:103:1: error: warnNote is unused | |
| 101 ┃ | |
| 102 ┃ warnNote :: String -> String | |
| 103 ┃ warnNote s = "â ï¸ " <> s | |
| 104 ┃ | |
| 105 ┃ backtick :: IsString s => P.Pretty s -> P.Pretty s | |
| Delete this definition or add ‘Unison.CommandLine.warnNote’ as a root to fix this error. | |
| src/Unison/CommandLine/InputPattern.hs:76:1: error: maxArgs is unused | |
| 74 ┃ | |
| 75 ┃ maxArgs :: InputPattern -> Maybe Int | |
| 76 ┃ maxArgs ip@(fmap fst . args -> args) = go args where | |
| 77 ┃ go [] = Just 0 | |
| 78 ┃ go (Required : args) = (1 +) <$> go args | |
| Delete this definition or add ‘Unison.CommandLine.InputPattern.maxArgs’ as a root to fix this error. | |
| src/Unison/CommandLine/InputPattern.hs:68:1: error: minArgs is unused | |
| 66 ┃ | |
| 67 ┃ minArgs :: InputPattern -> Int | |
| 68 ┃ minArgs ip@(fmap fst . args -> args) = go args where | |
| 69 ┃ go [] = 0 | |
| 70 ┃ go (Required : args) = 1 + go args | |
| Delete this definition or add ‘Unison.CommandLine.InputPattern.minArgs’ as a root to fix this error. | |
| src/Unison/CommandLine/InputPatterns.hs:74:1: error: helpFor is unused | |
| 72 ┃ | |
| 73 ┃ helpFor :: InputPattern -> Either (P.Pretty CT.ColorText) Input | |
| 74 ┃ helpFor p = I.parse help [I.patternName p] | |
| 75 ┃ | |
| 76 ┃ mergeBuiltins :: InputPattern | |
| Delete this definition or add ‘Unison.CommandLine.InputPatterns.helpFor’ as a root to fix this error. | |
| src/Unison/CommandLine/InputPatterns.hs:70:1: error: makeExampleEOS is unused | |
| 68 ┃ makeExampleEOS :: | |
| 69 ┃ InputPattern -> [P.Pretty CT.ColorText] -> P.Pretty CT.ColorText | |
| 70 ┃ makeExampleEOS p args = P.group $ | |
| 71 ┃ backtick (intercalateMap " " id (P.nonEmpty $ fromString (I.patternName p) : args)) <> "." | |
| 72 ┃ | |
| Delete this definition or add ‘Unison.CommandLine.InputPatterns.makeExampleEOS’ as a root to fix this error. | |
| src/Unison/CommandLine/InputPatterns.hs:56:1: error: patternName is unused | |
| 54 ┃ | |
| 55 ┃ patternName :: InputPattern -> P.Pretty P.ColorText | |
| 56 ┃ patternName = fromString . I.patternName | |
| 57 ┃ | |
| 58 ┃ -- `example list ["foo", "bar"]` (haskell) becomes `list foo bar` (pretty) | |
| Delete this definition or add ‘Unison.CommandLine.InputPatterns.patternName’ as a root to fix this error. | |
| src/Unison/CommandLine/InputPatterns.hs:317:1: error: viewByPrefix is unused | |
| 315 ┃ | |
| 316 ┃ viewByPrefix :: InputPattern | |
| 317 ┃ viewByPrefix = InputPattern | |
| 318 ┃ "view.recursive" | |
| 319 ┃ [] | |
| Delete this definition or add ‘Unison.CommandLine.InputPatterns.viewByPrefix’ as a root to fix this error. | |
| src/Unison/CommandLine/OutputMessages.hs:1872:1: error: filestatusTip is unused | |
| 1870 ┃ | |
| 1871 ┃ filestatusTip :: Pretty | |
| 1872 ┃ filestatusTip = tip "Use `help filestatus` to learn more." | |
| 1873 ┃ | |
| 1874 ┃ prettyDiff :: Names.Diff -> Pretty | |
| Delete this definition or add ‘Unison.CommandLine.OutputMessages.filestatusTip’ as a root to fix this error. | |
| src/Unison/CommandLine/OutputMessages.hs:1074:1: error: prettyRelative is unused | |
| 1072 ┃ | |
| 1073 ┃ prettyRelative :: Path.Relative -> Pretty | |
| 1074 ┃ prettyRelative = P.blue . P.shown | |
| 1075 ┃ | |
| 1076 ┃ prettySBH :: IsString s => ShortBranchHash -> P.Pretty s | |
| Delete this definition or add ‘Unison.CommandLine.OutputMessages.prettyRelative’ as a root to fix this error. | |
| src/Unison/DataDeclaration.hs:159:1: error: constructorTerms is unused | |
| 157 ┃ -> DataDeclaration v a | |
| 158 ┃ -> [(Reference.Id, Term v a, Type v a)] | |
| 159 ┃ constructorTerms hashCtor f rid dd = | |
| 160 ┃ (\((a, _, t), (i, re@(Reference.DerivedId r))) -> (r, f a re i, t)) <$> zip | |
| 161 ┃ (constructors' dd) | |
| Delete this definition or add ‘Unison.DataDeclaration.constructorTerms’ as a root to fix this error. | |
| src/Unison/DataDeclaration.hs:169:1: error: dataConstructorTerms is unused | |
| 167 ┃ -> DataDeclaration v a | |
| 168 ┃ -> [(Reference.Id, Term v a, Type v a)] | |
| 169 ┃ dataConstructorTerms = constructorTerms Term.hashConstructor Term.constructor | |
| 170 ┃ | |
| 171 ┃ effectConstructorTerms | |
| Delete this definition or add ‘Unison.DataDeclaration.dataConstructorTerms’ as a root to fix this error. | |
| src/Unison/DataDeclaration.hs:176:1: error: effectConstructorTerms is unused | |
| 174 ┃ -> EffectDeclaration v a | |
| 175 ┃ -> [(Reference.Id, Term v a, Type v a)] | |
| 176 ┃ effectConstructorTerms rid ed = | |
| 177 ┃ constructorTerms Term.hashRequest Term.request rid $ toDataDecl ed | |
| 178 ┃ | |
| Delete this definition or add ‘Unison.DataDeclaration.effectConstructorTerms’ as a root to fix this error. | |
| src/Unison/DataDeclaration.hs:93:1: error: generateConstructorRefs is unused | |
| 91 ┃ -> Int | |
| 92 ┃ -> [(ConstructorId, Reference)] | |
| 93 ┃ generateConstructorRefs hashCtor rid n = | |
| 94 ┃ (\i -> (i, hashCtor (Reference.DerivedId rid) i)) <$> [0 .. n] | |
| 95 ┃ | |
| Delete this definition or add ‘Unison.DataDeclaration.generateConstructorRefs’ as a root to fix this error. | |
| src/Unison/DataDeclaration.hs:320:1: error: hash is unused | |
| 318 ┃ hash :: (Eq v, Var v, Ord h, Accumulate h) | |
| 319 ┃ => [(v, ABT.Term F v ())] -> [(v, h)] | |
| 320 ┃ hash recursiveDecls = zip (fst <$> recursiveDecls) hashes where | |
| 321 ┃ hashes = ABT.hash <$> toLetRec recursiveDecls | |
| 322 ┃ | |
| Delete this definition or add ‘Unison.DataDeclaration.hash’ as a root to fix this error. | |
| src/Unison/DataDeclaration.hs:273:1: error: mkDataDecl is unused | |
| 271 ┃ | |
| 272 ┃ mkDataDecl :: Modifier -> [v] -> [(v, Type v ())] -> DataDeclaration v () | |
| 273 ┃ mkDataDecl m b cs = mkDataDecl' m () b $ map (\(v,t) -> ((),v,t)) cs | |
| 274 ┃ | |
| 275 ┃ constructorArities :: DataDeclaration v a -> [Int] | |
| Delete this definition or add ‘Unison.DataDeclaration.mkDataDecl’ as a root to fix this error. | |
| src/Unison/DataDeclaration.hs:266:1: error: mkEffectDecl is unused | |
| 264 ┃ | |
| 265 ┃ mkEffectDecl :: Modifier -> [v] -> [(v, Type v ())] -> EffectDeclaration v () | |
| 266 ┃ mkEffectDecl m b cs = mkEffectDecl' m () b $ map (\(v, t) -> ((), v, t)) cs | |
| 267 ┃ | |
| 268 ┃ mkDataDecl' | |
| Delete this definition or add ‘Unison.DataDeclaration.mkEffectDecl’ as a root to fix this error. | |
| src/Unison/DataDeclaration.hs:236:1: error: third is unused | |
| 234 ┃ | |
| 235 ┃ third :: (a -> b) -> (x,y,a) -> (x,y,b) | |
| 236 ┃ third f (x,y,a) = (x, y, f a) | |
| 237 ┃ | |
| 238 ┃ -- implementation of dataDeclToNames and effectDeclToNames | |
| Delete this definition or add ‘Unison.DataDeclaration.third’ as a root to fix this error. | |
| src/Unison/DataDeclaration.hs:324:1: error: toLetRec is unused | |
| 322 ┃ | |
| 323 ┃ toLetRec :: Ord v => [(v, ABT.Term F v ())] -> [ABT.Term F v ()] | |
| 324 ┃ toLetRec decls = do1 <$> vs | |
| 325 ┃ where | |
| 326 ┃ (vs, decls') = unzip decls | |
| Delete this definition or add ‘Unison.DataDeclaration.toLetRec’ as a root to fix this error. | |
| src/Unison/DataDeclaration.hs:332:1: error: unsafeUnwrapType is unused | |
| 330 ┃ | |
| 331 ┃ unsafeUnwrapType :: (Var v) => ABT.Term F v a -> Type v a | |
| 332 ┃ unsafeUnwrapType typ = ABT.transform f typ | |
| 333 ┃ where f (Type t) = t | |
| 334 ┃ f _ = error $ "Tried to unwrap a type that wasn't a type: " ++ show typ | |
| Delete this definition or add ‘Unison.DataDeclaration.unsafeUnwrapType’ as a root to fix this error. | |
| src/Unison/DataDeclaration.hs:80:1: error: withEffectDecl is unused | |
| 78 ┃ :: (DataDeclaration v a -> DataDeclaration v' a') | |
| 79 ┃ -> (EffectDeclaration v a -> EffectDeclaration v' a') | |
| 80 ┃ withEffectDecl f e = EffectDeclaration (f . toDataDecl $ e) | |
| 81 ┃ | |
| 82 ┃ withEffectDeclM :: Functor f | |
| Delete this definition or add ‘Unison.DataDeclaration.withEffectDecl’ as a root to fix this error. | |
| src/Unison/HashQualified'.hs:33:1: error: fromHQ is unused | |
| 31 ┃ | |
| 32 ┃ fromHQ :: HQ.HashQualified' n -> Maybe (HashQualified' n) | |
| 33 ┃ fromHQ = \case | |
| 34 ┃ HQ.NameOnly n -> Just $ NameOnly n | |
| 35 ┃ HQ.HashQualified n sh -> Just $ HashQualified n sh | |
| Delete this definition or add ‘Unison.HashQualified'.fromHQ’ as a root to fix this error. | |
| src/Unison/HashQualified.hs:130:1: error: fromName is unused | |
| 128 ┃ | |
| 129 ┃ fromName :: n -> HashQualified' n | |
| 130 ┃ fromName = NameOnly | |
| 131 ┃ | |
| 132 ┃ unsafeFromVar :: Var v => v -> HashQualified | |
| Delete this definition or add ‘Unison.HashQualified.fromName’ as a root to fix this error. | |
| src/Unison/HashQualified.hs:136:1: error: fromVar is unused | |
| 134 ┃ | |
| 135 ┃ fromVar :: Var v => v -> Maybe HashQualified | |
| 136 ┃ fromVar = fromText . Var.name | |
| 137 ┃ | |
| 138 ┃ toVar :: Var v => HashQualified -> v | |
| Delete this definition or add ‘Unison.HashQualified.fromVar’ as a root to fix this error. | |
| src/Unison/HashQualified.hs:57:1: error: hasName is unused | |
| 55 ┃ | |
| 56 ┃ hasName, hasHash :: HashQualified -> Bool | |
| 57 ┃ hasName = isJust . toName | |
| 58 ┃ hasHash = isJust . toHash | |
| 59 ┃ | |
| Delete this definition or add ‘Unison.HashQualified.hasName’ as a root to fix this error. | |
| src/Unison/LabeledDependency.hs:35:1: error: derivedTerm is unused | |
| 33 ┃ | |
| 34 ┃ derivedType = X . Left . DerivedId | |
| 35 ┃ derivedTerm = X . Right . Ref . DerivedId | |
| 36 ┃ typeRef = X . Left | |
| 37 ┃ termRef = X . Right . Ref | |
| Delete this definition or add ‘Unison.LabeledDependency.derivedTerm’ as a root to fix this error. | |
| src/Unison/LabeledDependency.hs:34:1: error: derivedType is unused | |
| 32 ┃ effectConstructor :: Reference -> Int -> LabeledDependency | |
| 33 ┃ | |
| 34 ┃ derivedType = X . Left . DerivedId | |
| 35 ┃ derivedTerm = X . Right . Ref . DerivedId | |
| 36 ┃ typeRef = X . Left | |
| Delete this definition or add ‘Unison.LabeledDependency.derivedType’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _Backticks is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._Backticks’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _Blank is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._Blank’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _Bytes is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._Bytes’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _Character is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._Character’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _Close is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._Close’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _Err is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._Err’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _Hash is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._Hash’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _Numeric is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._Numeric’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _Open is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._Open’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _Reserved is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._Reserved’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _Semi is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._Semi’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _SymbolyId is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._SymbolyId’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _Textual is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._Textual’ as a root to fix this error. | |
| src/Unison/Lexer.hs:100:1: error: _WordyId is unused | |
| 98 ┃ type IsVirtual = Bool -- is it a virtual semi or an actual semi? | |
| 99 ┃ | |
| 100 ┃ makePrisms ''Lexeme | |
| 101 ┃ | |
| 102 ┃ space :: P () | |
| Delete this definition or add ‘Unison.Lexer._WordyId’ as a root to fix this error. | |
| src/Unison/Name.hs:104:1: error: _stripTextPrefix is unused | |
| 102 ┃ -- stripTextPrefix "" a.b.c = undefined | |
| 103 ┃ _stripTextPrefix :: Text -> Name -> Maybe Name | |
| 104 ┃ _stripTextPrefix prefix name = | |
| 105 ┃ Name <$> Text.stripPrefix prefix (toText name) | |
| 106 ┃ | |
| Delete this definition or add ‘Unison.Name._stripTextPrefix’ as a root to fix this error. | |
| src/Unison/Name.hs:89:1: error: isPrefixOf is unused | |
| 87 ┃ | |
| 88 ┃ isPrefixOf :: Name -> Name -> Bool | |
| 89 ┃ a `isPrefixOf` b = toText a `Text.isPrefixOf` toText b | |
| 90 ┃ | |
| 91 ┃ -- foo.bar.baz `endsWithSegments` bar.baz == True | |
| Delete this definition or add ‘Unison.Name.isPrefixOf’ as a root to fix this error. | |
| src/Unison/Name.hs:67:1: error: sortNamed' is unused | |
| 65 ┃ -- names are equal. | |
| 66 ┃ sortNamed' :: (a -> Name) -> (a -> a -> Ordering) -> [a] -> [a] | |
| 67 ┃ sortNamed' by by2 as = let | |
| 68 ┃ as' = [ (a, toText (by a)) | a <- as ] | |
| 69 ┃ comp (a,s) (a2,s2) = RFC5051.compareUnicode s s2 <> by2 a a2 | |
| Delete this definition or add ‘Unison.Name.sortNamed'’ as a root to fix this error. | |
| src/Unison/Name.hs:53:1: error: sortNames is unused | |
| 51 ┃ | |
| 52 ┃ sortNames :: [Name] -> [Name] | |
| 53 ┃ sortNames = sortNamed id | |
| 54 ┃ | |
| 55 ┃ sortNamed :: (a -> Name) -> [a] -> [a] | |
| Delete this definition or add ‘Unison.Name.sortNames’ as a root to fix this error. | |
| src/Unison/Name.hs:120:1: error: stripPrefixes is unused | |
| 118 ┃ -- a.b.c.d -> d | |
| 119 ┃ stripPrefixes :: Name -> Name | |
| 120 ┃ stripPrefixes = fromSegment . last . segments | |
| 121 ┃ | |
| 122 ┃ joinDot :: Name -> Name -> Name | |
| Delete this definition or add ‘Unison.Name.stripPrefixes’ as a root to fix this error. | |
| src/Unison/NameSegment.hs:28:1: error: isEmpty is unused | |
| 26 ┃ | |
| 27 ┃ isEmpty :: NameSegment -> Bool | |
| 28 ┃ isEmpty ns = toText ns == mempty | |
| 29 ┃ | |
| 30 ┃ isPrefixOf :: NameSegment -> NameSegment -> Bool | |
| Delete this definition or add ‘Unison.NameSegment.isEmpty’ as a root to fix this error. | |
| src/Unison/NameSegment.hs:31:1: error: isPrefixOf is unused | |
| 29 ┃ | |
| 30 ┃ isPrefixOf :: NameSegment -> NameSegment -> Bool | |
| 31 ┃ isPrefixOf n1 n2 = Text.isPrefixOf (toText n1) (toText n2) | |
| 32 ┃ | |
| 33 ┃ toString :: NameSegment -> String | |
| Delete this definition or add ‘Unison.NameSegment.isPrefixOf’ as a root to fix this error. | |
| src/Unison/Names2.hs:148:1: error: _unionLeftRef is unused | |
| 146 ┃ -- = [foo -> #a, bar -> #a, foo -> #b, cat -> #c] | |
| 147 ┃ _unionLeftRef :: Ord n => Names' n -> Names' n -> Names' n | |
| 148 ┃ _unionLeftRef = unionLeft' $ const R.memberRan | |
| 149 ┃ | |
| 150 ┃ -- unionLeft two Names, but don't create new aliases or new name conflicts. | |
| Delete this definition or add ‘Unison.Names2._unionLeftRef’ as a root to fix this error. | |
| src/Unison/Names2.hs:288:1: error: filter is unused | |
| 286 ┃ | |
| 287 ┃ filter :: Ord n => (n -> Bool) -> Names' n -> Names' n | |
| 288 ┃ filter f (Names terms types) = Names (R.filterDom f terms) (R.filterDom f types) | |
| 289 ┃ | |
| 290 ┃ -- currently used for filtering before a conditional `add` | |
| Delete this definition or add ‘Unison.Names2.filter’ as a root to fix this error. | |
| src/Unison/Names2.hs:306:1: error: filterTypes is unused | |
| 304 ┃ | |
| 305 ┃ filterTypes :: Ord n => (n -> Bool) -> Names' n -> Names' n | |
| 306 ┃ filterTypes f (Names terms types) = Names terms (R.filterDom f types) | |
| 307 ┃ | |
| 308 ┃ difference :: Ord n => Names' n -> Names' n -> Names' n | |
| Delete this definition or add ‘Unison.Names2.filterTypes’ as a root to fix this error. | |
| src/Unison/Names3.hs:55:1: error: filterTypes is unused | |
| 53 ┃ | |
| 54 ┃ filterTypes :: (Name -> Bool) -> Names0 -> Names0 | |
| 55 ┃ filterTypes = Unison.Names2.filterTypes | |
| 56 ┃ | |
| 57 ┃ -- Simple 2 way diff, has the property that: | |
| Delete this definition or add ‘Unison.Names3.filterTypes’ as a root to fix this error. | |
| src/Unison/Names3.hs:141:1: error: hasTermNamed is unused | |
| 139 ┃ | |
| 140 ┃ hasTermNamed :: Name -> Names -> Bool | |
| 141 ┃ hasTermNamed n ns = not (Set.null $ lookupHQTerm (HQ.NameOnly n) ns) | |
| 142 ┃ | |
| 143 ┃ hasTypeNamed :: Name -> Names -> Bool | |
| Delete this definition or add ‘Unison.Names3.hasTermNamed’ as a root to fix this error. | |
| src/Unison/Names3.hs:79:1: error: isEmpty0 is unused | |
| 77 ┃ | |
| 78 ┃ isEmpty0 :: Names0 -> Bool | |
| 79 ┃ isEmpty0 n = R.null (terms0 n) && R.null (types0 n) | |
| 80 ┃ | |
| 81 ┃ -- Add `n1` to `currentNames`, shadowing anything with the same name and | |
| Delete this definition or add ‘Unison.Names3.isEmpty0’ as a root to fix this error. | |
| src/Unison/Names3.hs:76:1: error: isEmptyDiff is unused | |
| 74 ┃ | |
| 75 ┃ isEmptyDiff :: Diff -> Bool | |
| 76 ┃ isEmptyDiff d = isEmpty0 (addedNames d) && isEmpty0 (removedNames d) | |
| 77 ┃ | |
| 78 ┃ isEmpty0 :: Names0 -> Bool | |
| Delete this definition or add ‘Unison.Names3.isEmptyDiff’ as a root to fix this error. | |
| src/Unison/Parsers.hs:63:1: error: readAndParseFile is unused | |
| 61 ┃ -> FilePath | |
| 62 ┃ -> IO (Either (Parser.Err v) (UnisonFile v Ann)) | |
| 63 ┃ readAndParseFile penv fileName = do | |
| 64 ┃ txt <- readFile fileName | |
| 65 ┃ let src = Text.unpack txt | |
| Delete this definition or add ‘Unison.Parsers.readAndParseFile’ as a root to fix this error. | |
| src/Unison/Parsers.hs:80:1: error: unsafeParseFileBuiltinsOnly is unused | |
| 78 ┃ unsafeParseFileBuiltinsOnly | |
| 79 ┃ :: FilePath -> IO (UnisonFile Symbol Ann) | |
| 80 ┃ unsafeParseFileBuiltinsOnly = | |
| 81 ┃ unsafeReadAndParseFile $ Parser.ParsingEnv | |
| 82 ┃ mempty | |
| Delete this definition or add ‘Unison.Parsers.unsafeParseFileBuiltinsOnly’ as a root to fix this error. | |
| src/Unison/Parsers.hs:69:1: error: unsafeParseTerm is unused | |
| 67 ┃ | |
| 68 ┃ unsafeParseTerm :: Var v => String -> Parser.ParsingEnv -> Term v Ann | |
| 69 ┃ unsafeParseTerm s = fmap (unsafeGetRightFrom s) . parseTerm $ s | |
| 70 ┃ | |
| 71 ┃ unsafeReadAndParseFile | |
| Delete this definition or add ‘Unison.Parsers.unsafeParseTerm’ as a root to fix this error. | |
| src/Unison/Parsers.hs:73:1: error: unsafeReadAndParseFile is unused | |
| 71 ┃ unsafeReadAndParseFile | |
| 72 ┃ :: Parser.ParsingEnv -> FilePath -> IO (UnisonFile Symbol Ann) | |
| 73 ┃ unsafeReadAndParseFile penv fileName = do | |
| 74 ┃ txt <- readFile fileName | |
| 75 ┃ let str = Text.unpack txt | |
| Delete this definition or add ‘Unison.Parsers.unsafeReadAndParseFile’ as a root to fix this error. | |
| src/Unison/Path.hs:33:1: error: isSubpath is unused | |
| 31 ┃ -- | `isSubpath p1 p2` is true if `p2 == extend p1 x` for some `x` | |
| 32 ┃ isSubpath :: (Eq p, Path p) => p -> p -> Bool | |
| 33 ┃ isSubpath p1 p2 = lca p1 p2 == p1 | |
| 34 ┃ | |
| 35 ┃ instance Eq a => Path (Maybe a) where | |
| Delete this definition or add ‘Unison.Path.isSubpath’ as a root to fix this error. | |
| src/Unison/Path.hs:29:1: error: lca is unused | |
| 27 ┃ -- | Compute the lowest common ancestor of two paths | |
| 28 ┃ lca :: Path p => p -> p -> p | |
| 29 ┃ lca p p2 = fst (factor p p2) | |
| 30 ┃ | |
| 31 ┃ -- | `isSubpath p1 p2` is true if `p2 == extend p1 x` for some `x` | |
| Delete this definition or add ‘Unison.Path.lca’ as a root to fix this error. | |
| src/Unison/Paths.hs:203:1: error: asDeclaration is unused | |
| 201 ┃ | |
| 202 ┃ asDeclaration :: Target v -> Maybe (v, Term v) | |
| 203 ┃ asDeclaration (Declaration v b) = Just (v,b) | |
| 204 ┃ asDeclaration _ = Nothing | |
| Delete this definition or add ‘Unison.Paths.asDeclaration’ as a root to fix this error. | |
| src/Unison/Paths.hs:191:1: error: asTerm is unused | |
| 189 ┃ | |
| 190 ┃ asTerm :: Target v -> Maybe (Term v) | |
| 191 ┃ asTerm (Term t) = Just t | |
| 192 ┃ asTerm _ = Nothing | |
| 193 ┃ | |
| Delete this definition or add ‘Unison.Paths.asTerm’ as a root to fix this error. | |
| src/Unison/Paths.hs:195:1: error: asType is unused | |
| 193 ┃ | |
| 194 ┃ asType :: Target v -> Maybe (Type v) | |
| 195 ┃ asType (Type t) = Just t | |
| 196 ┃ asType _ = Nothing | |
| 197 ┃ | |
| Delete this definition or add ‘Unison.Paths.asType’ as a root to fix this error. | |
| src/Unison/Paths.hs:199:1: error: asVar is unused | |
| 197 ┃ | |
| 198 ┃ asVar :: Target v -> Maybe v | |
| 199 ┃ asVar (Var v) = Just v | |
| 200 ┃ asVar _ = Nothing | |
| 201 ┃ | |
| Delete this definition or add ‘Unison.Paths.asVar’ as a root to fix this error. | |
| src/Unison/Paths.hs:126:1: error: at is unused | |
| 124 ┃ | |
| 125 ┃ at :: Var v => Path -> Target v -> Maybe (Target v) | |
| 126 ┃ at path t = (\(a,_,_) -> a) <$> focus path t | |
| 127 ┃ | |
| 128 ┃ atTerm :: Var v => Path -> Term v -> Maybe (Term v) | |
| Delete this definition or add ‘Unison.Paths.at’ as a root to fix this error. | |
| src/Unison/Paths.hs:129:1: error: atTerm is unused | |
| 127 ┃ | |
| 128 ┃ atTerm :: Var v => Path -> Term v -> Maybe (Term v) | |
| 129 ┃ atTerm path t = asTerm =<< at path (Term t) | |
| 130 ┃ | |
| 131 ┃ atType :: Var v => Path -> Type v -> Maybe (Type v) | |
| Delete this definition or add ‘Unison.Paths.atTerm’ as a root to fix this error. | |
| src/Unison/Paths.hs:132:1: error: atType is unused | |
| 130 ┃ | |
| 131 ┃ atType :: Var v => Path -> Type v -> Maybe (Type v) | |
| 132 ┃ atType path t = asType =<< at path (Type t) | |
| 133 ┃ | |
| 134 ┃ modify :: Var v => (Target v -> Target (V v)) -> Path -> Target v -> Maybe (Target v) | |
| Delete this definition or add ‘Unison.Paths.atType’ as a root to fix this error. | |
| src/Unison/Paths.hs:122:1: error: focus is unused | |
| 120 ┃ | |
| 121 ┃ focus :: Var v => Path -> Target v -> Maybe (Target v, Target (V v) -> Maybe (Target v), [v]) | |
| 122 ┃ focus p t = tweak <$> ABT.focus (foldr ABT.compose ABT.here (map focus1 p)) t where | |
| 123 ┃ tweak (get, set, vs) = (get, \t -> vmap ABT.unvar <$> set t, vs) | |
| 124 ┃ | |
| Delete this definition or add ‘Unison.Paths.focus’ as a root to fix this error. | |
| src/Unison/Paths.hs:47:1: error: focus1 is unused | |
| 45 ┃ => PathElement | |
| 46 ┃ -> ABT.Path (Target v) (Target (V v)) (Target v) (Target (V v)) [v] | |
| 47 ┃ focus1 e = ABT.Path go' | |
| 48 ┃ where | |
| 49 ┃ go' t = go e t | |
| Delete this definition or add ‘Unison.Paths.focus1’ as a root to fix this error. | |
| src/Unison/Paths.hs:153:1: error: inScopeAt is unused | |
| 151 ┃ | |
| 152 ┃ inScopeAt :: Var v => Path -> Target v -> [v] | |
| 153 ┃ inScopeAt p t = maybe [] (\(_,_,vs) -> vs) (focus p t) | |
| 154 ┃ | |
| 155 ┃ inScopeAtTerm :: Var v => Path -> Term v -> [v] | |
| Delete this definition or add ‘Unison.Paths.inScopeAt’ as a root to fix this error. | |
| src/Unison/Paths.hs:156:1: error: inScopeAtTerm is unused | |
| 154 ┃ | |
| 155 ┃ inScopeAtTerm :: Var v => Path -> Term v -> [v] | |
| 156 ┃ inScopeAtTerm p t = inScopeAt p (Term t) | |
| 157 ┃ | |
| 158 ┃ inScopeAtType :: Var v => Path -> Type v -> [v] | |
| Delete this definition or add ‘Unison.Paths.inScopeAtTerm’ as a root to fix this error. | |
| src/Unison/Paths.hs:159:1: error: inScopeAtType is unused | |
| 157 ┃ | |
| 158 ┃ inScopeAtType :: Var v => Path -> Type v -> [v] | |
| 159 ┃ inScopeAtType p t = inScopeAt p (Type t) | |
| 160 ┃ | |
| 161 ┃ insertTerm :: Var v => Path -> Term v -> Maybe (Term v) | |
| Delete this definition or add ‘Unison.Paths.inScopeAtType’ as a root to fix this error. | |
| src/Unison/Paths.hs:162:1: error: insertTerm is unused | |
| 160 ┃ | |
| 161 ┃ insertTerm :: Var v => Path -> Term v -> Maybe (Term v) | |
| 162 ┃ insertTerm at _ | null at = Nothing | |
| 163 ┃ insertTerm at ctx = do | |
| 164 ┃ let at' = init at | |
| Delete this definition or add ‘Unison.Paths.insertTerm’ as a root to fix this error. | |
| src/Unison/Paths.hs:135:1: error: modify is unused | |
| 133 ┃ | |
| 134 ┃ modify :: Var v => (Target v -> Target (V v)) -> Path -> Target v -> Maybe (Target v) | |
| 135 ┃ modify f path t = focus path t >>= \(at,set,_) -> set (f at) | |
| 136 ┃ | |
| 137 ┃ modifyTerm :: Var v => (Term v -> Term (V v)) -> Path -> Term v -> Maybe (Term v) | |
| Delete this definition or add ‘Unison.Paths.modify’ as a root to fix this error. | |
| src/Unison/Paths.hs:138:1: error: modifyTerm is unused | |
| 136 ┃ | |
| 137 ┃ modifyTerm :: Var v => (Term v -> Term (V v)) -> Path -> Term v -> Maybe (Term v) | |
| 138 ┃ modifyTerm f p t = do | |
| 139 ┃ (at,set,_) <- focus p (Term t) | |
| 140 ┃ t <- asTerm at | |
| Delete this definition or add ‘Unison.Paths.modifyTerm’ as a root to fix this error. | |
| src/Unison/Paths.hs:144:1: error: modifyTerm' is unused | |
| 142 ┃ | |
| 143 ┃ modifyTerm' :: Var v => (Term v -> Term (V v)) -> Path -> Term v -> Term v | |
| 144 ┃ modifyTerm' f p t = fromMaybe t $ modifyTerm f p t | |
| 145 ┃ | |
| 146 ┃ modifyType :: Var v => (Type v -> Type (V v)) -> Path -> Type v -> Maybe (Type v) | |
| Delete this definition or add ‘Unison.Paths.modifyTerm'’ as a root to fix this error. | |
| src/Unison/Paths.hs:147:1: error: modifyType is unused | |
| 145 ┃ | |
| 146 ┃ modifyType :: Var v => (Type v -> Type (V v)) -> Path -> Type v -> Maybe (Type v) | |
| 147 ┃ modifyType f p t = do | |
| 148 ┃ (at,set,_) <- focus p (Type t) | |
| 149 ┃ t <- asType at | |
| Delete this definition or add ‘Unison.Paths.modifyType’ as a root to fix this error. | |
| src/Unison/Paths.hs:184:1: error: parent is unused | |
| 182 ┃ | |
| 183 ┃ parent :: Path -> Maybe Path | |
| 184 ┃ parent [] = Nothing | |
| 185 ┃ parent p = Just (init p) | |
| 186 ┃ | |
| Delete this definition or add ‘Unison.Paths.parent’ as a root to fix this error. | |
| src/Unison/Paths.hs:188:1: error: parent' is unused | |
| 186 ┃ | |
| 187 ┃ parent' :: Path -> Path | |
| 188 ┃ parent' = fromMaybe [] . parent | |
| 189 ┃ | |
| 190 ┃ asTerm :: Target v -> Maybe (Term v) | |
| Delete this definition or add ‘Unison.Paths.parent'’ as a root to fix this error. | |
| src/Unison/Paths.hs:181:1: error: pathExtend is unused | |
| 179 ┃ -- | Add an element onto the end of this 'Path' | |
| 180 ┃ pathExtend :: PathElement -> Path -> Path | |
| 181 ┃ pathExtend e p = p ++ [e] | |
| 182 ┃ | |
| 183 ┃ parent :: Path -> Maybe Path | |
| Delete this definition or add ‘Unison.Paths.pathExtend’ as a root to fix this error. | |
| src/Unison/Paths.hs:177:1: error: pathPrefixes is unused | |
| 175 ┃ -- | Return the list of all prefixes of the input path | |
| 176 ┃ pathPrefixes :: Path -> [Path] | |
| 177 ┃ pathPrefixes = inits | |
| 178 ┃ | |
| 179 ┃ -- | Add an element onto the end of this 'Path' | |
| Delete this definition or add ‘Unison.Paths.pathPrefixes’ as a root to fix this error. | |
| src/Unison/Paths.hs:26:1: error: vmap is unused | |
| 24 ┃ | |
| 25 ┃ vmap :: Ord v2 => (v -> v2) -> Target v -> Target v2 | |
| 26 ┃ vmap f (Var v) = Var (f v) | |
| 27 ┃ vmap f (Declaration v b) = Declaration (f v) (E.vmap f b) | |
| 28 ┃ vmap f (Term t) = Term (E.vmap f t) | |
| Delete this definition or add ‘Unison.Paths.vmap’ as a root to fix this error. | |
| src/Unison/Pattern.hs:64:1: error: application is unused | |
| 62 ┃ | |
| 63 ┃ application :: Pattern loc -> Bool | |
| 64 ┃ application (Constructor _ _ _ (_ : _)) = True | |
| 65 ┃ application _ = False | |
| 66 ┃ | |
| Delete this definition or add ‘Unison.Pattern.application’ as a root to fix this error. | |
| src/Unison/Pattern.hs:161:1: error: labeledDependencies is unused | |
| 159 ┃ | |
| 160 ┃ labeledDependencies :: Pattern loc -> Set LabeledDependency | |
| 161 ┃ labeledDependencies = generalizedDependencies LD.typeRef | |
| 162 ┃ LD.dataConstructor | |
| 163 ┃ LD.typeRef | |
| Delete this definition or add ‘Unison.Pattern.labeledDependencies’ as a root to fix this error. | |
| src/Unison/PrettyPrintEnv.hs:86:1: error: assignTermName is unused | |
| 84 ┃ | |
| 85 ┃ assignTermName :: Referent -> HashQualified -> PrettyPrintEnv -> PrettyPrintEnv | |
| 86 ┃ assignTermName r name = (fromTermNames [(r,name)] `unionLeft`) | |
| 87 ┃ | |
| 88 ┃ fromTypeNames :: [(Reference,HashQualified)] -> PrettyPrintEnv | |
| Delete this definition or add ‘Unison.PrettyPrintEnv.assignTermName’ as a root to fix this error. | |
| src/Unison/PrettyPrintEnv.hs:94:1: error: fromTermNames is unused | |
| 92 ┃ | |
| 93 ┃ fromTermNames :: [(Referent,HashQualified)] -> PrettyPrintEnv | |
| 94 ┃ fromTermNames tms = let | |
| 95 ┃ m = Map.fromList tms | |
| 96 ┃ in PrettyPrintEnv (`Map.lookup` m) (const Nothing) | |
| Delete this definition or add ‘Unison.PrettyPrintEnv.fromTermNames’ as a root to fix this error. | |
| src/Unison/PrettyPrintEnv.hs:89:1: error: fromTypeNames is unused | |
| 87 ┃ | |
| 88 ┃ fromTypeNames :: [(Reference,HashQualified)] -> PrettyPrintEnv | |
| 89 ┃ fromTypeNames types = let | |
| 90 ┃ m = Map.fromList types | |
| 91 ┃ in PrettyPrintEnv (const Nothing) (`Map.lookup` m) | |
| Delete this definition or add ‘Unison.PrettyPrintEnv.fromTypeNames’ as a root to fix this error. | |
| src/Unison/PrettyTerminal.hs:11:1: error: stripSurroundingBlanks is unused | |
| 9 ┃ | |
| 10 ┃ stripSurroundingBlanks :: String -> String | |
| 11 ┃ stripSurroundingBlanks s = unlines (dropWhile isBlank . dropWhileEnd isBlank $ lines s) where | |
| 12 ┃ isBlank line = all isSpace line | |
| 13 ┃ | |
| Delete this definition or add ‘Unison.PrettyTerminal.stripSurroundingBlanks’ as a root to fix this error. | |
| src/Unison/PrintError.hs:882:1: error: _posToEnglish is unused | |
| 880 ┃ | |
| 881 ┃ _posToEnglish :: IsString s => L.Pos -> s | |
| 882 ┃ _posToEnglish (L.Pos l c) = | |
| 883 ┃ fromString $ "Line " ++ show l ++ ", Column " ++ show c | |
| 884 ┃ | |
| Delete this definition or add ‘Unison.PrintError._posToEnglish’ as a root to fix this error. | |
| src/Unison/PrintError.hs:968:1: error: _printArrowsAtPos is unused | |
| 966 ┃ | |
| 967 ┃ _printArrowsAtPos :: String -> Int -> Int -> String | |
| 968 ┃ _printArrowsAtPos s line column = | |
| 969 ┃ let lineCaret s i = s ++ if i == line then "\n" ++ columnCaret else "" | |
| 970 ┃ columnCaret = replicate (column - 1) '-' ++ "^" | |
| Delete this definition or add ‘Unison.PrintError._printArrowsAtPos’ as a root to fix this error. | |
| src/Unison/PrintError.hs:962:1: error: _printPosRange is unused | |
| 960 ┃ | |
| 961 ┃ _printPosRange :: String -> L.Pos -> L.Pos -> String | |
| 962 ┃ _printPosRange s (L.Pos startLine startCol) _end = | |
| 963 ┃ -- todo: multi-line ranges | |
| 964 ┃ -- todo: ranges | |
| Delete this definition or add ‘Unison.PrintError._printPosRange’ as a root to fix this error. | |
| src/Unison/PrintError.hs:839:1: error: arrows is unused | |
| 837 ┃ | |
| 838 ┃ arrows :: (IsString a, Monoid a) => (b -> a) -> [b] -> a | |
| 839 ┃ arrows = intercalateMap " ->" | |
| 840 ┃ | |
| 841 ┃ commas :: (IsString a, Monoid a) => (b -> a) -> [b] -> a | |
| Delete this definition or add ‘Unison.PrintError.arrows’ as a root to fix this error. | |
| src/Unison/PrintError.hs:1328:1: error: findTerm is unused | |
| 1326 ┃ | |
| 1327 ┃ findTerm :: Seq (C.PathElement v loc) -> Maybe loc | |
| 1328 ┃ findTerm = go | |
| 1329 ┃ where | |
| 1330 ┃ go (C.InSynthesize t :<| _) = Just $ ABT.annotation t | |
| Delete this definition or add ‘Unison.PrintError.findTerm’ as a root to fix this error. | |
| src/Unison/PrintError.hs:978:1: error: firstLexerError is unused | |
| 976 ┃ | |
| 977 ┃ firstLexerError :: Foldable t => t (L.Token L.Lexeme) -> Maybe ([L.Token L.Lexeme], L.Err) | |
| 978 ┃ firstLexerError ts = | |
| 979 ┃ find (const True) [ (toList ts, e) | (L.payload -> L.Err e) <- toList ts ] | |
| 980 ┃ | |
| Delete this definition or add ‘Unison.PrintError.firstLexerError’ as a root to fix this error. | |
| src/Unison/PrintError.hs:96:1: error: showTypeWithProvenance is unused | |
| 94 ┃ -> Type v a | |
| 95 ┃ -> Pretty (AnnotatedText style) | |
| 96 ┃ showTypeWithProvenance env src color typ = | |
| 97 ┃ style color (renderType' env typ) | |
| 98 ┃ <> ".\n" | |
| Delete this definition or add ‘Unison.PrintError.showTypeWithProvenance’ as a root to fix this error. | |
| src/Unison/PrintError.hs:877:1: error: styleInOverallType is unused | |
| 875 ┃ -> Color | |
| 876 ┃ -> Pretty ColorText | |
| 877 ┃ styleInOverallType e overallType leafType c = renderType e f overallType | |
| 878 ┃ where | |
| 879 ┃ f loc s = if loc == ABT.annotation leafType then Color.style c <$> s else s | |
| Delete this definition or add ‘Unison.PrintError.styleInOverallType’ as a root to fix this error. | |
| src/Unison/PrintError.hs:1312:1: error: tokensAsErrorSite is unused | |
| 1310 ┃ | |
| 1311 ┃ tokensAsErrorSite :: String -> [L.Token a] -> Pretty ColorText | |
| 1312 ┃ tokensAsErrorSite src ts = | |
| 1313 ┃ showSource src [(rangeForToken t, ErrorSite) | t <- ts ] | |
| 1314 ┃ | |
| Delete this definition or add ‘Unison.PrintError.tokensAsErrorSite’ as a root to fix this error. | |
| src/Unison/Reference.hs:166:1: error: groupByComponent is unused | |
| 164 ┃ | |
| 165 ┃ groupByComponent :: [(k, Reference)] -> [[(k, Reference)]] | |
| 166 ┃ groupByComponent refs = done $ foldl' insert Map.empty refs | |
| 167 ┃ where | |
| 168 ┃ insert m (k, r@(Derived h _ _)) = | |
| Delete this definition or add ‘Unison.Reference.groupByComponent’ as a root to fix this error. | |
| src/Unison/Reference.hs:108:1: error: showShort is unused | |
| 106 ┃ | |
| 107 ┃ showShort :: Int -> Reference -> Text | |
| 108 ┃ showShort numHashChars = SH.toText . SH.take numHashChars . toShortHash | |
| 109 ┃ | |
| 110 ┃ type Pos = Word64 | |
| Delete this definition or add ‘Unison.Reference.showShort’ as a root to fix this error. | |
| src/Unison/Reference.hs:130:1: error: unsafeFromText is unused | |
| 128 ┃ | |
| 129 ┃ unsafeFromText :: Text -> Reference | |
| 130 ┃ unsafeFromText = either error id . fromText | |
| 131 ┃ | |
| 132 ┃ idFromText :: Text -> Maybe Id | |
| Delete this definition or add ‘Unison.Reference.unsafeFromText’ as a root to fix this error. | |
| src/Unison/Referent.hs:54:1: error: showShort is unused | |
| 52 ┃ | |
| 53 ┃ showShort :: Int -> Referent -> Text | |
| 54 ┃ showShort numHashChars = SH.toText . SH.take numHashChars . toShortHash | |
| 55 ┃ | |
| 56 ┃ toText :: Referent -> Text | |
| Delete this definition or add ‘Unison.Referent.showShort’ as a root to fix this error. | |
| src/Unison/Referent.hs:69:1: error: toString is unused | |
| 67 ┃ | |
| 68 ┃ toString :: Referent -> String | |
| 69 ┃ toString = Text.unpack . toText | |
| 70 ┃ | |
| 71 ┃ isConstructor :: Referent -> Bool | |
| Delete this definition or add ‘Unison.Referent.toString’ as a root to fix this error. | |
| src/Unison/Referent.hs:76:1: error: toTermReference is unused | |
| 74 ┃ | |
| 75 ┃ toTermReference :: Referent -> Maybe Reference | |
| 76 ┃ toTermReference = \case | |
| 77 ┃ Ref r -> Just r | |
| 78 ┃ _ -> Nothing | |
| Delete this definition or add ‘Unison.Referent.toTermReference’ as a root to fix this error. | |
| src/Unison/Referent.hs:100:1: error: unsafeFromText is unused | |
| 98 ┃ | |
| 99 ┃ unsafeFromText :: Text -> Referent | |
| 100 ┃ unsafeFromText = fromMaybe (error "invalid referent") . fromText | |
| 101 ┃ | |
| 102 ┃ -- #abc[.xy][#<T>cid] | |
| Delete this definition or add ‘Unison.Referent.unsafeFromText’ as a root to fix this error. | |
| src/Unison/Result.hs:54:1: error: isFailure is unused | |
| 52 ┃ | |
| 53 ┃ isFailure :: Functor f => ResultT note f a -> f Bool | |
| 54 ┃ isFailure = (isNothing . fst <$>) . runResultT | |
| 55 ┃ | |
| 56 ┃ toMaybe :: Functor f => ResultT note f a -> f (Maybe a) | |
| Delete this definition or add ‘Unison.Result.isFailure’ as a root to fix this error. | |
| src/Unison/Result.hs:51:1: error: isSuccess is unused | |
| 49 ┃ | |
| 50 ┃ isSuccess :: Functor f => ResultT note f a -> f Bool | |
| 51 ┃ isSuccess = (isJust . fst <$>) . runResultT | |
| 52 ┃ | |
| 53 ┃ isFailure :: Functor f => ResultT note f a -> f Bool | |
| Delete this definition or add ‘Unison.Result.isSuccess’ as a root to fix this error. | |
| src/Unison/Result.hs:45:1: error: result is unused | |
| 43 ┃ | |
| 44 ┃ result :: Result notes a -> Maybe a | |
| 45 ┃ result (Result _ may) = may | |
| 46 ┃ | |
| 47 ┃ pattern Result notes may = MaybeT (WriterT (Identity (may, notes))) | |
| Delete this definition or add ‘Unison.Result.result’ as a root to fix this error. | |
| src/Unison/Result.hs:67:1: error: toEither is unused | |
| 65 ┃ | |
| 66 ┃ toEither :: Functor f => ResultT notes f a -> ExceptT notes f a | |
| 67 ┃ toEither r = ExceptT (go <$> runResultT r) | |
| 68 ┃ where go (may, notes) = note notes may | |
| 69 ┃ | |
| Delete this definition or add ‘Unison.Result.toEither’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:636:1: error: bind is unused | |
| 634 ┃ | |
| 635 ┃ bind :: Var v => Cte v -> ANormal v -> ANormal v | |
| 636 ┃ bind (ST d us ms bu) = TLets d us ms bu | |
| 637 ┃ bind (LZ u f as) = TName u f as | |
| 638 ┃ | |
| Delete this definition or add ‘Unison.Runtime.ANF.bind’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1389:1: error: indent is unused | |
| 1387 ┃ | |
| 1388 ┃ indent :: Int -> ShowS | |
| 1389 ┃ indent ind = showString (replicate (ind*2) ' ') | |
| 1390 ┃ | |
| 1391 ┃ prettyGroup :: Var v => String -> SuperGroup v -> ShowS | |
| Delete this definition or add ‘Unison.Runtime.ANF.indent’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:588:1: error: matchLit is unused | |
| 586 ┃ | |
| 587 ┃ matchLit :: Term v a -> Maybe Lit | |
| 588 ┃ matchLit (Int' i) = Just $ I i | |
| 589 ┃ matchLit (Nat' n) = Just $ N n | |
| 590 ┃ matchLit (Float' f) = Just $ F f | |
| Delete this definition or add ‘Unison.Runtime.ANF.matchLit’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:356:1: error: optimize is unused | |
| 354 ┃ | |
| 355 ┃ optimize :: forall a v . (Semigroup a, Var v) => Term v a -> Term v a | |
| 356 ┃ optimize t = go t where | |
| 357 ┃ ann = ABT.annotation | |
| 358 ┃ go (Let1' b body) | canSubstLet b body = go (ABT.bind body b) | |
| Delete this definition or add ‘Unison.Runtime.ANF.optimize’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:512:1: error: packTags is unused | |
| 510 ┃ | |
| 511 ┃ packTags :: RTag -> CTag -> Word64 | |
| 512 ┃ packTags (RTag rt) (CTag ct) = ri .|. ci | |
| 513 ┃ where | |
| 514 ┃ ri = rt `shiftL` 16 | |
| Delete this definition or add ‘Unison.Runtime.ANF.packTags’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1437:1: error: prettyANF is unused | |
| 1435 ┃ | |
| 1436 ┃ prettyANF :: Var v => Bool -> Int -> ANormal v -> ShowS | |
| 1437 ┃ prettyANF m ind tm = prettySpace (reqSpace m tm) ind . case tm of | |
| 1438 ┃ TLets _ vs _ bn bo | |
| 1439 ┃ -> prettyRBind vs | |
| Delete this definition or add ‘Unison.Runtime.ANF.prettyANF’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1497:1: error: prettyBranches is unused | |
| 1495 ┃ | |
| 1496 ┃ prettyBranches :: Var v => Int -> Branched (ANormal v) -> ShowS | |
| 1497 ┃ prettyBranches ind bs = case bs of | |
| 1498 ┃ MatchEmpty -> showString "{}" | |
| 1499 ┃ MatchIntegral bs df | |
| Delete this definition or add ‘Unison.Runtime.ANF.prettyBranches’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1525:1: error: prettyCase is unused | |
| 1523 ┃ | |
| 1524 ┃ prettyCase :: Var v => Int -> ShowS -> ANormal v -> ShowS -> ShowS | |
| 1525 ┃ prettyCase ind sc (ABTN.TAbss vs e) r | |
| 1526 ┃ = showString "\n" . indent ind . sc . prettyVars vs | |
| 1527 ┃ . showString " ->" . prettyANF False (ind+1) e . r | |
| Delete this definition or add ‘Unison.Runtime.ANF.prettyCase’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1483:1: error: prettyFunc is unused | |
| 1481 ┃ | |
| 1482 ┃ prettyFunc :: Var v => Func v -> ShowS | |
| 1483 ┃ prettyFunc (FVar v) = pvar v . showString " " | |
| 1484 ┃ prettyFunc (FCont v) = pvar v . showString " " | |
| 1485 ┃ prettyFunc (FComb w) = showString "ENV(" . shows w . showString ")" | |
| Delete this definition or add ‘Unison.Runtime.ANF.prettyFunc’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1392:1: error: prettyGroup is unused | |
| 1390 ┃ | |
| 1391 ┃ prettyGroup :: Var v => String -> SuperGroup v -> ShowS | |
| 1392 ┃ prettyGroup s (Rec grp ent) | |
| 1393 ┃ = showString ("let rec[" ++ s ++ "]\n") | |
| 1394 ┃ . foldr f id grp | |
| Delete this definition or add ‘Unison.Runtime.ANF.prettyGroup’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1409:1: error: prettyLVars is unused | |
| 1407 ┃ | |
| 1408 ┃ prettyLVars :: Var v => [Mem] -> [v] -> ShowS | |
| 1409 ┃ prettyLVars [] [] = showString " " | |
| 1410 ┃ prettyLVars (c:cs) (v:vs) | |
| 1411 ┃ = showString " " | |
| Delete this definition or add ‘Unison.Runtime.ANF.prettyLVars’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1472:1: error: prettyLZF is unused | |
| 1470 ┃ | |
| 1471 ┃ prettyLZF :: Var v => Either Reference v -> ShowS | |
| 1472 ┃ prettyLZF (Left w) = showString "ENV(" . shows w . showString ") " | |
| 1473 ┃ prettyLZF (Right v) = pvar v . showString " " | |
| 1474 ┃ | |
| Delete this definition or add ‘Unison.Runtime.ANF.prettyLZF’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1419:1: error: prettyRBind is unused | |
| 1417 ┃ | |
| 1418 ┃ prettyRBind :: Var v => [v] -> ShowS | |
| 1419 ┃ prettyRBind [] = showString "()" | |
| 1420 ┃ prettyRBind [v] = pvar v | |
| 1421 ┃ prettyRBind (v:vs) | |
| Delete this definition or add ‘Unison.Runtime.ANF.prettyRBind’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1476:1: error: prettyRefs is unused | |
| 1474 ┃ | |
| 1475 ┃ prettyRefs :: [Reference] -> ShowS | |
| 1476 ┃ prettyRefs [] = showString "{}" | |
| 1477 ┃ prettyRefs (r:rs) | |
| 1478 ┃ = showString "{" . shows r | |
| Delete this definition or add ‘Unison.Runtime.ANF.prettyRefs’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1468:1: error: prettySpace is unused | |
| 1466 ┃ | |
| 1467 ┃ prettySpace :: Bool -> Int -> ShowS | |
| 1468 ┃ prettySpace False _ = showString " " | |
| 1469 ┃ prettySpace True ind = showString "\n" . indent ind | |
| 1470 ┃ | |
| Delete this definition or add ‘Unison.Runtime.ANF.prettySpace’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1426:1: error: prettySuperNormal is unused | |
| 1424 ┃ | |
| 1425 ┃ prettySuperNormal :: Var v => Int -> SuperNormal v -> ShowS | |
| 1426 ┃ prettySuperNormal ind (Lambda ccs (ABTN.TAbss vs tm)) | |
| 1427 ┃ = prettyLVars ccs vs | |
| 1428 ┃ . showString "=" | |
| Delete this definition or add ‘Unison.Runtime.ANF.prettySuperNormal’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1405:1: error: prettyVars is unused | |
| 1403 ┃ | |
| 1404 ┃ prettyVars :: Var v => [v] -> ShowS | |
| 1405 ┃ prettyVars | |
| 1406 ┃ = foldr (\v r -> showString " " . pvar v . r) id | |
| 1407 ┃ | |
| Delete this definition or add ‘Unison.Runtime.ANF.prettyVars’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1402:1: error: pvar is unused | |
| 1400 ┃ | |
| 1401 ┃ pvar :: Var v => v -> ShowS | |
| 1402 ┃ pvar v = showString . Text.unpack $ Var.name v | |
| 1403 ┃ | |
| 1404 ┃ prettyVars :: Var v => [v] -> ShowS | |
| Delete this definition or add ‘Unison.Runtime.ANF.pvar’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:1432:1: error: reqSpace is unused | |
| 1430 ┃ | |
| 1431 ┃ reqSpace :: Var v => Bool -> ANormal v -> Bool | |
| 1432 ┃ reqSpace _ TLets{} = True | |
| 1433 ┃ reqSpace _ TName{} = True | |
| 1434 ┃ reqSpace b _ = b | |
| Delete this definition or add ‘Unison.Runtime.ANF.reqSpace’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:640:1: error: unbind is unused | |
| 638 ┃ | |
| 639 ┃ unbind :: Var v => ANormal v -> Maybe (Cte v, ANormal v) | |
| 640 ┃ unbind (TLets d us ms bu bd) = Just (ST d us ms bu, bd) | |
| 641 ┃ unbind (TName u f as bd) = Just (LZ u f as, bd) | |
| 642 ┃ unbind _ = Nothing | |
| Delete this definition or add ‘Unison.Runtime.ANF.unbind’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:645:1: error: unbinds is unused | |
| 643 ┃ | |
| 644 ┃ unbinds :: Var v => ANormal v -> ([Cte v], ANormal v) | |
| 645 ┃ unbinds (TLets d us ms bu (unbinds -> (ctx, bd))) | |
| 646 ┃ = (ST d us ms bu:ctx, bd) | |
| 647 ┃ unbinds (TName u f as (unbinds -> (ctx, bd))) = (LZ u f as:ctx, bd) | |
| Delete this definition or add ‘Unison.Runtime.ANF.unbinds’ as a root to fix this error. | |
| src/Unison/Runtime/ANF.hs:518:1: error: unpackTags is unused | |
| 516 ┃ | |
| 517 ┃ unpackTags :: Word64 -> (RTag, CTag) | |
| 518 ┃ unpackTags w = (RTag $ w `shiftR` 16, CTag . fromIntegral $ w .&. 0xFFFF) | |
| 519 ┃ | |
| 520 ┃ ensureRTag :: (Ord n, Show n, Num n) => String -> n -> r -> r | |
| Delete this definition or add ‘Unison.Runtime.ANF.unpackTags’ as a root to fix this error. | |
| src/Unison/Runtime/Debug.hs:26:1: error: traceComb is unused | |
| 24 ┃ | |
| 25 ┃ traceComb :: Bool -> Word64 -> Comb -> Bool | |
| 26 ┃ traceComb False _ _ = True | |
| 27 ┃ traceComb True w c = trace (prettyComb w 0 c "\n") True | |
| 28 ┃ | |
| Delete this definition or add ‘Unison.Runtime.Debug.traceComb’ as a root to fix this error. | |
| src/Unison/Runtime/Debug.hs:34:1: error: traceCombs is unused | |
| 32 ┃ -> EnumMap Word64 Comb | |
| 33 ┃ -> EnumMap Word64 Comb | |
| 34 ┃ traceCombs _ False c = c | |
| 35 ┃ traceCombs w True c = trace (prettyCombs w c "") c | |
| 36 ┃ | |
| Delete this definition or add ‘Unison.Runtime.Debug.traceCombs’ as a root to fix this error. | |
| src/Unison/Runtime/Debug.hs:43:1: error: tracePretty is unused | |
| 41 ┃ -> Term v | |
| 42 ┃ -> Term v | |
| 43 ┃ tracePretty _ False tm = tm | |
| 44 ┃ tracePretty ppe True tm = trace (toANSI 50 $ pretty ppe tm) tm | |
| 45 ┃ | |
| Delete this definition or add ‘Unison.Runtime.Debug.tracePretty’ as a root to fix this error. | |
| src/Unison/Runtime/Debug.hs:52:1: error: tracePrettyGroup is unused | |
| 50 ┃ -> SuperGroup v | |
| 51 ┃ -> SuperGroup v | |
| 52 ┃ tracePrettyGroup _ False g = g | |
| 53 ┃ tracePrettyGroup w True g = trace (prettyGroup (show w) g "") g | |
| 54 ┃ | |
| Delete this definition or add ‘Unison.Runtime.Debug.tracePrettyGroup’ as a root to fix this error. | |
| src/Unison/Runtime/IOSource.hs:89:1: error: hostNameReference is unused | |
| 87 ┃ isPropagatedReference = typeNamed "IsPropagated" | |
| 88 ┃ filePathReference = typeNamed "io.FilePath" | |
| 89 ┃ hostNameReference = typeNamed "io.HostName" | |
| 90 ┃ serviceNameReference = typeNamed "io.ServiceName" | |
| 91 ┃ | |
| Delete this definition or add ‘Unison.Runtime.IOSource.hostNameReference’ as a root to fix this error. | |
| src/Unison/Runtime/IOSource.hs:100:1: error: isIOTest is unused | |
| 98 ┃ | |
| 99 ┃ isIOTest :: (R.Reference, R.Reference) | |
| 100 ┃ isIOTest = (isTestReference, termNamed "metadata.isIOTest") | |
| 101 ┃ | |
| 102 ┃ isPropagatedValue :: R.Reference | |
| Delete this definition or add ‘Unison.Runtime.IOSource.isIOTest’ as a root to fix this error. | |
| src/Unison/Runtime/IOSource.hs:90:1: error: serviceNameReference is unused | |
| 88 ┃ filePathReference = typeNamed "io.FilePath" | |
| 89 ┃ hostNameReference = typeNamed "io.HostName" | |
| 90 ┃ serviceNameReference = typeNamed "io.ServiceName" | |
| 91 ┃ | |
| 92 ┃ failureReference = typeNamed "io2.Failure" | |
| Delete this definition or add ‘Unison.Runtime.IOSource.serviceNameReference’ as a root to fix this error. | |
| src/Unison/Runtime/IR.hs:1049:1: error: compilationEnv0 is unused | |
| 1047 ┃ | |
| 1048 ┃ compilationEnv0 :: CompilationEnv e cont | |
| 1049 ┃ compilationEnv0 = CompilationEnv builtins mempty | |
| 1050 ┃ | |
| 1051 ┃ instance Semigroup (CompilationEnv e cont) where (<>) = mappend | |
| Delete this definition or add ‘Unison.Runtime.IR.compilationEnv0’ as a root to fix this error. | |
| src/Unison/Runtime/IR.hs:256:1: error: prettyIR is unused | |
| 254 ┃ -> IR e cont | |
| 255 ┃ -> P.Pretty String | |
| 256 ┃ prettyIR ppe prettyE prettyCont = pir | |
| 257 ┃ where | |
| 258 ┃ unlets (Let s hd tl _) = (Just s, hd) : unlets tl | |
| Delete this definition or add ‘Unison.Runtime.IR.prettyIR’ as a root to fix this error. | |
| src/Unison/Runtime/IR.hs:366:1: error: prettyValue is unused | |
| 364 ┃ -> Value e cont | |
| 365 ┃ -> P.Pretty String | |
| 366 ┃ prettyValue ppe prettyE prettyCont = pv | |
| 367 ┃ where | |
| 368 ┃ pv v = case v of | |
| Delete this definition or add ‘Unison.Runtime.IR.prettyValue’ as a root to fix this error. | |
| src/Unison/Runtime/IR.hs:245:1: error: prettyZ is unused | |
| 243 ┃ -> Z e cont | |
| 244 ┃ -> P.Pretty String | |
| 245 ┃ prettyZ ppe prettyE prettyCont z = case z of | |
| 246 ┃ Slot i -> "@" <> P.shown i | |
| 247 ┃ LazySlot i -> "'@" <> P.shown i | |
| Delete this definition or add ‘Unison.Runtime.IR.prettyZ’ as a root to fix this error. | |
| src/Unison/Runtime/MCode.hs:1324:1: error: bx is unused | |
| 1322 ┃ | |
| 1323 ┃ bx :: ShowS | |
| 1324 ┃ bx = ('B':) | |
| 1325 ┃ | |
| 1326 ┃ prettyIns :: Instr -> ShowS | |
| Delete this definition or add ‘Unison.Runtime.MCode.bx’ as a root to fix this error. | |
| src/Unison/Runtime/MCode.hs:1260:1: error: indent is unused | |
| 1258 ┃ | |
| 1259 ┃ indent :: Int -> ShowS | |
| 1260 ┃ indent ind = showString (replicate (ind*2) ' ') | |
| 1261 ┃ | |
| 1262 ┃ prettyCombs | |
| Delete this definition or add ‘Unison.Runtime.MCode.indent’ as a root to fix this error. | |
| src/Unison/Runtime/MCode.hs:1333:1: error: prettyArgs is unused | |
| 1331 ┃ | |
| 1332 ┃ prettyArgs :: Args -> ShowS | |
| 1333 ┃ prettyArgs ZArgs = shows @[Int] [] | |
| 1334 ┃ prettyArgs (UArg1 i) = un . shows [i] | |
| 1335 ┃ prettyArgs (BArg1 i) = bx . shows [i] | |
| Delete this definition or add ‘Unison.Runtime.MCode.prettyArgs’ as a root to fix this error. | |
| src/Unison/Runtime/MCode.hs:1303:1: error: prettyBranches is unused | |
| 1301 ┃ | |
| 1302 ┃ prettyBranches :: Int -> Branch -> ShowS | |
| 1303 ┃ prettyBranches ind bs | |
| 1304 ┃ = case bs of | |
| 1305 ┃ Test1 i e df -> pdf df . picase i e | |
| Delete this definition or add ‘Unison.Runtime.MCode.prettyBranches’ as a root to fix this error. | |
| src/Unison/Runtime/MCode.hs:1271:1: error: prettyComb is unused | |
| 1269 ┃ | |
| 1270 ┃ prettyComb :: Word64 -> Word64 -> Comb -> ShowS | |
| 1271 ┃ prettyComb w i (Lam ua ba _ _ s) | |
| 1272 ┃ = shows w . showString ":" . shows i . shows [ua,ba] | |
| 1273 ┃ . showString ":\n" . prettySection 2 s | |
| Delete this definition or add ‘Unison.Runtime.MCode.prettyComb’ as a root to fix this error. | |
| src/Unison/Runtime/MCode.hs:1266:1: error: prettyCombs is unused | |
| 1264 ┃ -> EnumMap Word64 Comb | |
| 1265 ┃ -> ShowS | |
| 1266 ┃ prettyCombs w es | |
| 1267 ┃ = foldr (\(i,c) r -> prettyComb w i c . showString "\n" . r) | |
| 1268 ┃ id (mapToList es) | |
| Delete this definition or add ‘Unison.Runtime.MCode.prettyCombs’ as a root to fix this error. | |
| src/Unison/Runtime/MCode.hs:1327:1: error: prettyIns is unused | |
| 1325 ┃ | |
| 1326 ┃ prettyIns :: Instr -> ShowS | |
| 1327 ┃ prettyIns (Pack r i as) | |
| 1328 ┃ = showString "Pack " . showsPrec 10 r | |
| 1329 ┃ . (' ':) . shows i . (' ':) . prettyArgs as | |
| Delete this definition or add ‘Unison.Runtime.MCode.prettyIns’ as a root to fix this error. | |
| src/Unison/Runtime/MCode.hs:1298:1: error: prettyIx is unused | |
| 1296 ┃ | |
| 1297 ┃ prettyIx :: CombIx -> ShowS | |
| 1298 ┃ prettyIx (CIx _ c s) | |
| 1299 ┃ = showString "Resume[" . shows c | |
| 1300 ┃ . showString "," . shows s . showString "]" | |
| Delete this definition or add ‘Unison.Runtime.MCode.prettyIx’ as a root to fix this error. | |
| src/Unison/Runtime/MCode.hs:1276:1: error: prettySection is unused | |
| 1274 ┃ | |
| 1275 ┃ prettySection :: Int -> Section -> ShowS | |
| 1276 ┃ prettySection ind sec | |
| 1277 ┃ = indent ind . case sec of | |
| 1278 ┃ App _ r as -> | |
| Delete this definition or add ‘Unison.Runtime.MCode.prettySection’ as a root to fix this error. | |
| src/Unison/Runtime/MCode.hs:1321:1: error: un is unused | |
| 1319 ┃ | |
| 1320 ┃ un :: ShowS | |
| 1321 ┃ un = ('U':) | |
| 1322 ┃ | |
| 1323 ┃ bx :: ShowS | |
| Delete this definition or add ‘Unison.Runtime.MCode.un’ as a root to fix this error. | |
| src/Unison/Runtime/Machine.hs:1369:1: error: discardCont is unused | |
| 1367 ┃ :: DEnv -> Stack 'UN -> Stack 'BX -> K | |
| 1368 ┃ -> Word64 -> IO (DEnv, Stack 'UN, Stack 'BX, K) | |
| 1369 ┃ discardCont denv ustk bstk k p | |
| 1370 ┃ = splitCont denv ustk bstk k p | |
| 1371 ┃ <&> \(_, denv, ustk, bstk, _, _, k) -> (denv, ustk, bstk, k) | |
| Delete this definition or add ‘Unison.Runtime.Machine.discardCont’ as a root to fix this error. | |
| src/Unison/Runtime/Machine.hs:159:1: error: lookupDenv is unused | |
| 157 ┃ | |
| 158 ┃ lookupDenv :: Word64 -> DEnv -> Closure | |
| 159 ┃ lookupDenv p denv = fromMaybe BlackHole $ EC.lookup p denv | |
| 160 ┃ | |
| 161 ┃ exec | |
| Delete this definition or add ‘Unison.Runtime.Machine.lookupDenv’ as a root to fix this error. | |
| src/Unison/Runtime/Machine.hs:672:1: error: peekForeign is unused | |
| 670 ┃ | |
| 671 ┃ peekForeign :: Stack 'BX -> Int -> IO a | |
| 672 ┃ peekForeign bstk i | |
| 673 ┃ = peekOff bstk i >>= \case | |
| 674 ┃ Foreign x -> pure $ unwrapForeign x | |
| Delete this definition or add ‘Unison.Runtime.Machine.peekForeign’ as a root to fix this error. | |
| src/Unison/Runtime/Machine.hs:86:1: error: refNumTy is unused | |
| 84 ┃ | |
| 85 ┃ refNumTy :: CCache -> Reference -> IO Word64 | |
| 86 ┃ refNumTy cc r = refNumsTy cc >>= \case | |
| 87 ┃ (M.lookup r -> Just w) -> pure w | |
| 88 ┃ _ -> die $ "refNumTy: unknown reference: " ++ show r | |
| Delete this definition or add ‘Unison.Runtime.Machine.refNumTy’ as a root to fix this error. | |
| src/Unison/Runtime/Machine.hs:91:1: error: refNumTy' is unused | |
| 89 ┃ | |
| 90 ┃ refNumTy' :: CCache -> Reference -> IO (Maybe Word64) | |
| 91 ┃ refNumTy' cc r = M.lookup r <$> refNumsTy cc | |
| 92 ┃ | |
| 93 ┃ baseCCache :: IO CCache | |
| Delete this definition or add ‘Unison.Runtime.Machine.refNumTy'’ as a root to fix this error. | |
| src/Unison/Runtime/Machine.hs:1398:1: error: reserveIds is unused | |
| 1396 ┃ | |
| 1397 ┃ reserveIds :: Word64 -> TVar Word64 -> IO Word64 | |
| 1398 ┃ reserveIds n free = atomically . stateTVar free $ \i -> (i, i+n) | |
| 1399 ┃ | |
| 1400 ┃ updateMap :: Semigroup s => s -> TVar s -> STM s | |
| Delete this definition or add ‘Unison.Runtime.Machine.reserveIds’ as a root to fix this error. | |
| src/Unison/Runtime/Rt1.hs:218:1: error: arity is unused | |
| 216 ┃ | |
| 217 ┃ arity :: Value -> Int | |
| 218 ┃ arity (Lam n _ _) = n | |
| 219 ┃ arity _ = 0 | |
| 220 ┃ | |
| Delete this definition or add ‘Unison.Runtime.Rt1.arity’ as a root to fix this error. | |
| src/Unison/Runtime/Rt1.hs:159:1: error: atd is unused | |
| 157 ┃ | |
| 158 ┃ atd :: Size -> Z -> Stack -> IO (R.Reference, ConstructorId, [Value]) | |
| 159 ┃ atd size i m = at size i m >>= \case | |
| 160 ┃ Data r id vs -> pure (r, id, vs) | |
| 161 ┃ v -> fail $ "type error, expecting Data, got " <> show v | |
| Delete this definition or add ‘Unison.Runtime.Rt1.atd’ as a root to fix this error. | |
| src/Unison/Runtime/Rt1IO.hs:195:1: error: constructPair is unused | |
| 193 ┃ | |
| 194 ┃ constructPair :: RT.Value -> RT.Value -> RT.Value | |
| 195 ┃ constructPair a b = IR.Data DD.pairRef 0 [a, b] | |
| 196 ┃ | |
| 197 ┃ convertErrorType :: IOError -> IR.ConstructorId | |
| Delete this definition or add ‘Unison.Runtime.Rt1IO.constructPair’ as a root to fix this error. | |
| src/Unison/Runtime/Rt1IO.hs:186:1: error: convertOptional is unused | |
| 184 ┃ | |
| 185 ┃ convertOptional :: RT.Value -> Maybe RT.Value | |
| 186 ┃ convertOptional (IR.Data _ _ [] ) = Nothing | |
| 187 ┃ convertOptional (IR.Data _ _ [x]) = Just x | |
| 188 ┃ convertOptional v = | |
| Delete this definition or add ‘Unison.Runtime.Rt1IO.convertOptional’ as a root to fix this error. | |
| src/Unison/Runtime/SparseVector.hs:72:1: error: _1 is unused | |
| 70 ┃ | |
| 71 ┃ _1 :: (UV.Unbox a, UV.Unbox b) => SparseVector bits (a,b) -> SparseVector bits a | |
| 72 ┃ _1 = fst . unzip | |
| 73 ┃ | |
| 74 ┃ _2 :: (UV.Unbox a, UV.Unbox b) => SparseVector bits (a,b) -> SparseVector bits b | |
| Delete this definition or add ‘Unison.Runtime.SparseVector._1’ as a root to fix this error. | |
| src/Unison/Runtime/SparseVector.hs:75:1: error: _2 is unused | |
| 73 ┃ | |
| 74 ┃ _2 :: (UV.Unbox a, UV.Unbox b) => SparseVector bits (a,b) -> SparseVector bits b | |
| 75 ┃ _2 = snd . unzip | |
| 76 ┃ | |
| 77 ┃ -- Denotationally: `unzip p = (\n -> fst <$> p n, \n -> snd <$> p n)` | |
| Delete this definition or add ‘Unison.Runtime.SparseVector._2’ as a root to fix this error. | |
| src/Unison/Runtime/SparseVector.hs:91:1: error: choose is unused | |
| 89 ┃ -> SparseVector bits a | |
| 90 ┃ -> SparseVector bits a | |
| 91 ┃ choose bits t f | |
| 92 ┃ | B.zeroBits == bits = f | |
| 93 ┃ | B.complement bits == B.zeroBits = t | |
| Delete this definition or add ‘Unison.Runtime.SparseVector.choose’ as a root to fix this error. | |
| src/Unison/Runtime/SparseVector.hs:127:1: error: eq is unused | |
| 125 ┃ -- Pointer equality a la Scala. | |
| 126 ┃ eq :: a -> a -> Bool | |
| 127 ┃ eq x y = Exts.isTrue# (Exts.reallyUnsafePtrEquality# x y Exts.==# 1#) | |
| 128 ┃ {-# INLINE eq #-} | |
| Delete this definition or add ‘Unison.Runtime.SparseVector.eq’ as a root to fix this error. | |
| src/Unison/Runtime/SparseVector.hs:26:1: error: map is unused | |
| 24 ┃ -- Denotationally: `map f v n = f <$> v n` | |
| 25 ┃ map :: (UV.Unbox a, UV.Unbox b) => (a -> b) -> SparseVector bits a -> SparseVector bits b | |
| 26 ┃ map f v = v { elements = UV.map f (elements v) } | |
| 27 ┃ | |
| 28 ┃ -- Denotationally, a mask is a `Nat -> Bool`, so this implementation | |
| Delete this definition or add ‘Unison.Runtime.SparseVector.map’ as a root to fix this error. | |
| src/Unison/Runtime/SparseVector.hs:32:1: error: mask is unused | |
| 30 ┃ mask :: (UV.Unbox a, B.FiniteBits bits) | |
| 31 ┃ => bits -> SparseVector bits a -> SparseVector bits a | |
| 32 ┃ mask bits a = | |
| 33 ┃ if indices' == bits then a -- check if mask is a superset | |
| 34 ┃ else SparseVector indices' $ UV.create $ do | |
| Delete this definition or add ‘Unison.Runtime.SparseVector.mask’ as a root to fix this error. | |
| src/Unison/Runtime/SparseVector.hs:102:1: error: merge is unused | |
| 100 ┃ -> SparseVector bits a | |
| 101 ┃ -> SparseVector bits a | |
| 102 ┃ merge a b = SparseVector indices' tricky | |
| 103 ┃ where | |
| 104 ┃ indices' = indices a .|. indices b | |
| Delete this definition or add ‘Unison.Runtime.SparseVector.merge’ as a root to fix this error. | |
| src/Unison/Runtime/SparseVector.hs:81:1: error: unzip is unused | |
| 79 ┃ => SparseVector bits (a,b) | |
| 80 ┃ -> (SparseVector bits a, SparseVector bits b) | |
| 81 ┃ unzip (SparseVector inds ps) = | |
| 82 ┃ let (as,bs) = UV.unzip ps | |
| 83 ┃ in (SparseVector inds as, SparseVector inds bs) | |
| Delete this definition or add ‘Unison.Runtime.SparseVector.unzip’ as a root to fix this error. | |
| src/Unison/Runtime/SparseVector.hs:62:1: error: zipWith is unused | |
| 60 ┃ -> SparseVector bits b | |
| 61 ┃ -> SparseVector bits c | |
| 62 ┃ zipWith f a b = | |
| 63 ┃ if indices a `eq` indices b || indices a == indices b then | |
| 64 ┃ SparseVector (indices a) (UV.zipWith f (elements a) (elements b)) | |
| Delete this definition or add ‘Unison.Runtime.SparseVector.zipWith’ as a root to fix this error. | |
| src/Unison/Runtime/Stack.hs:133:1: error: formData is unused | |
| 131 ┃ | |
| 132 ┃ formData :: Reference -> Word64 -> [Int] -> [Closure] -> Closure | |
| 133 ┃ formData r t [] [] = Enum r t | |
| 134 ┃ formData r t [i] [] = DataU1 r t i | |
| 135 ┃ formData r t [i,j] [] = DataU2 r t i j | |
| Delete this definition or add ‘Unison.Runtime.Stack.formData’ as a root to fix this error. | |
| src/Unison/Runtime/Stack.hs:646:1: error: frameView is unused | |
| 644 ┃ | |
| 645 ┃ frameView :: MEM b => Show (Elem b) => Stack b -> IO () | |
| 646 ┃ frameView stk = putStr "|" >> gof False 0 | |
| 647 ┃ where | |
| 648 ┃ fsz = fsize stk | |
| Delete this definition or add ‘Unison.Runtime.Stack.frameView’ as a root to fix this error. | |
| src/Unison/Runtime/Stack.hs:124:1: error: ints is unused | |
| 122 ┃ | |
| 123 ┃ ints :: ByteArray -> [Int] | |
| 124 ┃ ints ba = fmap (indexByteArray ba) [0..n-1] | |
| 125 ┃ where | |
| 126 ┃ n = sizeofByteArray ba `div` 8 | |
| Delete this definition or add ‘Unison.Runtime.Stack.ints’ as a root to fix this error. | |
| src/Unison/Runtime/Stack.hs:492:1: error: peekBi is unused | |
| 490 ┃ | |
| 491 ┃ peekBi :: BuiltinForeign b => Stack 'BX -> IO b | |
| 492 ┃ peekBi bstk = unwrapForeign . marshalToForeign <$> peek bstk | |
| 493 ┃ {-# inline peekBi #-} | |
| 494 ┃ | |
| Delete this definition or add ‘Unison.Runtime.Stack.peekBi’ as a root to fix this error. | |
| src/Unison/Runtime/Stack.hs:456:1: error: peekD is unused | |
| 454 ┃ | |
| 455 ┃ peekD :: Stack 'UN -> IO Double | |
| 456 ┃ peekD (US _ _ sp stk) = readByteArray stk sp | |
| 457 ┃ {-# inline peekD #-} | |
| 458 ┃ | |
| Delete this definition or add ‘Unison.Runtime.Stack.peekD’ as a root to fix this error. | |
| src/Unison/Runtime/Stack.hs:452:1: error: peekN is unused | |
| 450 ┃ | |
| 451 ┃ peekN :: Stack 'UN -> IO Word64 | |
| 452 ┃ peekN (US _ _ sp stk) = readByteArray stk sp | |
| 453 ┃ {-# inline peekN #-} | |
| 454 ┃ | |
| Delete this definition or add ‘Unison.Runtime.Stack.peekN’ as a root to fix this error. | |
| src/Unison/Runtime/Stack.hs:488:1: error: pokeOffBi is unused | |
| 486 ┃ | |
| 487 ┃ pokeOffBi :: BuiltinForeign b => Stack 'BX -> Int -> b -> IO () | |
| 488 ┃ pokeOffBi bstk i x = pokeOff bstk i (Foreign $ wrapBuiltin x) | |
| 489 ┃ {-# inline pokeOffBi #-} | |
| 490 ┃ | |
| Delete this definition or add ‘Unison.Runtime.Stack.pokeOffBi’ as a root to fix this error. | |
| src/Unison/Runtime/Stack.hs:114:1: error: splitData is unused | |
| 112 ┃ | |
| 113 ┃ splitData :: Closure -> Maybe (Reference, Word64, [Int], [Closure]) | |
| 114 ┃ splitData (Enum r t) = Just (r, t, [], []) | |
| 115 ┃ splitData (DataU1 r t i) = Just (r, t, [i], []) | |
| 116 ┃ splitData (DataU2 r t i j) = Just (r, t, [i,j], []) | |
| Delete this definition or add ‘Unison.Runtime.Stack.splitData’ as a root to fix this error. | |
| src/Unison/Runtime/Stack.hs:129:1: error: useg is unused | |
| 127 ┃ | |
| 128 ┃ useg :: [Int] -> Seg 'UN | |
| 129 ┃ useg ws = case L.fromList ws of | |
| 130 ┃ PrimArray ba -> ByteArray ba | |
| 131 ┃ | |
| Delete this definition or add ‘Unison.Runtime.Stack.useg’ as a root to fix this error. | |
| src/Unison/Runtime/Vector.hs:43:1: error: bound is unused | |
| 41 ┃ -- Returns the maximum `Nat` for which `mu v` may return `Just`. | |
| 42 ┃ bound :: Nat -> Vec a -> Nat | |
| 43 ┃ bound width v = case v of | |
| 44 ┃ Scalar _ -> width | |
| 45 ┃ Vec vs -> fromIntegral $ UV.length vs | |
| Delete this definition or add ‘Unison.Runtime.Vector.bound’ as a root to fix this error. | |
| src/Unison/Runtime/Vector.hs:27:1: error: mu is unused | |
| 25 ┃ | |
| 26 ┃ mu :: Vec a -> Nat -> Maybe a | |
| 27 ┃ mu v = case v of | |
| 28 ┃ Scalar a -> const (Just a) | |
| 29 ┃ Vec vs -> \i -> vs UV.!? fromIntegral i | |
| Delete this definition or add ‘Unison.Runtime.Vector.mu’ as a root to fix this error. | |
| src/Unison/Runtime/Vector.hs:51:1: error: toList is unused | |
| 49 ┃ | |
| 50 ┃ toList :: Vec a -> [a] | |
| 51 ┃ toList v = let | |
| 52 ┃ n = bound maxBound v | |
| 53 ┃ muv = mu v | |
| Delete this definition or add ‘Unison.Runtime.Vector.toList’ as a root to fix this error. | |
| src/Unison/Settings.hs:12:1: error: demoHideVarNumber is unused | |
| 10 ┃ | |
| 11 ┃ demoHideVarNumber :: Bool | |
| 12 ┃ demoHideVarNumber = False | |
| 13 ┃ | |
| 14 ┃ removePureEffects :: Bool | |
| Delete this definition or add ‘Unison.Settings.demoHideVarNumber’ as a root to fix this error. | |
| src/Unison/ShortHash.hs:19:1: error: isConstructor is unused | |
| 17 ┃ -- currently unused | |
| 18 ┃ isConstructor :: ShortHash -> Bool | |
| 19 ┃ isConstructor = \case | |
| 20 ┃ ShortHash _ _ (Just _) -> True | |
| 21 ┃ _ -> False | |
| Delete this definition or add ‘Unison.ShortHash.isConstructor’ as a root to fix this error. | |
| src/Unison/Term.hs:567:1: error: ann_ is unused | |
| 565 ┃ | |
| 566 ┃ ann_ :: Ord v => Term0' vt v -> Type vt () -> Term0' vt v | |
| 567 ┃ ann_ e t = ABT.tm (Ann e t) | |
| 568 ┃ | |
| 569 ┃ ann :: Ord v | |
| Delete this definition or add ‘Unison.Term.ann_’ as a root to fix this error. | |
| src/Unison/Term.hs:526:1: error: app_ is unused | |
| 524 ┃ -- todo: delete and rename app' to app | |
| 525 ┃ app_ :: Ord v => Term0' vt v -> Term0' vt v -> Term0' vt v | |
| 526 ┃ app_ f arg = ABT.tm (App f arg) | |
| 527 ┃ | |
| 528 ┃ app :: Ord v => a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a | |
| Delete this definition or add ‘Unison.Term.app_’ as a root to fix this error. | |
| src/Unison/Term.hs:917:1: error: betaNormalForm is unused | |
| 915 ┃ | |
| 916 ┃ betaNormalForm :: Var v => Term0 v -> Term0 v | |
| 917 ┃ betaNormalForm (App' f a) = betaNormalForm (betaReduce (app() (betaNormalForm f) a)) | |
| 918 ┃ betaNormalForm e = e | |
| 919 ┃ | |
| Delete this definition or add ‘Unison.Term.betaNormalForm’ as a root to fix this error. | |
| src/Unison/Term.hs:296:1: error: freeTypeVars is unused | |
| 294 ┃ | |
| 295 ┃ freeTypeVars :: Ord vt => Term' vt v a -> Set vt | |
| 296 ┃ freeTypeVars t = Map.keysSet $ freeTypeVarAnnotations t | |
| 297 ┃ | |
| 298 ┃ freeTypeVarAnnotations :: Ord vt => Term' vt v a -> Map vt [a] | |
| Delete this definition or add ‘Unison.Term.freeTypeVars’ as a root to fix this error. | |
| src/Unison/Term.hs:458:1: error: fresh is unused | |
| 456 ┃ | |
| 457 ┃ fresh :: Var v => Term0 v -> v -> v | |
| 458 ┃ fresh = ABT.fresh | |
| 459 ┃ | |
| 460 ┃ -- some smart constructors | |
| Delete this definition or add ‘Unison.Term.fresh’ as a root to fix this error. | |
| src/Unison/Term.hs:962:1: error: hashConstructor is unused | |
| 960 ┃ | |
| 961 ┃ hashConstructor :: Reference -> ConstructorId -> Reference | |
| 962 ┃ hashConstructor = hashConstructor' $ constructor () | |
| 963 ┃ | |
| 964 ┃ hashRequest :: Reference -> ConstructorId -> Reference | |
| Delete this definition or add ‘Unison.Term.hashConstructor’ as a root to fix this error. | |
| src/Unison/Term.hs:952:1: error: hashConstructor' is unused | |
| 950 ┃ hashConstructor' | |
| 951 ┃ :: (Reference -> ConstructorId -> Term0 Symbol) -> Reference -> ConstructorId -> Reference | |
| 952 ┃ hashConstructor' f r cid = | |
| 953 ┃ let | |
| 954 ┃ -- this is a bit circuitous, but defining everything in terms of hashComponents | |
| Delete this definition or add ‘Unison.Term.hashConstructor'’ as a root to fix this error. | |
| src/Unison/Term.hs:965:1: error: hashRequest is unused | |
| 963 ┃ | |
| 964 ┃ hashRequest :: Reference -> ConstructorId -> Reference | |
| 965 ┃ hashRequest = hashConstructor' $ request () | |
| 966 ┃ | |
| 967 ┃ fromReferent :: Ord v | |
| Delete this definition or add ‘Unison.Term.hashRequest’ as a root to fix this error. | |
| src/Unison/Term.hs:584:1: error: lam'' is unused | |
| 582 ┃ | |
| 583 ┃ lam'' :: Ord v => [(a,v)] -> Term2 vt at ap v a -> Term2 vt at ap v a | |
| 584 ┃ lam'' vs body = foldr (uncurry lam) body vs | |
| 585 ┃ | |
| 586 ┃ isLam :: Term2 vt at ap v a -> Bool | |
| Delete this definition or add ‘Unison.Term.lam''’ as a root to fix this error. | |
| src/Unison/Term.hs:654:1: error: letRec_ is unused | |
| 652 ┃ -- and the output expression may also reference any binding in the block. | |
| 653 ┃ letRec_ :: Ord v => IsTop -> [(v, Term0' vt v)] -> Term0' vt v -> Term0' vt v | |
| 654 ┃ letRec_ _ [] e = e | |
| 655 ┃ letRec_ isTop bindings e = ABT.cycle (foldr (ABT.abs . fst) z bindings) | |
| 656 ┃ where | |
| Delete this definition or add ‘Unison.Term.letRec_’ as a root to fix this error. | |
| src/Unison/Term.hs:513:1: error: placeholder is unused | |
| 511 ┃ | |
| 512 ┃ placeholder :: Ord v => a -> String -> Term2 vt a ap v a | |
| 513 ┃ placeholder a s = ABT.tm' a . Blank $ B.Recorded (B.Placeholder a s) | |
| 514 ┃ | |
| 515 ┃ resolve :: Ord v => at -> ab -> String -> Term2 vt ab ap v at | |
| Delete this definition or add ‘Unison.Term.placeholder’ as a root to fix this error. | |
| src/Unison/Term.hs:747:1: error: unApps is unused | |
| 745 ┃ :: Term2 vt at ap v a | |
| 746 ┃ -> Maybe (Term2 vt at ap v a, [Term2 vt at ap v a]) | |
| 747 ┃ unApps t = unAppsPred (t, const True) | |
| 748 ┃ | |
| 749 ┃ -- Same as unApps but taking a predicate controlling whether we match on a given function argument. | |
| Delete this definition or add ‘Unison.Term.unApps’ as a root to fix this error. | |
| src/Unison/Term.hs:752:1: error: unAppsPred is unused | |
| 750 ┃ unAppsPred :: (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) -> | |
| 751 ┃ Maybe (Term2 vt at ap v a, [Term2 vt at ap v a]) | |
| 752 ┃ unAppsPred (t, pred) = case go t [] of [] -> Nothing; f:args -> Just (f,args) | |
| 753 ┃ where | |
| 754 ┃ go (App' i o) acc | pred o = go i (o:acc) | |
| Delete this definition or add ‘Unison.Term.unAppsPred’ as a root to fix this error. | |
| src/Unison/Term.hs:762:1: error: unBinaryApp is unused | |
| 760 ┃ Term2 vt at ap v a, | |
| 761 ┃ Term2 vt at ap v a) | |
| 762 ┃ unBinaryApp t = case unApps t of | |
| 763 ┃ Just (f, [arg1, arg2]) -> Just (f, arg1, arg2) | |
| 764 ┃ _ -> Nothing | |
| Delete this definition or add ‘Unison.Term.unBinaryApp’ as a root to fix this error. | |
| src/Unison/Term.hs:773:1: error: unBinaryApps is unused | |
| 771 ┃ , Term2 vt at ap v a | |
| 772 ┃ ) | |
| 773 ┃ unBinaryApps t = unBinaryAppsPred (t, const True) | |
| 774 ┃ | |
| 775 ┃ -- Same as unBinaryApps but taking a predicate controlling whether we match on a given binary function. | |
| Delete this definition or add ‘Unison.Term.unBinaryApps’ as a root to fix this error. | |
| src/Unison/Term.hs:781:1: error: unBinaryAppsPred is unused | |
| 779 ┃ Term2 vt at ap v a)], | |
| 780 ┃ Term2 vt at ap v a) | |
| 781 ┃ unBinaryAppsPred (t, pred) = case unBinaryApp t of | |
| 782 ┃ Just (f, x, y) | pred f -> case unBinaryAppsPred (x, pred) of | |
| 783 ┃ Just (as, xLast) -> Just ((xLast, f) : as, y) | |
| Delete this definition or add ‘Unison.Term.unBinaryAppsPred’ as a root to fix this error. | |
| src/Unison/Term.hs:794:1: error: unLamsOpt' is unused | |
| 792 ┃ -- lambda extraction. | |
| 793 ┃ unLamsOpt' :: Term2 vt at ap v a -> Maybe ([v], Term2 vt at ap v a) | |
| 794 ┃ unLamsOpt' t = case unLams' t of | |
| 795 ┃ r@(Just _) -> r | |
| 796 ┃ Nothing -> Just ([], t) | |
| Delete this definition or add ‘Unison.Term.unLamsOpt'’ as a root to fix this error. | |
| src/Unison/Term.hs:804:1: error: unLamsUntilDelay' is unused | |
| 802 ┃ => Term2 vt at ap v a | |
| 803 ┃ -> Maybe ([v], Term2 vt at ap v a) | |
| 804 ┃ unLamsUntilDelay' t = case unLamsPred' (t, (/=) $ Var.named "()") of | |
| 805 ┃ r@(Just _) -> r | |
| 806 ┃ Nothing -> Just ([], t) | |
| Delete this definition or add ‘Unison.Term.unLamsUntilDelay'’ as a root to fix this error. | |
| src/Unison/Term.hs:704:1: error: unLet is unused | |
| 702 ┃ :: Term2 vt at ap v a | |
| 703 ┃ -> Maybe ([(IsTop, v, Term2 vt at ap v a)], Term2 vt at ap v a) | |
| 704 ┃ unLet t = fixup (go t) | |
| 705 ┃ where | |
| 706 ┃ go (ABT.Tm' (Let isTop b (ABT.out -> ABT.Abs v t))) = case go t of | |
| Delete this definition or add ‘Unison.Term.unLet’ as a root to fix this error. | |
| src/Unison/Term.hs:697:1: error: unLet1 is unused | |
| 695 ┃ => Term' vt v a | |
| 696 ┃ -> Maybe (IsTop, Term' vt v a, ABT.Subst (F vt a a) v a) | |
| 697 ┃ unLet1 (ABT.Tm' (Let isTop b (ABT.Abs' subst))) = Just (isTop, b, subst) | |
| 698 ┃ unLet1 _ = Nothing | |
| 699 ┃ | |
| Delete this definition or add ‘Unison.Term.unLet1’ as a root to fix this error. | |
| src/Unison/Term.hs:735:1: error: unLetRec is unused | |
| 733 ┃ ) | |
| 734 ┃ ) | |
| 735 ┃ unLetRec (unLetRecNamed -> Just (isTop, bs, e)) = Just | |
| 736 ┃ ( isTop | |
| 737 ┃ , \freshen -> do | |
| Delete this definition or add ‘Unison.Term.unLetRec’ as a root to fix this error. | |
| src/Unison/Term.hs:720:1: error: unLetRecNamed is unused | |
| 718 ┃ , Term2 vt at ap v a | |
| 719 ┃ ) | |
| 720 ┃ unLetRecNamed (ABT.Cycle' vs (ABT.Tm' (LetRec isTop bs e))) | |
| 721 ┃ | length vs == length bs = Just (isTop, zip vs bs, e) | |
| 722 ┃ unLetRecNamed _ = Nothing | |
| Delete this definition or add ‘Unison.Term.unLetRecNamed’ as a root to fix this error. | |
| src/Unison/Term.hs:598:1: error: unLetRecNamedAnnotated is unused | |
| 596 ┃ -> Maybe | |
| 597 ┃ (IsTop, a, [((a, v), Term' vt v a)], Term' vt v a) | |
| 598 ┃ unLetRecNamedAnnotated (ABT.CycleA' ann avs (ABT.Tm' (LetRec isTop bs e))) = | |
| 599 ┃ Just (isTop, ann, avs `zip` bs, e) | |
| 600 ┃ unLetRecNamedAnnotated _ = Nothing | |
| Delete this definition or add ‘Unison.Term.unLetRecNamedAnnotated’ as a root to fix this error. | |
| src/Unison/Term.hs:817:1: error: unReqOrCtor is unused | |
| 815 ┃ | |
| 816 ┃ unReqOrCtor :: Term2 vt at ap v a -> Maybe (Reference, ConstructorId) | |
| 817 ┃ unReqOrCtor (Constructor' r cid) = Just (r, cid) | |
| 818 ┃ unReqOrCtor (Request' r cid) = Just (r, cid) | |
| 819 ┃ unReqOrCtor _ = Nothing | |
| Delete this definition or add ‘Unison.Term.unReqOrCtor’ as a root to fix this error. | |
| src/Unison/Term.hs:466:1: error: var' is unused | |
| 464 ┃ | |
| 465 ┃ var' :: Var v => Text -> Term0' vt v | |
| 466 ┃ var' = var() . Var.named | |
| 467 ┃ | |
| 468 ┃ ref :: Ord v => a -> Reference -> Term2 vt at ap v a | |
| Delete this definition or add ‘Unison.Term.var'’ as a root to fix this error. | |
| src/Unison/Term.hs:502:1: error: watch is unused | |
| 500 ┃ | |
| 501 ┃ watch :: (Var v, Semigroup a) => a -> String -> Term v a -> Term v a | |
| 502 ┃ watch a note e = | |
| 503 ┃ apps' (builtin a "Debug.watch") [text a (Text.pack note), e] | |
| 504 ┃ | |
| Delete this definition or add ‘Unison.Term.watch’ as a root to fix this error. | |
| src/Unison/Term.hs:506:1: error: watchMaybe is unused | |
| 504 ┃ | |
| 505 ┃ watchMaybe :: (Var v, Semigroup a) => Maybe String -> Term v a -> Term v a | |
| 506 ┃ watchMaybe Nothing e = e | |
| 507 ┃ watchMaybe (Just note) e = watch (ABT.annotation e) note e | |
| 508 ┃ | |
| Delete this definition or add ‘Unison.Term.watchMaybe’ as a root to fix this error. | |
| src/Unison/Term.hs:280:1: error: wrapV is unused | |
| 278 ┃ | |
| 279 ┃ wrapV :: Ord v => Term v a -> Term (ABT.V v) a | |
| 280 ┃ wrapV = vmap ABT.Bound | |
| 281 ┃ | |
| 282 ┃ -- | All variables mentioned in the given term. | |
| Delete this definition or add ‘Unison.Term.wrapV’ as a root to fix this error. | |
| src/Unison/TermParser.hs:677:1: error: var is unused | |
| 675 ┃ | |
| 676 ┃ var :: Var v => L.Token v -> Term v Ann | |
| 677 ┃ var t = Term.var (ann t) (L.payload t) | |
| 678 ┃ | |
| 679 ┃ seqOp :: Ord v => P v Pattern.SeqOp | |
| Delete this definition or add ‘Unison.TermParser.var’ as a root to fix this error. | |
| src/Unison/TermParser.hs:715:1: error: verifyRelativeName is unused | |
| 713 ┃ | |
| 714 ┃ verifyRelativeName :: Ord v => P v (L.Token Name) -> P v (L.Token Name) | |
| 715 ┃ verifyRelativeName name = do | |
| 716 ┃ name <- name | |
| 717 ┃ verifyRelativeName' name | |
| Delete this definition or add ‘Unison.TermParser.verifyRelativeName’ as a root to fix this error. | |
| src/Unison/TermParser.hs:51:1: error: watch is unused | |
| 49 ┃ | |
| 50 ┃ watch :: Show a => String -> a -> a | |
| 51 ┃ watch msg a = let !_ = trace (msg ++ ": " ++ show a) () in a | |
| 52 ┃ | |
| 53 ┃ {- | |
| Delete this definition or add ‘Unison.TermParser.watch’ as a root to fix this error. | |
| src/Unison/TermPrinter.hs:526:1: error: prettyBinding' is unused | |
| 524 ┃ prettyBinding' :: | |
| 525 ┃ Var v => Int -> PrettyPrintEnv -> HQ.HashQualified -> Term v a -> ColorText | |
| 526 ┃ prettyBinding' width n v t = PP.render width $ PP.syntaxToColor $ prettyBinding n v t | |
| 527 ┃ | |
| 528 ┃ prettyBinding0 | |
| Delete this definition or add ‘Unison.TermPrinter.prettyBinding'’ as a root to fix this error. | |
| src/Unison/TermPrinter.hs:1186:1: error: toBytes is unused | |
| 1184 ┃ | |
| 1185 ┃ toBytes :: Term3 v PrintAnnotation -> Maybe [Word64] | |
| 1186 ┃ toBytes (App' (Builtin' "Bytes.fromList") (Sequence' bs)) = | |
| 1187 ┃ toList <$> traverse go bs | |
| 1188 ┃ where go (Nat' n) = Just n | |
| Delete this definition or add ‘Unison.TermPrinter.toBytes’ as a root to fix this error. | |
| src/Unison/TermPrinter.hs:1143:1: error: unLamsMatch' is unused | |
| 1141 ┃ => Term2 vt at ap v a | |
| 1142 ┃ -> Maybe ([v], [([Pattern ap], Maybe (Term2 vt at ap v a), Term2 vt at ap v a)]) | |
| 1143 ┃ unLamsMatch' t = case unLamsUntilDelay' t of | |
| 1144 ┃ -- x -> match x with pat -> ... | |
| 1145 ┃ -- becomes | |
| Delete this definition or add ‘Unison.TermPrinter.unLamsMatch'’ as a root to fix this error. | |
| src/Unison/TermPrinter.hs:1087:1: error: unLetBlock is unused | |
| 1085 ┃ => Term2 vt at ap v a | |
| 1086 ┃ -> Maybe ([(v, Term2 vt at ap v a)], Term2 vt at ap v a) | |
| 1087 ┃ unLetBlock t = rec t where | |
| 1088 ┃ dontIntersect v1s v2s = | |
| 1089 ┃ all (`Set.notMember` v2set) (fst <$> v1s) where | |
| Delete this definition or add ‘Unison.TermPrinter.unLetBlock’ as a root to fix this error. | |
| src/Unison/Type.hs:365:1: error: andor is unused | |
| 363 ┃ | |
| 364 ┃ andor :: Ord v => Type v () | |
| 365 ┃ andor = arrows (f <$> [boolean(), boolean()]) $ boolean() | |
| 366 ┃ where f x = ((), x) | |
| 367 ┃ | |
| Delete this definition or add ‘Unison.Type.andor’ as a root to fix this error. | |
| src/Unison/Type.hs:205:1: error: derivedBase32Hex is unused | |
| 203 ┃ | |
| 204 ┃ derivedBase32Hex :: Ord v => Reference -> a -> Type v a | |
| 205 ┃ derivedBase32Hex r a = ref a r | |
| 206 ┃ | |
| 207 ┃ -- derivedBase58' :: Text -> Reference | |
| Delete this definition or add ‘Unison.Type.derivedBase32Hex’ as a root to fix this error. | |
| src/Unison/Type.hs:311:1: error: effectType is unused | |
| 309 ┃ | |
| 310 ┃ effectType :: Ord v => a -> Type v a | |
| 311 ┃ effectType a = ref a $ effectRef | |
| 312 ┃ | |
| 313 ┃ code, value :: Ord v => a -> Type v a | |
| Delete this definition or add ‘Unison.Type.effectType’ as a root to fix this error. | |
| src/Unison/Type.hs:428:1: error: flipApply is unused | |
| 426 ┃ -- `(a -> (a -> b) -> b)` | |
| 427 ┃ flipApply :: Var v => Type v () -> Type v () | |
| 428 ┃ flipApply t = forall() b $ arrow() (arrow() t (var() b)) (var() b) | |
| 429 ┃ where b = ABT.fresh t (Var.named "b") | |
| 430 ┃ | |
| Delete this definition or add ‘Unison.Type.flipApply’ as a root to fix this error. | |
| src/Unison/Type.hs:383:1: error: forall' is unused | |
| 381 ┃ | |
| 382 ┃ forall' :: Var v => a -> [Text] -> Type v a -> Type v a | |
| 383 ┃ forall' a vs body = foldr (forall a) body (Var.named <$> vs) | |
| 384 ┃ | |
| 385 ┃ foralls :: Ord v => a -> [v] -> Type v a -> Type v a | |
| Delete this definition or add ‘Unison.Type.forall'’ as a root to fix this error. | |
| src/Unison/Type.hs:567:1: error: functionResult is unused | |
| 565 ┃ | |
| 566 ┃ functionResult :: Type v a -> Maybe (Type v a) | |
| 567 ┃ functionResult = go False | |
| 568 ┃ where | |
| 569 ┃ go inArr (ForallNamed' _ body) = go inArr body | |
| Delete this definition or add ‘Unison.Type.functionResult’ as a root to fix this error. | |
| src/Unison/Type.hs:655:1: error: hashComponents is unused | |
| 653 ┃ hashComponents | |
| 654 ┃ :: Var v => Map v (Type v a) -> Map v (Reference.Id, Type v a) | |
| 655 ┃ hashComponents = ReferenceUtil.hashComponents $ refId () | |
| 656 ┃ | |
| 657 ┃ instance Hashable1 F where | |
| Delete this definition or add ‘Unison.Type.hashComponents’ as a root to fix this error. | |
| src/Unison/Type.hs:347:1: error: iff is unused | |
| 345 ┃ | |
| 346 ┃ iff :: Var v => Type v () | |
| 347 ┃ iff = forall () aa $ arrows (f <$> [boolean(), a, a]) a | |
| 348 ┃ where aa = Var.named "a" | |
| 349 ┃ a = var () aa | |
| Delete this definition or add ‘Unison.Type.iff’ as a root to fix this error. | |
| src/Unison/Type.hs:353:1: error: iff' is unused | |
| 351 ┃ | |
| 352 ┃ iff' :: Var v => a -> Type v a | |
| 353 ┃ iff' loc = forall loc aa $ arrows (f <$> [boolean loc, a, a]) a | |
| 354 ┃ where aa = Var.named "a" | |
| 355 ┃ a = var loc aa | |
| Delete this definition or add ‘Unison.Type.iff'’ as a root to fix this error. | |
| src/Unison/Type.hs:183:1: error: isArrow is unused | |
| 181 ┃ -- | True if the given type is a function, possibly quantified | |
| 182 ┃ isArrow :: ABT.Var v => Type v a -> Bool | |
| 183 ┃ isArrow (ForallNamed' _ t) = isArrow t | |
| 184 ┃ isArrow (Arrow' _ _) = True | |
| 185 ┃ isArrow _ = False | |
| Delete this definition or add ‘Unison.Type.isArrow’ as a root to fix this error. | |
| src/Unison/Type.hs:145:1: error: unApps is unused | |
| 143 ┃ | |
| 144 ┃ unApps :: Type v a -> Maybe (Type v a, [Type v a]) | |
| 145 ┃ unApps t = case go t [] of | |
| 146 ┃ [] -> Nothing | |
| 147 ┃ [ _ ] -> Nothing | |
| Delete this definition or add ‘Unison.Type.unApps’ as a root to fix this error. | |
| src/Unison/Type.hs:174:1: error: unEffect0 is unused | |
| 172 ┃ | |
| 173 ┃ unEffect0 :: Ord v => Type v a -> ([Type v a], Type v a) | |
| 174 ┃ unEffect0 (Effect1' e a) = (flattenEffects e, a) | |
| 175 ┃ unEffect0 t = ([], t) | |
| 176 ┃ | |
| Delete this definition or add ‘Unison.Type.unEffect0’ as a root to fix this error. | |
| src/Unison/Type.hs:134:1: error: unEffectfulArrows is unused | |
| 132 ┃ unEffectfulArrows | |
| 133 ┃ :: Type v a -> Maybe (Type v a, [(Maybe [Type v a], Type v a)]) | |
| 134 ┃ unEffectfulArrows t = case t of | |
| 135 ┃ Arrow' i o -> Just (i, go o) | |
| 136 ┃ _ -> Nothing | |
| Delete this definition or add ‘Unison.Type.unEffectfulArrows’ as a root to fix this error. | |
| src/Unison/Type.hs:178:1: error: unEffects1 is unused | |
| 176 ┃ | |
| 177 ┃ unEffects1 :: Ord v => Type v a -> Maybe ([Type v a], Type v a) | |
| 178 ┃ unEffects1 (Effect1' (Effects' es) a) = Just (es, a) | |
| 179 ┃ unEffects1 _ = Nothing | |
| 180 ┃ | |
| Delete this definition or add ‘Unison.Type.unEffects1’ as a root to fix this error. | |
| src/Unison/Type.hs:122:1: error: unPure is unused | |
| 120 ┃ | |
| 121 ┃ unPure :: Ord v => Type v a -> Maybe (Type v a) | |
| 122 ┃ unPure (Effect'' [] t) = Just t | |
| 123 ┃ unPure (Effect'' _ _) = Nothing | |
| 124 ┃ unPure t = Just t | |
| Delete this definition or add ‘Unison.Type.unPure’ as a root to fix this error. | |
| src/Unison/Type.hs:443:1: error: unforall is unused | |
| 441 ┃ | |
| 442 ┃ unforall :: Type v a -> Type v a | |
| 443 ┃ unforall (ForallsNamed' _ t) = t | |
| 444 ┃ unforall t = t | |
| 445 ┃ | |
| Delete this definition or add ‘Unison.Type.unforall’ as a root to fix this error. | |
| src/Unison/Type.hs:462:1: error: usesEffects is unused | |
| 460 ┃ | |
| 461 ┃ usesEffects :: Ord v => Type v a -> Bool | |
| 462 ┃ usesEffects t = getAny . getConst $ ABT.visit go t where | |
| 463 ┃ go (Effect1' _ _) = Just (Const (Any True)) | |
| 464 ┃ go _ = Nothing | |
| Delete this definition or add ‘Unison.Type.usesEffects’ as a root to fix this error. | |
| src/Unison/Type.hs:376:1: error: v' is unused | |
| 374 ┃ | |
| 375 ┃ v' :: Var v => Text -> Type v () | |
| 376 ┃ v' s = ABT.var (Var.named s) | |
| 377 ┃ | |
| 378 ┃ -- Like `v'`, but creates an annotated variable given an annotation | |
| Delete this definition or add ‘Unison.Type.v'’ as a root to fix this error. | |
| src/Unison/Type.hs:57:1: error: wrapV is unused | |
| 55 ┃ | |
| 56 ┃ wrapV :: Ord v => Type v a -> Type (ABT.V v) a | |
| 57 ┃ wrapV = ABT.vmap ABT.Bound | |
| 58 ┃ | |
| 59 ┃ freeVars :: Type v a -> Set v | |
| Delete this definition or add ‘Unison.Type.wrapV’ as a root to fix this error. | |
| src/Unison/TypePrinter.hs:184:1: error: prettySignaturesAlt is unused | |
| 182 ┃ -> [([HashQualified], Type v a)] | |
| 183 ┃ -> Pretty ColorText | |
| 184 ┃ prettySignaturesAlt env ts = PP.lines $ | |
| 185 ┃ PP.group <$> prettySignaturesAlt' env ts | |
| Delete this definition or add ‘Unison.TypePrinter.prettySignaturesAlt’ as a root to fix this error. | |
| src/Unison/TypePrinter.hs:158:1: error: prettySignaturesAlt' is unused | |
| 156 ┃ -> [([HashQualified], Type v a)] | |
| 157 ┃ -> [Pretty ColorText] | |
| 158 ┃ prettySignaturesAlt' env ts = map PP.syntaxToColor $ PP.align | |
| 159 ┃ [ ( PP.commas . fmap (\name -> styleHashQualified'' (fmt $ S.HashQualifier name) name) $ names | |
| 160 ┃ , (fmt S.TypeAscriptionColon ": " <> pretty0 env Map.empty (-1) typ) | |
| Delete this definition or add ‘Unison.TypePrinter.prettySignaturesAlt'’ as a root to fix this error. | |
| src/Unison/Typechecker.hs:318:1: error: check is unused | |
| 316 ┃ -> Type v loc | |
| 317 ┃ -> ResultT (Notes v loc) f (Type v loc) | |
| 318 ┃ check env term typ = synthesize env (Term.ann (ABT.annotation term) term typ) | |
| 319 ┃ -- | `checkAdmissible' e t` tests that `(f : t -> r) e` is well-typed. | |
| 320 ┃ -- If `t` has quantifiers, these are moved outside, so if `t : forall a . a`, | |
| Delete this definition or add ‘Unison.Typechecker.check’ as a root to fix this error. | |
| src/Unison/Typechecker.hs:330:1: error: wellTyped is unused | |
| 328 ┃ -- | Returns `True` if the expression is well-typed, `False` otherwise | |
| 329 ┃ wellTyped :: (Monad f, Var v, Ord loc) => Env v loc -> Term v loc -> f Bool | |
| 330 ┃ wellTyped env term = go <$> runResultT (synthesize env term) | |
| 331 ┃ where go (may, _) = isJust may | |
| 332 ┃ | |
| Delete this definition or add ‘Unison.Typechecker.wellTyped’ as a root to fix this error. | |
| src/Unison/Typechecker/Context.hs:477:1: error: _logContext is unused | |
| 475 ┃ | |
| 476 ┃ _logContext :: (Ord loc, Var v) => String -> M v loc () | |
| 477 ┃ _logContext msg = when debugEnabled $ do | |
| 478 ┃ ctx <- getContext | |
| 479 ┃ let !_ = trace ("\n"++msg ++ ": " ++ show ctx) () | |
| Delete this definition or add ‘Unison.Typechecker.Context._logContext’ as a root to fix this error. | |
| src/Unison/Typechecker/Context.hs:1929:1: error: isEqual is unused | |
| 1927 ┃ isEqual | |
| 1928 ┃ :: (Var v, Ord loc) => Type v loc -> Type v loc -> Either (CompilerBug v loc) Bool | |
| 1929 ┃ isEqual t1 t2 = | |
| 1930 ┃ (&&) <$> isSubtype t1 t2 <*> isSubtype t2 t1 | |
| 1931 ┃ | |
| Delete this definition or add ‘Unison.Typechecker.Context.isEqual’ as a root to fix this error. | |
| src/Unison/Typechecker/Extractor.hs:93:1: error: _any is unused | |
| 91 ┃ -- unused / untested | |
| 92 ┃ _any :: SubseqExtractor v loc () | |
| 93 ┃ _any = _any' (\n -> pathLength n - 1) | |
| 94 ┃ where | |
| 95 ┃ pathLength :: C.ErrorNote v loc -> Int | |
| Delete this definition or add ‘Unison.Typechecker.Extractor._any’ as a root to fix this error. | |
| src/Unison/Typechecker/Extractor.hs:99:1: error: _any' is unused | |
| 97 ┃ | |
| 98 ┃ _any' :: (n -> Int) -> SubseqExtractor' n () | |
| 99 ┃ _any' getLast = SubseqExtractor' $ \note -> Pure () : do | |
| 100 ┃ let last = getLast note | |
| 101 ┃ start <- [0 .. last] | |
| Delete this definition or add ‘Unison.Typechecker.Extractor._any'’ as a root to fix this error. | |
| src/Unison/Typechecker/Extractor.hs:68:1: error: _no is unused | |
| 66 ┃ -- unused, but don't want to delete it yet - Aug 30, 2018 | |
| 67 ┃ _no :: SubseqExtractor' n a -> SubseqExtractor' n () | |
| 68 ┃ _no xa = SubseqExtractor' $ \note -> | |
| 69 ┃ let as = runSubseq xa note | |
| 70 ┃ in if null [ a | Pure a <- as ] | |
| Delete this definition or add ‘Unison.Typechecker.Extractor._no’ as a root to fix this error. | |
| src/Unison/Typechecker/Extractor.hs:262:1: error: effectConstructorWrongArgCount is unused | |
| 260 ┃ loc | |
| 261 ┃ (C.ExpectedArgCount, C.ActualArgCount, Reference, C.ConstructorId) | |
| 262 ┃ effectConstructorWrongArgCount = cause >>= \case | |
| 263 ┃ C.EffectConstructorWrongArgCount expected actual r cid -> | |
| 264 ┃ pure (expected, actual, r, cid) | |
| Delete this definition or add ‘Unison.Typechecker.Extractor.effectConstructorWrongArgCount’ as a root to fix this error. | |
| src/Unison/Typechecker/Extractor.hs:234:1: error: illFormedType is unused | |
| 232 ┃ | |
| 233 ┃ illFormedType :: ErrorExtractor v loc (C.Context v loc) | |
| 234 ┃ illFormedType = cause >>= \case | |
| 235 ┃ C.IllFormedType c -> pure c | |
| 236 ┃ _ -> mzero | |
| Delete this definition or add ‘Unison.Typechecker.Extractor.illFormedType’ as a root to fix this error. | |
| src/Unison/Typechecker/Extractor.hs:160:1: error: inSynthesize is unused | |
| 158 ┃ | |
| 159 ┃ inSynthesize :: SubseqExtractor v loc (C.Term v loc) | |
| 160 ┃ inSynthesize = asPathExtractor $ \case | |
| 161 ┃ C.InSynthesize t -> Just t | |
| 162 ┃ _ -> Nothing | |
| Delete this definition or add ‘Unison.Typechecker.Extractor.inSynthesize’ as a root to fix this error. | |
| src/Unison/Typechecker/Extractor.hs:283:1: error: infoNote is unused | |
| 281 ┃ | |
| 282 ┃ infoNote :: InfoExtractor v loc (C.InfoNote v loc) | |
| 283 ┃ infoNote = extractor $ Just . id | |
| 284 ┃ | |
| 285 ┃ innermostTerm :: ErrorExtractor v loc (C.Term v loc) | |
| Delete this definition or add ‘Unison.Typechecker.Extractor.infoNote’ as a root to fix this error. | |
| src/Unison/Typechecker/Extractor.hs:269:1: error: malformedEffectBind is unused | |
| 267 ┃ malformedEffectBind | |
| 268 ┃ :: ErrorExtractor v loc (C.Type v loc, C.Type v loc, [C.Type v loc]) | |
| 269 ┃ malformedEffectBind = cause >>= \case | |
| 270 ┃ C.MalformedEffectBind ctor ctorResult es -> pure (ctor, ctorResult, es) | |
| 271 ┃ _ -> mzero | |
| Delete this definition or add ‘Unison.Typechecker.Extractor.malformedEffectBind’ as a root to fix this error. | |
| src/Unison/Typechecker/Extractor.hs:274:1: error: solvedBlank is unused | |
| 272 ┃ | |
| 273 ┃ solvedBlank :: InfoExtractor v loc (B.Recorded loc, v, C.Type v loc) | |
| 274 ┃ solvedBlank = extractor $ \n -> case n of | |
| 275 ┃ C.SolvedBlank b v t -> pure (b, v, t) | |
| 276 ┃ _ -> mzero | |
| Delete this definition or add ‘Unison.Typechecker.Extractor.solvedBlank’ as a root to fix this error. | |
| src/Unison/Typechecker/Extractor.hs:299:1: error: topLevelComponent is unused | |
| 297 ┃ loc | |
| 298 ┃ [(v, Type v loc, RedundantTypeAnnotation)] | |
| 299 ┃ topLevelComponent = extractor go | |
| 300 ┃ where | |
| 301 ┃ go (C.TopLevelComponent c) = Just c | |
| Delete this definition or add ‘Unison.Typechecker.Extractor.topLevelComponent’ as a root to fix this error. | |
| src/Unison/Typechecker/Extractor.hs:47:1: error: traceNote is unused | |
| 45 ┃ traceNote | |
| 46 ┃ :: Show a => String -> ErrorExtractor v loc a -> ErrorExtractor v loc a | |
| 47 ┃ traceNote s ex = extractor $ \n -> | |
| 48 ┃ let result = extract ex n | |
| 49 ┃ in trace (if null s then show result else s ++ ": " ++ show result) result | |
| Delete this definition or add ‘Unison.Typechecker.Extractor.traceNote’ as a root to fix this error. | |
| src/Unison/Typechecker/Extractor.hs:41:1: error: traceSubseq is unused | |
| 39 ┃ | |
| 40 ┃ traceSubseq :: Show a => String -> SubseqExtractor' n a -> SubseqExtractor' n a | |
| 41 ┃ traceSubseq s ex = SubseqExtractor' $ \n -> | |
| 42 ┃ let rs = runSubseq ex n | |
| 43 ┃ in trace (if null s then show rs else s ++ ": " ++ show rs) rs | |
| Delete this definition or add ‘Unison.Typechecker.Extractor.traceSubseq’ as a root to fix this error. | |
| src/Unison/Typechecker/TypeError.hs:124:1: error: topLevelComponent is unused | |
| 122 ┃ | |
| 123 ┃ topLevelComponent :: Ex.InfoExtractor v a (TypeInfo v a) | |
| 124 ┃ topLevelComponent = do | |
| 125 ┃ defs <- Ex.topLevelComponent | |
| 126 ┃ pure $ TopLevelComponent defs | |
| Delete this definition or add ‘Unison.Typechecker.TypeError.topLevelComponent’ as a root to fix this error. | |
| src/Unison/Typechecker/TypeLookup.hs:34:1: error: constructorType is unused | |
| 32 ┃ | |
| 33 ┃ constructorType :: TypeLookup v a -> Reference -> Maybe CT.ConstructorType | |
| 34 ┃ constructorType tl r = | |
| 35 ┃ (const CT.Data <$> Map.lookup r (dataDecls tl)) <|> | |
| 36 ┃ (const CT.Effect <$> Map.lookup r (effectDecls tl)) | |
| Delete this definition or add ‘Unison.Typechecker.TypeLookup.constructorType’ as a root to fix this error. | |
| src/Unison/Typechecker/TypeLookup.hs:29:1: error: unsafeConstructorType is unused | |
| 27 ┃ -- bombs if not found | |
| 28 ┃ unsafeConstructorType :: TypeLookup v a -> Reference -> CT.ConstructorType | |
| 29 ┃ unsafeConstructorType tl r = fromMaybe | |
| 30 ┃ (error $ "no constructor type for " <> show r) | |
| 31 ┃ (constructorType tl r) | |
| Delete this definition or add ‘Unison.Typechecker.TypeLookup.unsafeConstructorType’ as a root to fix this error. | |
| src/Unison/UnisonFile.hs:279:1: error: bindNames is unused | |
| 277 ┃ -> UnisonFile v a | |
| 278 ┃ -> Names.ResolutionResult v a (UnisonFile v a) | |
| 279 ┃ bindNames names (UnisonFileId d e ts ws) = do | |
| 280 ┃ -- todo: consider having some kind of binding structure for terms & watches | |
| 281 ┃ -- so that you don't weirdly have free vars to tiptoe around. | |
| Delete this definition or add ‘Unison.UnisonFile.bindNames’ as a root to fix this error. | |
| src/Unison/UnisonFile.hs:292:1: error: constructorType is unused | |
| 290 ┃ constructorType :: | |
| 291 ┃ Var v => UnisonFile v a -> Reference -> Maybe CT.ConstructorType | |
| 292 ┃ constructorType = TL.constructorType . declsToTypeLookup | |
| 293 ┃ | |
| 294 ┃ data Env v a = Env | |
| Delete this definition or add ‘Unison.UnisonFile.constructorType’ as a root to fix this error. | |
| src/Unison/UnisonFile.hs:183:1: error: dependencies' is unused | |
| 181 ┃ dependencies' :: | |
| 182 ┃ forall v a. Var v => TypecheckedUnisonFile v a -> Relation Reference.Id Reference | |
| 183 ┃ dependencies' file = let | |
| 184 ┃ terms :: Map v (Reference.Id, Term v a, Type v a) | |
| 185 ┃ terms = hashTermsId file | |
| Delete this definition or add ‘Unison.UnisonFile.dependencies'’ as a root to fix this error. | |
| src/Unison/UnisonFile.hs:307:1: error: effects is unused | |
| 305 ┃ | |
| 306 ┃ effects :: Env v a -> Map v (Reference, EffectDeclaration v a) | |
| 307 ┃ effects = fmap (first Reference.DerivedId) . effectsId | |
| 308 ┃ | |
| 309 ┃ data Error v a | |
| Delete this definition or add ‘Unison.UnisonFile.effects’ as a root to fix this error. | |
| src/Unison/UnisonFile.hs:157:1: error: getDecl' is unused | |
| 155 ┃ | |
| 156 ┃ getDecl' :: Ord v => TypecheckedUnisonFile v a -> v -> Maybe (DD.Decl v a) | |
| 157 ┃ getDecl' uf v = | |
| 158 ┃ (Right . snd <$> Map.lookup v (dataDeclarations' uf)) <|> | |
| 159 ┃ (Left . snd <$> Map.lookup v (effectDeclarations' uf)) | |
| Delete this definition or add ‘Unison.UnisonFile.getDecl'’ as a root to fix this error. | |
| src/Unison/UnisonFile.hs:246:1: error: typecheckedUnisonFile0 is unused | |
| 244 ┃ | |
| 245 ┃ typecheckedUnisonFile0 :: Ord v => TypecheckedUnisonFile v a | |
| 246 ┃ typecheckedUnisonFile0 = TypecheckedUnisonFileId Map.empty Map.empty mempty mempty mempty | |
| 247 ┃ | |
| 248 ┃ -- Returns true if the file has any definitions or watches | |
| Delete this definition or add ‘Unison.UnisonFile.typecheckedUnisonFile0’ as a root to fix this error. | |
| src/Unison/UnisonFile.hs:88:1: error: uberTerm' is unused | |
| 86 ┃ -- Converts a file and a body to a single let rec with the given body. | |
| 87 ┃ uberTerm' :: (Var v, Monoid a) => UnisonFile v a -> Term v a -> Term v a | |
| 88 ┃ uberTerm' uf body = | |
| 89 ┃ Term.letRec' True (terms uf <> allWatches uf) $ body | |
| 90 ┃ | |
| Delete this definition or add ‘Unison.UnisonFile.uberTerm'’ as a root to fix this error. | |
| src/Unison/Util/AnnotatedText.hs:88:1: error: deannotate is unused | |
| 86 ┃ | |
| 87 ┃ deannotate :: AnnotatedText a -> AnnotatedText b | |
| 88 ┃ deannotate = annotate' Nothing | |
| 89 ┃ | |
| 90 ┃ -- Replace the annotation (whether existing or no) with the given annotation | |
| Delete this definition or add ‘Unison.Util.AnnotatedText.deannotate’ as a root to fix this error. | |
| src/Unison/Util/AnnotatedText.hs:118:1: error: textEmpty is unused | |
| 116 ┃ | |
| 117 ┃ textEmpty :: AnnotatedText a -> Bool | |
| 118 ┃ textEmpty = (==0) . textLength | |
| 119 ┃ | |
| 120 ┃ condensedExcerptToText :: Int -> AnnotatedExcerpt a -> AnnotatedText a | |
| Delete this definition or add ‘Unison.Util.AnnotatedText.textEmpty’ as a root to fix this error. | |
| src/Unison/Util/AnnotatedText.hs:114:1: error: textLength is unused | |
| 112 ┃ | |
| 113 ┃ textLength :: AnnotatedText a -> Int | |
| 114 ┃ textLength (AnnotatedText chunks) = foldl' go 0 chunks | |
| 115 ┃ where go len (text, _a) = len + length text | |
| 116 ┃ | |
| Delete this definition or add ‘Unison.Util.AnnotatedText.textLength’ as a root to fix this error. | |
| src/Unison/Util/AnnotatedText.hs:99:1: error: trailingNewLine is unused | |
| 97 ┃ | |
| 98 ┃ trailingNewLine :: AnnotatedText a -> Bool | |
| 99 ┃ trailingNewLine (AnnotatedText (init :|> (s,_))) = | |
| 100 ┃ case lastMay s of | |
| 101 ┃ Just '\n' -> True | |
| Delete this definition or add ‘Unison.Util.AnnotatedText.trailingNewLine’ as a root to fix this error. | |
| src/Unison/Util/Bytes.hs:56:1: error: cons is unused | |
| 54 ┃ | |
| 55 ┃ cons :: B.ByteArrayAccess ba => ba -> Bytes -> Bytes | |
| 56 ┃ cons b bs | B.null b = bs | |
| 57 ┃ cons b (Bytes bs) = Bytes (view (B.convert b) T.<| bs) | |
| 58 ┃ | |
| Delete this definition or add ‘Unison.Util.Bytes.cons’ as a root to fix this error. | |
| src/Unison/Util/Bytes.hs:28:1: error: null is unused | |
| 26 ┃ | |
| 27 ┃ null :: Bytes -> Bool | |
| 28 ┃ null (Bytes bs) = T.null bs | |
| 29 ┃ | |
| 30 ┃ empty :: Bytes | |
| Delete this definition or add ‘Unison.Util.Bytes.null’ as a root to fix this error. | |
| src/Unison/Util/ColorText.hs:36:1: error: hiCyan is unused | |
| 34 ┃ hiBlue = style HiBlue | |
| 35 ┃ hiPurple = style HiPurple | |
| 36 ┃ hiCyan = style HiCyan | |
| 37 ┃ hiWhite = style HiWhite | |
| 38 ┃ bold = style Bold | |
| Delete this definition or add ‘Unison.Util.ColorText.hiCyan’ as a root to fix this error. | |
| src/Unison/Util/ColorText.hs:35:1: error: hiPurple is unused | |
| 33 ┃ hiYellow = style HiYellow | |
| 34 ┃ hiBlue = style HiBlue | |
| 35 ┃ hiPurple = style HiPurple | |
| 36 ┃ hiCyan = style HiCyan | |
| 37 ┃ hiWhite = style HiWhite | |
| Delete this definition or add ‘Unison.Util.ColorText.hiPurple’ as a root to fix this error. | |
| src/Unison/Util/ColorText.hs:37:1: error: hiWhite is unused | |
| 35 ┃ hiPurple = style HiPurple | |
| 36 ┃ hiCyan = style HiCyan | |
| 37 ┃ hiWhite = style HiWhite | |
| 38 ┃ bold = style Bold | |
| 39 ┃ underline = style Underline | |
| Delete this definition or add ‘Unison.Util.ColorText.hiWhite’ as a root to fix this error. | |
| src/Unison/Util/ColorText.hs:45:1: error: toHTML is unused | |
| 43 ┃ | |
| 44 ┃ toHTML :: String -> ColorText -> String | |
| 45 ┃ toHTML cssPrefix (AnnotatedText at) = toList at >>= \case | |
| 46 ┃ (s, color) -> wrap color (s >>= newlineToBreak) | |
| 47 ┃ where | |
| Delete this definition or add ‘Unison.Util.ColorText.toHTML’ as a root to fix this error. | |
| src/Unison/Util/ColorText.hs:29:1: error: white is unused | |
| 27 ┃ purple = style Purple | |
| 28 ┃ cyan = style Cyan | |
| 29 ┃ white = style White | |
| 30 ┃ hiBlack = style HiBlack | |
| 31 ┃ hiRed = style HiRed | |
| Delete this definition or add ‘Unison.Util.ColorText.white’ as a root to fix this error. | |
| src/Unison/Util/CyclicEq.hs:29:1: error: bothEq' is unused | |
| 27 ┃ bothEq' :: (Eq a, CyclicEq b) => CT.CycleTable Int Int -> CT.CycleTable Int Int | |
| 28 ┃ -> a -> a -> b -> b -> IO Bool | |
| 29 ┃ bothEq' h1 h2 a1 a2 b1 b2 = | |
| 30 ┃ if a1 == a2 then cyclicEq h1 h2 b1 b2 | |
| 31 ┃ else pure False | |
| Delete this definition or add ‘Unison.Util.CyclicEq.bothEq'’ as a root to fix this error. | |
| src/Unison/Util/EnumContainers.hs:93:1: error: keys is unused | |
| 91 ┃ | |
| 92 ┃ keys :: EnumKey k => EnumMap k a -> [k] | |
| 93 ┃ keys (EM m) = fmap intToKey . IM.keys $ m | |
| 94 ┃ | |
| 95 ┃ restrictKeys :: EnumKey k => EnumMap k a -> EnumSet k -> EnumMap k a | |
| Delete this definition or add ‘Unison.Util.EnumContainers.keys’ as a root to fix this error. | |
| src/Unison/Util/EnumContainers.hs:82:1: error: setSingleton is unused | |
| 80 ┃ | |
| 81 ┃ setSingleton :: EnumKey k => k -> EnumSet k | |
| 82 ┃ setSingleton e = ES . IS.singleton $ keyToInt e | |
| 83 ┃ | |
| 84 ┃ mapInsert :: EnumKey k => k -> a -> EnumMap k a -> EnumMap k a | |
| Delete this definition or add ‘Unison.Util.EnumContainers.setSingleton’ as a root to fix this error. | |
| src/Unison/Util/EnumContainers.hs:90:1: error: unionWith is unused | |
| 88 ┃ :: EnumKey k => EnumKey k | |
| 89 ┃ => (a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a | |
| 90 ┃ unionWith f (EM l) (EM r) = EM $ IM.unionWith f l r | |
| 91 ┃ | |
| 92 ┃ keys :: EnumKey k => EnumMap k a -> [k] | |
| Delete this definition or add ‘Unison.Util.EnumContainers.unionWith’ as a root to fix this error. | |
| src/Unison/Util/Exception.hs:16:1: error: catchAny is unused | |
| 14 ┃ -- Catch all exceptions except asynchronous exceptions. | |
| 15 ┃ catchAny :: IO a -> (SomeException -> IO a) -> IO a | |
| 16 ┃ catchAny action onE = tryAny action >>= either onE return | |
| Delete this definition or add ‘Unison.Util.Exception.catchAny’ as a root to fix this error. | |
| src/Unison/Util/Find.hs:139:1: error: candidates is unused | |
| 137 ┃ | |
| 138 ┃ candidates :: Names.Names' Name.Name -> HashQualified -> [SearchResult] | |
| 139 ┃ candidates b hq = typeCandidates <> termCandidates | |
| 140 ┃ where | |
| 141 ┃ -- filter branch by hash | |
| Delete this definition or add ‘Unison.Util.Find.candidates’ as a root to fix this error. | |
| src/Unison/Util/Find.hs:129:1: error: fuzzyFindInBranch is unused | |
| 127 ┃ -> HashQualified | |
| 128 ┃ -> [(SearchResult, P.Pretty P.ColorText)] | |
| 129 ┃ fuzzyFindInBranch b hq = | |
| 130 ┃ case HQ.toName hq of | |
| 131 ┃ (Name.toString -> n) -> | |
| Delete this definition or add ‘Unison.Util.Find.fuzzyFindInBranch’ as a root to fix this error. | |
| src/Unison/Util/Find.hs:82:1: error: fuzzyFindMatchArray is unused | |
| 80 ┃ String -> [a] -> (a -> String) | |
| 81 ┃ -> [(RE.MatchArray, (a, P.Pretty P.ColorText))] | |
| 82 ┃ fuzzyFindMatchArray query items render = | |
| 83 ┃ scoreAndHighlight $ items | |
| 84 ┃ where | |
| Delete this definition or add ‘Unison.Util.Find.fuzzyFindMatchArray’ as a root to fix this error. | |
| src/Unison/Util/Find.hs:34:1: error: fuzzyFinder is unused | |
| 32 ┃ fuzzyFinder :: forall a. | |
| 33 ┃ String -> [a] -> (a -> String) -> [(a, P.Pretty P.ColorText)] | |
| 34 ┃ fuzzyFinder query items render = | |
| 35 ┃ sortAndCleanup $ fuzzyFindMatchArray query items render | |
| 36 ┃ where | |
| Delete this definition or add ‘Unison.Util.Find.fuzzyFinder’ as a root to fix this error. | |
| src/Unison/Util/Find.hs:136:1: error: getName is unused | |
| 134 ┃ | |
| 135 ┃ getName :: SearchResult -> (SearchResult, P.Pretty P.ColorText) | |
| 136 ┃ getName sr = (sr, P.syntaxToColor $ prettyHashQualified' (SR.name sr)) | |
| 137 ┃ | |
| 138 ┃ candidates :: Names.Names' Name.Name -> HashQualified -> [SearchResult] | |
| Delete this definition or add ‘Unison.Util.Find.getName’ as a root to fix this error. | |
| src/Unison/Util/Find.hs:164:1: error: highlight is unused | |
| 162 ┃ -> [(Pos, Len)] | |
| 163 ┃ -> P.Pretty P.ColorText | |
| 164 ┃ highlight on = highlight' on id | |
| 165 ┃ | |
| 166 ┃ highlight' :: (P.Pretty P.ColorText -> P.Pretty P.ColorText) | |
| Delete this definition or add ‘Unison.Util.Find.highlight’ as a root to fix this error. | |
| src/Unison/Util/Find.hs:171:1: error: highlight' is unused | |
| 169 ┃ -> [(Pos, Len)] | |
| 170 ┃ -> P.Pretty P.ColorText | |
| 171 ┃ highlight' on off t groups = case groups of | |
| 172 ┃ [] -> (off . P.text) t | |
| 173 ┃ (0,_) : _ -> go groups | |
| Delete this definition or add ‘Unison.Util.Find.highlight'’ as a root to fix this error. | |
| src/Unison/Util/Find.hs:116:1: error: prefixFindInBranch is unused | |
| 114 ┃ prefixFindInBranch :: | |
| 115 ┃ Names0 -> HashQualified -> [(SearchResult, P.Pretty P.ColorText)] | |
| 116 ┃ prefixFindInBranch b hq = fmap getName $ | |
| 117 ┃ case HQ.toName hq of | |
| 118 ┃ -- query string includes a name component, so do a prefix find on that | |
| Delete this definition or add ‘Unison.Util.Find.prefixFindInBranch’ as a root to fix this error. | |
| src/Unison/Util/Free.hs:21:1: error: fold is unused | |
| 19 ┃ | |
| 20 ┃ fold :: Monad m => (forall x. f x -> m x) -> Free f a -> m a | |
| 21 ┃ fold f m = case m of | |
| 22 ┃ Pure a -> pure a | |
| 23 ┃ Bind x k -> f x >>= fold f . k | |
| Delete this definition or add ‘Unison.Util.Free.fold’ as a root to fix this error. | |
| src/Unison/Util/Free.hs:42:1: error: free is unused | |
| 40 ┃ | |
| 41 ┃ free :: Traversable f => f (Free f a) -> Free f a | |
| 42 ┃ free = go . sequence | |
| 43 ┃ where go (Pure fa) = Bind fa Pure | |
| 44 ┃ go (Bind fi f) = Bind fi (go . f) | |
| Delete this definition or add ‘Unison.Util.Free.free’ as a root to fix this error. | |
| src/Unison/Util/Free.hs:26:1: error: unfold is unused | |
| 24 ┃ | |
| 25 ┃ unfold :: (v -> Either a (f v)) -> v -> Free f a | |
| 26 ┃ unfold f seed = case f seed of | |
| 27 ┃ Left a -> Pure a | |
| 28 ┃ Right fv -> Bind fv (unfold f) | |
| Delete this definition or add ‘Unison.Util.Free.unfold’ as a root to fix this error. | |
| src/Unison/Util/Free.hs:31:1: error: unfold' is unused | |
| 29 ┃ | |
| 30 ┃ unfold' :: (v -> Free f (Either a v)) -> v -> Free f a | |
| 31 ┃ unfold' f seed = f seed >>= either Pure (unfold' f) | |
| 32 ┃ | |
| 33 ┃ unfoldM :: (Traversable f, Applicative m, Monad m) | |
| Delete this definition or add ‘Unison.Util.Free.unfold'’ as a root to fix this error. | |
| src/Unison/Util/Free.hs:35:1: error: unfoldM is unused | |
| 33 ┃ unfoldM :: (Traversable f, Applicative m, Monad m) | |
| 34 ┃ => (b -> m (Either a (f b))) -> b -> m (Free f a) | |
| 35 ┃ unfoldM f seed = do | |
| 36 ┃ e <- f seed | |
| 37 ┃ case e of | |
| Delete this definition or add ‘Unison.Util.Free.unfoldM’ as a root to fix this error. | |
| src/Unison/Util/List.hs:17:1: error: groupBy is unused | |
| 15 ┃ | |
| 16 ┃ groupBy :: (Foldable f, Ord k) => (v -> k) -> f v -> Map k [v] | |
| 17 ┃ groupBy f vs = reverse <$> foldl' step Map.empty vs | |
| 18 ┃ where step m v = Map.insertWith (++) (f v) [v] m | |
| 19 ┃ | |
| Delete this definition or add ‘Unison.Util.List.groupBy’ as a root to fix this error. | |
| src/Unison/Util/List.hs:30:1: error: nubOrdOn is unused | |
| 28 ┃ else a : wrangle' as (Set.insert b seen) | |
| 29 ┃ where b = f a | |
| 30 ┃ nubOrdOn = uniqueBy | |
| 31 ┃ | |
| 32 ┃ -- prefers later copies | |
| Delete this definition or add ‘Unison.Util.List.nubOrdOn’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:99:1: error: at is unused | |
| 97 ┃ | |
| 98 ┃ at :: Level -> Logger -> Logger | |
| 99 ┃ at lvl logger = logger { getLevel = lvl } | |
| 100 ┃ | |
| 101 ┃ atError, atWarn, atInfo, atDebug, atTrace :: Logger -> Logger | |
| Delete this definition or add ‘Unison.Util.Logger.at’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:35:1: error: atomic is unused | |
| 33 ┃ -- | Ensure at most one message is logged at the same time | |
| 34 ┃ atomic :: Logger -> IO Logger | |
| 35 ┃ atomic logger = do | |
| 36 ┃ lock <- newMVar () | |
| 37 ┃ pure $ | |
| Delete this definition or add ‘Unison.Util.Logger.atomic’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:85:1: error: debug is unused | |
| 83 ┃ warn l = logAt l warnLevel | |
| 84 ┃ info l = logAt l infoLevel | |
| 85 ┃ debug l = logAt l debugLevel | |
| 86 ┃ trace l = logAt l traceLevel | |
| 87 ┃ | |
| Delete this definition or add ‘Unison.Util.Logger.debug’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:92:1: error: debug' is unused | |
| 90 ┃ warn' l = logAt' l warnLevel | |
| 91 ┃ info' l = logAt' l infoLevel | |
| 92 ┃ debug' l = logAt' l debugLevel | |
| 93 ┃ trace' l = logAt' l traceLevel | |
| 94 ┃ | |
| Delete this definition or add ‘Unison.Util.Logger.debug'’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:109:1: error: decrement is unused | |
| 107 ┃ | |
| 108 ┃ decrement :: Logger -> Logger | |
| 109 ┃ decrement (Logger s p n l) = Logger s p (n-1) l | |
| Delete this definition or add ‘Unison.Util.Logger.decrement’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:82:1: error: error is unused | |
| 80 ┃ | |
| 81 ┃ error, warn, info, debug, trace :: Logger -> String -> IO () | |
| 82 ┃ error l = logAt l errorLevel | |
| 83 ┃ warn l = logAt l warnLevel | |
| 84 ┃ info l = logAt l infoLevel | |
| Delete this definition or add ‘Unison.Util.Logger.error’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:89:1: error: error' is unused | |
| 87 ┃ | |
| 88 ┃ error', warn', info', debug', trace' :: Logger -> IO String -> IO () | |
| 89 ┃ error' l = logAt' l errorLevel | |
| 90 ┃ warn' l = logAt' l warnLevel | |
| 91 ┃ info' l = logAt' l infoLevel | |
| Delete this definition or add ‘Unison.Util.Logger.error'’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:106:1: error: increment is unused | |
| 104 ┃ | |
| 105 ┃ increment :: Logger -> Logger | |
| 106 ┃ increment (Logger s p n l) = Logger s p (n+1) l | |
| 107 ┃ | |
| 108 ┃ decrement :: Logger -> Logger | |
| Delete this definition or add ‘Unison.Util.Logger.increment’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:84:1: error: info is unused | |
| 82 ┃ error l = logAt l errorLevel | |
| 83 ┃ warn l = logAt l warnLevel | |
| 84 ┃ info l = logAt l infoLevel | |
| 85 ┃ debug l = logAt l debugLevel | |
| 86 ┃ trace l = logAt l traceLevel | |
| Delete this definition or add ‘Unison.Util.Logger.info’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:91:1: error: info' is unused | |
| 89 ┃ error' l = logAt' l errorLevel | |
| 90 ┃ warn' l = logAt' l warnLevel | |
| 91 ┃ info' l = logAt' l infoLevel | |
| 92 ┃ debug' l = logAt' l debugLevel | |
| 93 ┃ trace' l = logAt' l traceLevel | |
| Delete this definition or add ‘Unison.Util.Logger.info'’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:66:1: error: logAt is unused | |
| 64 ┃ | |
| 65 ┃ logAt :: Logger -> Level -> String -> IO () | |
| 66 ┃ logAt logger lvl msg | lvl <= getLevel logger = raw logger (prefix logger msg) | |
| 67 ┃ | otherwise = pure () | |
| 68 ┃ | |
| Delete this definition or add ‘Unison.Util.Logger.logAt’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:62:1: error: logAt' is unused | |
| 60 ┃ | |
| 61 ┃ logAt' :: Logger -> Level -> IO String -> IO () | |
| 62 ┃ logAt' logger lvl msg | lvl <= getLevel logger = msg >>= \msg -> raw logger (prefix logger msg) | |
| 63 ┃ | otherwise = pure () | |
| 64 ┃ | |
| Delete this definition or add ‘Unison.Util.Logger.logAt'’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:51:1: error: logHandleAt is unused | |
| 49 ┃ | |
| 50 ┃ logHandleAt :: Logger -> Level -> Handle -> IO () | |
| 51 ┃ logHandleAt logger lvl h | |
| 52 ┃ | lvl > getLevel logger = pure () | |
| 53 ┃ | otherwise = void . forkIO $ loop where | |
| Delete this definition or add ‘Unison.Util.Logger.logHandleAt’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:79:1: error: logger is unused | |
| 77 ┃ | |
| 78 ┃ logger :: (String -> IO ()) -> Logger | |
| 79 ┃ logger log = Logger [] id 0 log | |
| 80 ┃ | |
| 81 ┃ error, warn, info, debug, trace :: Logger -> String -> IO () | |
| Delete this definition or add ‘Unison.Util.Logger.logger’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:70:1: error: scope is unused | |
| 68 ┃ | |
| 69 ┃ scope :: String -> Logger -> Logger | |
| 70 ┃ scope s (Logger s0 _ lvl raw) = Logger s' prefix' lvl raw where | |
| 71 ┃ prefix' msg = prefix ++ msg | |
| 72 ┃ prefix = "[" ++ intercalate " " s' ++ "] " | |
| Delete this definition or add ‘Unison.Util.Logger.scope’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:76:1: error: scope' is unused | |
| 74 ┃ | |
| 75 ┃ scope' :: [String] -> Logger -> Logger | |
| 76 ┃ scope' s l = foldr scope l s | |
| 77 ┃ | |
| 78 ┃ logger :: (String -> IO ()) -> Logger | |
| Delete this definition or add ‘Unison.Util.Logger.scope'’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:42:1: error: toHandle is unused | |
| 40 ┃ | |
| 41 ┃ toHandle :: Handle -> Logger | |
| 42 ┃ toHandle h = logger (hPutStrLn h) | |
| 43 ┃ | |
| 44 ┃ toStandardError :: Logger | |
| Delete this definition or add ‘Unison.Util.Logger.toHandle’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:45:1: error: toStandardError is unused | |
| 43 ┃ | |
| 44 ┃ toStandardError :: Logger | |
| 45 ┃ toStandardError = toHandle stderr | |
| 46 ┃ | |
| 47 ┃ toStandardOut :: Logger | |
| Delete this definition or add ‘Unison.Util.Logger.toStandardError’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:48:1: error: toStandardOut is unused | |
| 46 ┃ | |
| 47 ┃ toStandardOut :: Logger | |
| 48 ┃ toStandardOut = toHandle stdout | |
| 49 ┃ | |
| 50 ┃ logHandleAt :: Logger -> Level -> Handle -> IO () | |
| Delete this definition or add ‘Unison.Util.Logger.toStandardOut’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:86:1: error: trace is unused | |
| 84 ┃ info l = logAt l infoLevel | |
| 85 ┃ debug l = logAt l debugLevel | |
| 86 ┃ trace l = logAt l traceLevel | |
| 87 ┃ | |
| 88 ┃ error', warn', info', debug', trace' :: Logger -> IO String -> IO () | |
| Delete this definition or add ‘Unison.Util.Logger.trace’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:93:1: error: trace' is unused | |
| 91 ┃ info' l = logAt' l infoLevel | |
| 92 ┃ debug' l = logAt' l debugLevel | |
| 93 ┃ trace' l = logAt' l traceLevel | |
| 94 ┃ | |
| 95 ┃ errorLevel, warnLevel, infoLevel, debugLevel, traceLevel :: Level | |
| Delete this definition or add ‘Unison.Util.Logger.trace'’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:83:1: error: warn is unused | |
| 81 ┃ error, warn, info, debug, trace :: Logger -> String -> IO () | |
| 82 ┃ error l = logAt l errorLevel | |
| 83 ┃ warn l = logAt l warnLevel | |
| 84 ┃ info l = logAt l infoLevel | |
| 85 ┃ debug l = logAt l debugLevel | |
| Delete this definition or add ‘Unison.Util.Logger.warn’ as a root to fix this error. | |
| src/Unison/Util/Logger.hs:90:1: error: warn' is unused | |
| 88 ┃ error', warn', info', debug', trace' :: Logger -> IO String -> IO () | |
| 89 ┃ error' l = logAt' l errorLevel | |
| 90 ┃ warn' l = logAt' l warnLevel | |
| 91 ┃ info' l = logAt' l infoLevel | |
| 92 ┃ debug' l = logAt' l debugLevel | |
| Delete this definition or add ‘Unison.Util.Logger.warn'’ as a root to fix this error. | |
| src/Unison/Util/Menu.hs:110:1: error: _repeatMenu1 is unused | |
| 108 ┃ -> Maybe Keyword | |
| 109 ┃ -> IO (Either mc [a]) | |
| 110 ┃ _repeatMenu1 console caption render renderMeta groups metas initial = | |
| 111 ┃ groupMenu1 console caption render renderMeta groups metas initial >>= \case | |
| 112 ┃ Just x -> pure x | |
| Delete this definition or add ‘Unison.Util.Menu._repeatMenu1’ as a root to fix this error. | |
| src/Unison/Util/Menu.hs:124:1: error: groupMenu1 is unused | |
| 122 ┃ -> Maybe Keyword | |
| 123 ┃ -> IO (Maybe (Either mc [a])) | |
| 124 ┃ groupMenu1 console caption render renderMeta groups metas initial = do | |
| 125 ┃ when ((not . textEmpty) caption) $ do | |
| 126 ┃ print . toANSI $ caption | |
| Delete this definition or add ‘Unison.Util.Menu.groupMenu1’ as a root to fix this error. | |
| src/Unison/Util/Menu.hs:220:1: error: groupMenuN is unused | |
| 218 ┃ -> [[Keyword]] | |
| 219 ┃ -> IO (Either mc [[a]]) | |
| 220 ┃ groupMenuN console caption render renderMeta groups metas initials = | |
| 221 ┃ groupMenuN' console caption render renderMeta groups metas (Set.fromList initials) | |
| 222 ┃ | |
| Delete this definition or add ‘Unison.Util.Menu.groupMenuN’ as a root to fix this error. | |
| src/Unison/Util/Menu.hs:232:1: error: groupMenuN' is unused | |
| 230 ┃ -> Set [Keyword] | |
| 231 ┃ -> IO (Either mc [[a]]) | |
| 232 ┃ groupMenuN' console caption render renderMeta groups metas initials = do | |
| 233 ┃ when ((not . textEmpty) caption) $ do | |
| 234 ┃ print . toANSI $ caption | |
| Delete this definition or add ‘Unison.Util.Menu.groupMenuN'’ as a root to fix this error. | |
| src/Unison/Util/Menu.hs:92:1: error: menu1 is unused | |
| 90 ┃ -> Maybe Keyword | |
| 91 ┃ -> IO (Maybe (Either mc a)) | |
| 92 ┃ menu1 console caption render renderMeta groups metas initial = do | |
| 93 ┃ let groups' = [ ([k], [a]) | (k, a) <- groups ] | |
| 94 ┃ metas' = [ ([k], mc) | (k, mc) <- metas ] | |
| Delete this definition or add ‘Unison.Util.Menu.menu1’ as a root to fix this error. | |
| src/Unison/Util/Menu.hs:209:1: error: menuN is unused | |
| 207 ┃ -> [Keyword] | |
| 208 ┃ -> IO (Either mc [[a]]) | |
| 209 ┃ menuN _console _caption _render _renderMeta _groups _metas _initials = pure (Right []) | |
| 210 ┃ | |
| 211 ┃ groupMenuN :: forall a mc. Ord a | |
| Delete this definition or add ‘Unison.Util.Menu.menuN’ as a root to fix this error. | |
| src/Unison/Util/Menu.hs:29:1: error: renderChoices is unused | |
| 27 ┃ -> (Keyword -> Bool) | |
| 28 ┃ -> Stylized | |
| 29 ┃ renderChoices render renderMeta groups metas isSelected = | |
| 30 ┃ showGroups <> showMetas | |
| 31 ┃ where | |
| Delete this definition or add ‘Unison.Util.Menu.renderChoices’ as a root to fix this error. | |
| src/Unison/Util/PinBoard.hs:94:1: error: debugDump is unused | |
| 92 ┃ | |
| 93 ┃ debugDump :: MonadIO m => (a -> Text) -> PinBoard a -> m () | |
| 94 ┃ debugDump f (PinBoard boardVar) = liftIO do | |
| 95 ┃ board <- readMVar boardVar | |
| 96 ┃ contents <- (traverse . traverse) bucketToList (IntMap.toList board) | |
| Delete this definition or add ‘Unison.Util.PinBoard.debugDump’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:797:1: error: boxForkLeft is unused | |
| 795 ┃ boxForkLeft, boxLeft, boxRight :: | |
| 796 ┃ forall s . (LL.ListLike s Char, IsString s) => [Pretty s] -> [Pretty s] | |
| 797 ┃ boxForkLeft = boxLeft' lBoxStyle1 | |
| 798 ┃ boxLeft = boxLeft' lBoxStyle2 | |
| 799 ┃ boxRight = boxRight' rBoxStyle2 | |
| Delete this definition or add ‘Unison.Util.Pretty.boxForkLeft’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:828:1: error: boxLeftM is unused | |
| 826 ┃ boxLeftM, boxRightM :: forall m s . (Monad m, LL.ListLike s Char, IsString s) | |
| 827 ┃ => [m (Pretty s)] -> [m (Pretty s)] | |
| 828 ┃ boxLeftM = boxLeftM' lBoxStyle2 | |
| 829 ┃ boxRightM = boxRightM' rBoxStyle2 | |
| 830 ┃ | |
| Delete this definition or add ‘Unison.Util.Pretty.boxLeftM’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:829:1: error: boxRightM is unused | |
| 827 ┃ => [m (Pretty s)] -> [m (Pretty s)] | |
| 828 ┃ boxLeftM = boxLeftM' lBoxStyle2 | |
| 829 ┃ boxRightM = boxRightM' rBoxStyle2 | |
| 830 ┃ | |
| 831 ┃ boxLeftM' :: forall m s . (Monad m, LL.ListLike s Char, IsString s) | |
| Delete this definition or add ‘Unison.Util.Pretty.boxRightM’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:525:1: error: column2Header is unused | |
| 523 ┃ column2Header | |
| 524 ┃ :: Pretty ColorText -> Pretty ColorText -> [(Pretty ColorText, Pretty ColorText)] -> Pretty ColorText | |
| 525 ┃ column2Header left right = column2sep " " . ((fmap CT.hiBlack left, fmap CT.hiBlack right):) | |
| 526 ┃ | |
| 527 ┃ column2sep | |
| Delete this definition or add ‘Unison.Util.Pretty.column2Header’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:553:1: error: column3M is unused | |
| 551 ┃ => [m (Pretty s, Pretty s, Pretty s)] | |
| 552 ┃ -> m (Pretty s) | |
| 553 ┃ column3M = fmap column3 . sequence | |
| 554 ┃ | |
| 555 ┃ column3UnzippedM | |
| Delete this definition or add ‘Unison.Util.Pretty.column3M’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:562:1: error: column3UnzippedM is unused | |
| 560 ┃ -> [m (Pretty s)] | |
| 561 ┃ -> m (Pretty s) | |
| 562 ┃ column3UnzippedM bottomPadding left mid right = let | |
| 563 ┃ rowCount = maximum (fmap length [left, mid, right]) | |
| 564 ┃ pad :: [m (Pretty s)] -> [m (Pretty s)] | |
| Delete this definition or add ‘Unison.Util.Pretty.column3UnzippedM’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:450:1: error: commented is unused | |
| 448 ┃ commented | |
| 449 ┃ :: (Foldable f, LL.ListLike s Char, IsString s) => f (Pretty s) -> Pretty s | |
| 450 ┃ commented = prefixed "-- " "-- " | |
| 451 ┃ | |
| 452 ┃ numbered | |
| Delete this definition or add ‘Unison.Util.Pretty.commented’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:514:1: error: excerptColumn2 is unused | |
| 512 ┃ -> [(Pretty s, Pretty s)] | |
| 513 ┃ -> Pretty s | |
| 514 ┃ excerptColumn2 max cols = case max of | |
| 515 ┃ Just max | len > max -> lines [column2 cols, "... " <> shown (len - max)] | |
| 516 ┃ _ -> column2 cols | |
| Delete this definition or add ‘Unison.Util.Pretty.excerptColumn2’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:503:1: error: excerptColumn2Headed is unused | |
| 501 ┃ -> [(Pretty s, Pretty s)] | |
| 502 ┃ -> Pretty s | |
| 503 ┃ excerptColumn2Headed max hd cols = case max of | |
| 504 ┃ Just max | len > max -> | |
| 505 ┃ lines [column2 (hd : take max cols), "... " <> shown (len - max) <> " more"] | |
| Delete this definition or add ‘Unison.Util.Pretty.excerptColumn2Headed’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:397:1: error: excerptSep is unused | |
| 395 ┃ -- if list is too long, adds `... 22 more` to the end | |
| 396 ┃ excerptSep :: IsString s => Maybe Int -> Pretty s -> [Pretty s] -> Pretty s | |
| 397 ┃ excerptSep maxCount = | |
| 398 ┃ excerptSep' maxCount (\i -> group ("... " <> shown i <> " more")) | |
| 399 ┃ | |
| Delete this definition or add ‘Unison.Util.Pretty.excerptSep’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:664:1: error: hangUngrouped is unused | |
| 662 ┃ hangUngrouped | |
| 663 ┃ :: (LL.ListLike s Char, IsString s) => Pretty s -> Pretty s -> Pretty s | |
| 664 ┃ hangUngrouped from = hangUngrouped' from " " | |
| 665 ┃ | |
| 666 ┃ hang :: (LL.ListLike s Char, IsString s) => Pretty s -> Pretty s -> Pretty s | |
| Delete this definition or add ‘Unison.Util.Pretty.hangUngrouped’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:658:1: error: hangUngrouped' is unused | |
| 656 ┃ -> Pretty s | |
| 657 ┃ -> Pretty s | |
| 658 ┃ hangUngrouped' from by p = if isMultiLine p | |
| 659 ┃ then from <> "\n" <> indent by p | |
| 660 ┃ else (from <> " " <> p) `orElse` (from <> "\n" <> indent by p) | |
| Delete this definition or add ‘Unison.Util.Pretty.hangUngrouped'’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:771:1: error: hiCyan is unused | |
| 769 ┃ hiBlue = map CT.hiBlue | |
| 770 ┃ hiPurple = map CT.hiPurple | |
| 771 ┃ hiCyan = map CT.hiCyan | |
| 772 ┃ hiWhite = map CT.hiWhite | |
| 773 ┃ bold = map CT.bold | |
| Delete this definition or add ‘Unison.Util.Pretty.hiCyan’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:770:1: error: hiPurple is unused | |
| 768 ┃ hiYellow = map CT.hiYellow | |
| 769 ┃ hiBlue = map CT.hiBlue | |
| 770 ┃ hiPurple = map CT.hiPurple | |
| 771 ┃ hiCyan = map CT.hiCyan | |
| 772 ┃ hiWhite = map CT.hiWhite | |
| Delete this definition or add ‘Unison.Util.Pretty.hiPurple’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:772:1: error: hiWhite is unused | |
| 770 ┃ hiPurple = map CT.hiPurple | |
| 771 ┃ hiCyan = map CT.hiCyan | |
| 772 ┃ hiWhite = map CT.hiWhite | |
| 773 ┃ bold = map CT.bold | |
| 774 ┃ underline = map CT.underline | |
| Delete this definition or add ‘Unison.Util.Pretty.hiWhite’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:813:1: error: lBoxStyle1 is unused | |
| 811 ┃ ) | |
| 812 ┃ lBoxStyle1, lBoxStyle2, rBoxStyle2 :: IsString s => BoxStyle s | |
| 813 ┃ lBoxStyle1 = (("â ", "â ") -- first | |
| 814 ┃ ,("â ", "â ") -- middle | |
| 815 ┃ ,("â ", " ") -- last | |
| Delete this definition or add ‘Unison.Util.Pretty.lBoxStyle1’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:490:1: error: leftPad is unused | |
| 488 ┃ | |
| 489 ┃ leftPad, rightPad :: IsString s => Int -> Pretty s -> Pretty s | |
| 490 ┃ leftPad n p = | |
| 491 ┃ let rem = n - preferredWidth p | |
| 492 ┃ in if rem > 0 then fromString (replicate rem ' ') <> p else p | |
| Delete this definition or add ‘Unison.Util.Pretty.leftPad’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:670:1: error: nest is unused | |
| 668 ┃ | |
| 669 ┃ nest :: (LL.ListLike s Char, IsString s) => Pretty s -> Pretty s -> Pretty s | |
| 670 ┃ nest = hang' "" | |
| 671 ┃ | |
| 672 ┃ indent :: (LL.ListLike s Char, IsString s) => Pretty s -> Pretty s -> Pretty s | |
| Delete this definition or add ‘Unison.Util.Pretty.nest’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:166:1: error: orElses is unused | |
| 164 ┃ | |
| 165 ┃ orElses :: [Pretty s] -> Pretty s | |
| 166 ┃ orElses [] = mempty | |
| 167 ┃ orElses ps = foldr1 orElse ps | |
| 168 ┃ | |
| Delete this definition or add ‘Unison.Util.Pretty.orElses’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:387:1: error: sepSpaced is unused | |
| 385 ┃ | |
| 386 ┃ sepSpaced :: (Foldable f, IsString s) => Pretty s -> f (Pretty s) -> Pretty s | |
| 387 ┃ sepSpaced between = sep (between <> softbreak) | |
| 388 ┃ | |
| 389 ┃ sep :: (Foldable f, IsString s) => Pretty s -> f (Pretty s) -> Pretty s | |
| Delete this definition or add ‘Unison.Util.Pretty.sepSpaced’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:254:1: error: toHTML is unused | |
| 252 ┃ | |
| 253 ┃ toHTML :: String -> Width -> Pretty CT.ColorText -> String | |
| 254 ┃ toHTML cssPrefix avail p = CT.toHTML cssPrefix (render avail p) | |
| 255 ┃ | |
| 256 ┃ toPlainUnbroken :: Pretty ColorText -> String | |
| Delete this definition or add ‘Unison.Util.Pretty.toHTML’ as a root to fix this error. | |
| src/Unison/Util/Pretty.hs:764:1: error: white is unused | |
| 762 ┃ purple = map CT.purple | |
| 763 ┃ cyan = map CT.cyan | |
| 764 ┃ white = map CT.white | |
| 765 ┃ hiBlack = map CT.hiBlack | |
| 766 ┃ hiRed = map CT.hiRed | |
| Delete this definition or add ‘Unison.Util.Pretty.white’ as a root to fix this error. | |
| src/Unison/Util/Range.hs:16:1: error: isMultiLine is unused | |
| 14 ┃ | |
| 15 ┃ isMultiLine :: Range -> Bool | |
| 16 ┃ isMultiLine (Range (Pos startLine _) (Pos endLine _)) = startLine < endLine | |
| 17 ┃ | |
| 18 ┃ data Range = Range { start :: Pos, end :: Pos } deriving (Eq, Ord, Show) | |
| Delete this definition or add ‘Unison.Util.Range.isMultiLine’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:330:1: error: <$| is unused | |
| 328 ┃ -- | |
| 329 ┃ (<$|) :: (Ord a, Ord b) => Set a -> Set b -> Relation a b -> Set a | |
| 330 ┃ (as <$| bs) r = as `S.intersection` generarAS bs | |
| 331 ┃ where generarAS = compactSet . S.map (`lookupRan'` r) | |
| 332 ┃ | |
| Delete this definition or add ‘Unison.Util.Relation.<$|’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:478:1: error: bimap is unused | |
| 476 ┃ bimap :: (Ord a, Ord b, Ord c, Ord d) | |
| 477 ┃ => (a -> c) -> (b -> d) -> Relation a b -> Relation c d | |
| 478 ┃ bimap f g = fromList . fmap (\(a,b) -> (f a, g b)) . toList | |
| 479 ┃ | |
| 480 ┃ instance (Ord a, Ord b) => Monoid (Relation a b) where | |
| Delete this definition or add ‘Unison.Util.Relation.bimap’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:496:1: error: collectRan is unused | |
| 494 ┃ collectRan :: Ord a => Ord c => | |
| 495 ┃ (b -> Maybe c) -> Relation a b -> Relation a c | |
| 496 ┃ collectRan f r = fromList [ (a, c) | (a, f -> Just c) <- toList r ] | |
| Delete this definition or add ‘Unison.Util.Relation.collectRan’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:285:1: error: compactSet is unused | |
| 283 ┃ -- It is similar to 'concat'. | |
| 284 ┃ compactSet :: Ord a => Set (Maybe (Set a)) -> Set a | |
| 285 ┃ compactSet = S.fold (S.union . fromMaybe S.empty) S.empty | |
| 286 ┃ | |
| 287 ┃ | |
| Delete this definition or add ‘Unison.Util.Relation.compactSet’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:429:1: error: deleteDomWhere is unused | |
| 427 ┃ | |
| 428 ┃ deleteDomWhere :: (Ord a, Ord b) => (a -> Bool) -> b -> Relation a b -> Relation a b | |
| 429 ┃ deleteDomWhere f b r = | |
| 430 ┃ foldl' (\r a -> if f a then delete a b r else r) r (lookupRan b r) | |
| 431 ┃ | |
| Delete this definition or add ‘Unison.Util.Relation.deleteDomWhere’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:419:1: error: deleteRan is unused | |
| 417 ┃ | |
| 418 ┃ deleteRan :: (Ord a, Ord b) => b -> Relation a b -> Relation a b | |
| 419 ┃ deleteRan b r = foldl' (\r a -> delete a b r) r $ lookupRan b r | |
| 420 ┃ | |
| 421 ┃ deleteDom :: (Ord a, Ord b) => a -> Relation a b -> Relation a b | |
| Delete this definition or add ‘Unison.Util.Relation.deleteRan’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:425:1: error: deleteRanWhere is unused | |
| 423 ┃ | |
| 424 ┃ deleteRanWhere :: (Ord a, Ord b) => (b -> Bool) -> a -> Relation a b -> Relation a b | |
| 425 ┃ deleteRanWhere f a r = | |
| 426 ┃ foldl' (\r b -> if f b then delete a b r else r) r (lookupDom a r) | |
| 427 ┃ | |
| Delete this definition or add ‘Unison.Util.Relation.deleteRanWhere’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:157:1: error: foldlStrict is unused | |
| 155 ┃ -- | |
| 156 ┃ foldlStrict :: (a -> b -> a) -> a -> [b] -> a | |
| 157 ┃ foldlStrict f z xs = case xs of | |
| 158 ┃ [] -> z | |
| 159 ┃ (x : xx) -> let z' = f z x in seq z' (foldlStrict f z' xx) | |
| Delete this definition or add ‘Unison.Util.Relation.foldlStrict’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:467:1: error: fromManyRan is unused | |
| 465 ┃ fromManyRan | |
| 466 ┃ :: (Foldable f, Ord a, Ord b) => a -> f b -> Relation a b | |
| 467 ┃ fromManyRan a bs = insertManyRan a bs mempty | |
| 468 ┃ | |
| 469 ┃ fromManyDom | |
| Delete this definition or add ‘Unison.Util.Relation.fromManyRan’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:463:1: error: fromSet is unused | |
| 461 ┃ | |
| 462 ┃ fromSet :: (Ord a, Ord b) => Set (a,b) -> Relation a b | |
| 463 ┃ fromSet = fromList . S.toList | |
| 464 ┃ | |
| 465 ┃ fromManyRan | |
| Delete this definition or add ‘Unison.Util.Relation.fromSet’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:129:1: error: joinDom is unused | |
| 127 ┃ | |
| 128 ┃ joinDom :: (Ord a, Ord b, Ord c) => Relation a b -> Relation a c -> Relation a (b,c) | |
| 129 ┃ joinDom b c = swap $ joinRan (swap b) (swap c) | |
| 130 ┃ | |
| 131 ┃ -- joinRan [(1, 'x'), (2, 'x'), (3, 'z')] [(true, 'x'), (true, 'y'), (false, 'z')] | |
| Delete this definition or add ‘Unison.Util.Relation.joinDom’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:134:1: error: joinRan is unused | |
| 132 ┃ -- == [((1,true), 'x'), ((2,true), 'x'), ((3,false), 'z')] | |
| 133 ┃ joinRan :: (Ord a, Ord b, Ord c) => Relation a c -> Relation b c -> Relation (a,b) c | |
| 134 ┃ joinRan a b = fromList | |
| 135 ┃ [ ((a,b), c) | |
| 136 ┃ | c <- S.toList $ ran a `S.intersection` ran b | |
| Delete this definition or add ‘Unison.Util.Relation.joinRan’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:264:1: error: manyRan is unused | |
| 262 ┃ | |
| 263 ┃ manyRan :: Ord b => b -> Relation a b -> Bool | |
| 264 ┃ manyRan b = (>1) . S.size . lookupRan b | |
| 265 ┃ | |
| 266 ┃ -- | Returns the domain in the relation, as a Set, in its entirety. | |
| Delete this definition or add ‘Unison.Util.Relation.manyRan’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:111:1: error: outerJoinRanMultimaps is unused | |
| 109 ┃ -> Relation b c | |
| 110 ┃ -> Map c (Set a, Set b) | |
| 111 ┃ outerJoinRanMultimaps a b = outerJoinDomMultimaps (swap a) (swap b) | |
| 112 ┃ | |
| 113 ┃ innerJoinDomMultimaps :: (Ord a, Ord b, Ord c) | |
| Delete this definition or add ‘Unison.Util.Relation.outerJoinRanMultimaps’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:407:1: error: replaceRan is unused | |
| 405 ┃ | |
| 406 ┃ replaceRan :: (Ord a, Ord b) => b -> b -> Relation a b -> Relation a b | |
| 407 ┃ replaceRan b b' r = | |
| 408 ┃ foldl' (\r a -> insert a b' $ delete a b r) r (lookupRan b r) | |
| 409 ┃ | |
| Delete this definition or add ‘Unison.Util.Relation.replaceRan’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:372:1: error: subtractRan is unused | |
| 370 ┃ | |
| 371 ┃ subtractRan :: (Ord a, Ord b) => Set b -> Relation a b -> Relation a b | |
| 372 ┃ subtractRan = flip (||>) | |
| 373 ┃ | |
| 374 ┃ -- Restrict the domain to not include these `a` | |
| Delete this definition or add ‘Unison.Util.Relation.subtractRan’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:77:1: error: toSet is unused | |
| 75 ┃ -- | Builds a Set from a Relation | |
| 76 ┃ toSet :: (Ord a, Ord b) => Relation a b -> S.Set (a, b) | |
| 77 ┃ toSet = S.fromList . toList | |
| 78 ┃ | |
| 79 ┃ -- | | |
| Delete this definition or add ‘Unison.Util.Relation.toSet’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:492:1: error: toUnzippedMultimap is unused | |
| 490 ┃ toUnzippedMultimap :: | |
| 491 ┃ Ord a => Ord b => Ord c => Relation a (b,c) -> Map a (Set b, Set c) | |
| 492 ┃ toUnzippedMultimap r = (\s -> (S.map fst s, S.map snd s)) <$> toMultimap r | |
| 493 ┃ | |
| 494 ┃ collectRan :: Ord a => Ord c => | |
| Delete this definition or add ‘Unison.Util.Relation.toUnzippedMultimap’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:164:1: error: unions is unused | |
| 162 ┃ -- | Union a list of relations using the 'empty' relation. | |
| 163 ┃ unions :: (Ord a, Ord b) => [Relation a b] -> Relation a b | |
| 164 ┃ unions = foldlStrict union empty | |
| 165 ┃ | |
| 166 ┃ -- | Insert a relation @ x @ and @ y @ in the relation @ r @ | |
| Delete this definition or add ‘Unison.Util.Relation.unions’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:411:1: error: updateDom is unused | |
| 409 ┃ | |
| 410 ┃ updateDom :: (Ord a, Ord b) => (a -> a) -> b -> Relation a b -> Relation a b | |
| 411 ┃ updateDom f b r = | |
| 412 ┃ foldl' (\r a -> insert (f a) b $ delete a b r) r (lookupRan b r) | |
| 413 ┃ | |
| Delete this definition or add ‘Unison.Util.Relation.updateDom’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:415:1: error: updateRan is unused | |
| 413 ┃ | |
| 414 ┃ updateRan :: (Ord a, Ord b) => (b -> b) -> a -> Relation a b -> Relation a b | |
| 415 ┃ updateRan f a r = | |
| 416 ┃ foldl' (\r b -> insert a (f b) $ delete a b r) r (lookupDom a r) | |
| 417 ┃ | |
| Delete this definition or add ‘Unison.Util.Relation.updateRan’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:341:1: error: |$> is unused | |
| 339 ┃ -- @( Case a |> r b )@ | |
| 340 ┃ (|$>) :: (Ord a, Ord b) => Set a -> Set b -> Relation a b -> Set b | |
| 341 ┃ (as |$> bs) r = bs `S.intersection` generarBS as | |
| 342 ┃ where generarBS = compactSet . S.map (`lookupDom'` r) | |
| 343 ┃ | |
| Delete this definition or add ‘Unison.Util.Relation.|$>’ as a root to fix this error. | |
| src/Unison/Util/Relation.hs:369:1: error: ||> is unused | |
| 367 ┃ -- Restrict the range to not include these `b`s | |
| 368 ┃ (||>) :: (Ord a, Ord b) => Relation a b -> Set b -> Relation a b | |
| 369 ┃ r ||> t = fromList [ (a,b) | (a,b) <- toList r, not (b `S.member` t)] | |
| 370 ┃ | |
| 371 ┃ subtractRan :: (Ord a, Ord b) => Set b -> Relation a b -> Relation a b | |
| Delete this definition or add ‘Unison.Util.Relation.||>’ as a root to fix this error. | |
| src/Unison/Util/Relation3.hs:25:1: error: d1s is unused | |
| 23 ┃ | |
| 24 ┃ d1s :: Relation3 a b c -> Set a | |
| 25 ┃ d1s = Map.keysSet . d1 | |
| 26 ┃ | |
| 27 ┃ d2s :: Relation3 a b c -> Set b | |
| Delete this definition or add ‘Unison.Util.Relation3.d1s’ as a root to fix this error. | |
| src/Unison/Util/Relation3.hs:28:1: error: d2s is unused | |
| 26 ┃ | |
| 27 ┃ d2s :: Relation3 a b c -> Set b | |
| 28 ┃ d2s = Map.keysSet . d2 | |
| 29 ┃ | |
| 30 ┃ d3s :: Relation3 a b c -> Set c | |
| Delete this definition or add ‘Unison.Util.Relation3.d2s’ as a root to fix this error. | |
| src/Unison/Util/Relation3.hs:31:1: error: d3s is unused | |
| 29 ┃ | |
| 30 ┃ d3s :: Relation3 a b c -> Set c | |
| 31 ┃ d3s = Map.keysSet . d3 | |
| 32 ┃ | |
| 33 ┃ filter :: (Ord a, Ord b, Ord c) | |
| Delete this definition or add ‘Unison.Util.Relation3.d3s’ as a root to fix this error. | |
| src/Unison/Util/Relation3.hs:35:1: error: filter is unused | |
| 33 ┃ filter :: (Ord a, Ord b, Ord c) | |
| 34 ┃ => ((a,b,c) -> Bool) -> Relation3 a b c -> Relation3 a b c | |
| 35 ┃ filter f = fromList . Prelude.filter f . toList | |
| 36 ┃ | |
| 37 ┃ member :: (Ord a, Ord b, Ord c) => a -> b -> c -> Relation3 a b c -> Bool | |
| Delete this definition or add ‘Unison.Util.Relation3.filter’ as a root to fix this error. | |
| src/Unison/Util/Relation3.hs:64:1: error: fromNestedDom is unused | |
| 62 ┃ | |
| 63 ┃ fromNestedDom :: (Ord a, Ord b, Ord c) => Relation (a,b) c -> Relation3 a b c | |
| 64 ┃ fromNestedDom = fromList . fmap (\((a,b),c) -> (a,b,c)) . R.toList | |
| 65 ┃ fromNestedRan :: (Ord a, Ord b, Ord c) => Relation a (b,c) -> Relation3 a b c | |
| 66 ┃ fromNestedRan = fromList . fmap (\(a,(b,c)) -> (a,b,c)) . R.toList | |
| Delete this definition or add ‘Unison.Util.Relation3.fromNestedDom’ as a root to fix this error. | |
| src/Unison/Util/Relation3.hs:66:1: error: fromNestedRan is unused | |
| 64 ┃ fromNestedDom = fromList . fmap (\((a,b),c) -> (a,b,c)) . R.toList | |
| 65 ┃ fromNestedRan :: (Ord a, Ord b, Ord c) => Relation a (b,c) -> Relation3 a b c | |
| 66 ┃ fromNestedRan = fromList . fmap (\(a,(b,c)) -> (a,b,c)) . R.toList | |
| 67 ┃ | |
| 68 ┃ fromList :: (Ord a, Ord b, Ord c) => [(a,b,c)] -> Relation3 a b c | |
| Delete this definition or add ‘Unison.Util.Relation3.fromNestedRan’ as a root to fix this error. | |
| src/Unison/Util/Relation3.hs:47:1: error: lookupD3 is unused | |
| 45 ┃ | |
| 46 ┃ lookupD3 :: (Ord a, Ord b, Ord c) => c -> Relation3 a b c -> Relation a b | |
| 47 ┃ lookupD3 c = fromMaybe mempty . Map.lookup c . d3 | |
| 48 ┃ | |
| 49 ┃ size :: (Ord a, Ord b, Ord c) => Relation3 a b c -> Int | |
| Delete this definition or add ‘Unison.Util.Relation3.lookupD3’ as a root to fix this error. | |
| src/Unison/Util/Relation3.hs:61:1: error: nestD12 is unused | |
| 59 ┃ | |
| 60 ┃ nestD12 :: (Ord a, Ord b, Ord c) => Relation3 a b c -> Relation (a,b) c | |
| 61 ┃ nestD12 r = R.fromList [ ((a,b),c) | (a,b,c) <- toList r ] | |
| 62 ┃ | |
| 63 ┃ fromNestedDom :: (Ord a, Ord b, Ord c) => Relation (a,b) c -> Relation3 a b c | |
| Delete this definition or add ‘Unison.Util.Relation3.nestD12’ as a root to fix this error. | |
| src/Unison/Util/Relation3.hs:50:1: error: size is unused | |
| 48 ┃ | |
| 49 ┃ size :: (Ord a, Ord b, Ord c) => Relation3 a b c -> Int | |
| 50 ┃ size = getSum . foldMap (Sum . R.size) . d1 | |
| 51 ┃ | |
| 52 ┃ toList :: Relation3 a b c -> [(a,b,c)] | |
| Delete this definition or add ‘Unison.Util.Relation3.size’ as a root to fix this error. | |
| src/Unison/Util/Relation4.hs:67:1: error: d12 is unused | |
| 65 ┃ | |
| 66 ┃ d12 :: (Ord a, Ord b) => Relation4 a b c d -> Relation a b | |
| 67 ┃ d12 = R.fromMultimap . fmap (Map.keysSet . R3.d1) . d1 | |
| 68 ┃ | |
| 69 ┃ d34 :: (Ord c, Ord d) => Relation4 a b c d -> Relation c d | |
| Delete this definition or add ‘Unison.Util.Relation4.d12’ as a root to fix this error. | |
| src/Unison/Util/Relation4.hs:74:1: error: d12s is unused | |
| 72 ┃ -- todo: make me faster | |
| 73 ┃ d12s :: (Ord a, Ord b) => Relation4 a b c d -> [(a,b)] | |
| 74 ┃ d12s = nubOrd . fmap (\(a, (b, _)) -> (a,b)) . toNestedList | |
| 75 ┃ --e.g. Map.toList (d1 r) >>= \(a, r3) -> (a,) <$> Map.keys (R3.d1 r3) | |
| 76 ┃ | |
| Delete this definition or add ‘Unison.Util.Relation4.d12s’ as a root to fix this error. | |
| src/Unison/Util/Relation4.hs:64:1: error: d1set is unused | |
| 62 ┃ | |
| 63 ┃ d1set :: Ord a => Relation4 a b c d -> Set a | |
| 64 ┃ d1set = Map.keysSet . d1 | |
| 65 ┃ | |
| 66 ┃ d12 :: (Ord a, Ord b) => Relation4 a b c d -> Relation a b | |
| Delete this definition or add ‘Unison.Util.Relation4.d1set’ as a root to fix this error. | |
| src/Unison/Util/Relation4.hs:89:1: error: delete is unused | |
| 87 ┃ ins x y z = Just . R3.insert x y z . fromMaybe mempty | |
| 88 ┃ | |
| 89 ┃ delete a b c d Relation4{..} = | |
| 90 ┃ Relation4 | |
| 91 ┃ (Map.alter (del b c d) a d1) | |
| Delete this definition or add ‘Unison.Util.Relation4.delete’ as a root to fix this error. | |
| src/Unison/Util/Relation4.hs:52:1: error: selectD3 is unused | |
| 50 ┃ selectD3 :: (Ord a, Ord b, Ord c, Ord d) | |
| 51 ┃ => c -> Relation4 a b c d -> Relation4 a b c d | |
| 52 ┃ selectD3 c r = | |
| 53 ┃ fromList [ (a,b,c,d) | (a,b,d) <- maybe [] R3.toList $ Map.lookup c (d3 r) ] | |
| 54 ┃ | |
| Delete this definition or add ‘Unison.Util.Relation4.selectD3’ as a root to fix this error. | |
| src/Unison/Util/Relation4.hs:30:1: error: size is unused | |
| 28 ┃ | |
| 29 ┃ size :: (Ord a, Ord b, Ord c, Ord d) => Relation4 a b c d -> Int | |
| 30 ┃ size = getSum . foldMap (Sum . R3.size) . d1 | |
| 31 ┃ | |
| 32 ┃ toNestedList :: Relation4 a b c d -> [(a,(b,(c,d)))] | |
| Delete this definition or add ‘Unison.Util.Relation4.size’ as a root to fix this error. | |
| src/Unison/Util/Star3.hs:60:1: error: d12s is unused | |
| 58 ┃ => Star3 fact d1 d2 d3 | |
| 59 ┃ -> [(fact, d1, d2)] | |
| 60 ┃ d12s s = [ (f, x, y) | f <- Set.toList (fact s) | |
| 61 ┃ , x <- Set.toList (R.lookupDom f (d1 s)) | |
| 62 ┃ , y <- Set.toList (R.lookupDom f (d2 s)) ] | |
| Delete this definition or add ‘Unison.Util.Star3.d12s’ as a root to fix this error. | |
| src/Unison/Util/Star3.hs:67:1: error: d13s is unused | |
| 65 ┃ => Star3 fact d1 d2 d3 | |
| 66 ┃ -> [(fact, d1, d3)] | |
| 67 ┃ d13s s = [ (f, x, y) | f <- Set.toList (fact s) | |
| 68 ┃ , x <- Set.toList (R.lookupDom f (d1 s)) | |
| 69 ┃ , y <- Set.toList (R.lookupDom f (d3 s)) ] | |
| Delete this definition or add ‘Unison.Util.Star3.d13s’ as a root to fix this error. | |
| src/Unison/Util/Star3.hs:46:1: error: d23s is unused | |
| 44 ┃ => Star3 fact d1 d2 d3 | |
| 45 ┃ -> [(fact, d2, d3)] | |
| 46 ┃ d23s s = [ (f, x, y) | f <- Set.toList (fact s) | |
| 47 ┃ , x <- Set.toList (R.lookupDom f (d2 s)) | |
| 48 ┃ , y <- Set.toList (R.lookupDom f (d3 s)) ] | |
| Delete this definition or add ‘Unison.Util.Star3.d23s’ as a root to fix this error. | |
| src/Unison/Util/Star3.hs:53:1: error: d23s' is unused | |
| 51 ┃ => Star3 fact d1 d2 d3 | |
| 52 ┃ -> [(d2, d3)] | |
| 53 ┃ d23s' s = [ (x, y) | f <- Set.toList (fact s) | |
| 54 ┃ , x <- Set.toList (R.lookupDom f (d2 s)) | |
| 55 ┃ , y <- Set.toList (R.lookupDom f (d3 s)) ] | |
| Delete this definition or add ‘Unison.Util.Star3.d23s'’ as a root to fix this error. | |
| src/Unison/Util/Star3.hs:82:1: error: fromList is unused | |
| 80 ┃ fromList :: (Ord fact, Ord d1, Ord d2, Ord d3) | |
| 81 ┃ => [(fact, d1, d2, d3)] -> Star3 fact d1 d2 d3 | |
| 82 ┃ fromList = foldl' (flip insert) mempty | |
| 83 ┃ | |
| 84 ┃ selectFact | |
| Delete this definition or add ‘Unison.Util.Star3.fromList’ as a root to fix this error. | |
| src/Unison/Util/Star3.hs:148:1: error: insert is unused | |
| 146 ┃ -> Star3 fact d1 d2 d3 | |
| 147 ┃ -> Star3 fact d1 d2 d3 | |
| 148 ┃ insert (f, d1i, d2i, d3i) s = Star3 fact' d1' d2' d3' where | |
| 149 ┃ fact' = Set.insert f (fact s) | |
| 150 ┃ d1' = R.insert f d1i (d1 s) | |
| Delete this definition or add ‘Unison.Util.Star3.insert’ as a root to fix this error. | |
| src/Unison/Util/Star3.hs:72:1: error: mapD1 is unused | |
| 70 ┃ | |
| 71 ┃ mapD1 :: (Ord fact, Ord d1, Ord d1a) => (d1 -> d1a) -> Star3 fact d1 d2 d3 -> Star3 fact d1a d2 d3 | |
| 72 ┃ mapD1 f s = s { d1 = R.mapRan f (d1 s) } | |
| 73 ┃ | |
| 74 ┃ mapD2 :: (Ord fact, Ord d2, Ord d2a) => (d2 -> d2a) -> Star3 fact d1 d2 d3 -> Star3 fact d1 d2a d3 | |
| Delete this definition or add ‘Unison.Util.Star3.mapD1’ as a root to fix this error. | |
| src/Unison/Util/Star3.hs:75:1: error: mapD2 is unused | |
| 73 ┃ | |
| 74 ┃ mapD2 :: (Ord fact, Ord d2, Ord d2a) => (d2 -> d2a) -> Star3 fact d1 d2 d3 -> Star3 fact d1 d2a d3 | |
| 75 ┃ mapD2 f s = s { d2 = R.mapRan f (d2 s) } | |
| 76 ┃ | |
| 77 ┃ mapD3 :: (Ord fact, Ord d3, Ord d3a) => (d3 -> d3a) -> Star3 fact d1 d2 d3 -> Star3 fact d1 d2 d3a | |
| Delete this definition or add ‘Unison.Util.Star3.mapD2’ as a root to fix this error. | |
| src/Unison/Util/Star3.hs:139:1: error: memberD2 is unused | |
| 137 ┃ | |
| 138 ┃ memberD2 :: (Ord fact, Ord d2) => (fact,d2) -> Star3 fact d1 d2 d3 -> Bool | |
| 139 ┃ memberD2 (f, x) s = R.member f x (d2 s) | |
| 140 ┃ | |
| 141 ┃ memberD3 :: (Ord fact, Ord d3) => (fact,d3) -> Star3 fact d1 d2 d3 -> Bool | |
| Delete this definition or add ‘Unison.Util.Star3.memberD2’ as a root to fix this error. | |
| src/Unison/Util/Star3.hs:142:1: error: memberD3 is unused | |
| 140 ┃ | |
| 141 ┃ memberD3 :: (Ord fact, Ord d3) => (fact,d3) -> Star3 fact d1 d2 d3 -> Bool | |
| 142 ┃ memberD3 (f, x) s = R.member f x (d3 s) | |
| 143 ┃ | |
| 144 ┃ insert :: (Ord fact, Ord d1, Ord d2, Ord d3) | |
| Delete this definition or add ‘Unison.Util.Star3.memberD3’ as a root to fix this error. | |
| src/Unison/Util/Star3.hs:98:1: error: select1D3 is unused | |
| 96 ┃ :: (Ord fact, Ord d1, Ord d2, Ord d3) | |
| 97 ┃ => d3 -> Star3 fact d1 d2 d3 -> Star3 fact d1 d2 d3 | |
| 98 ┃ select1D3 = selectD3 . Set.singleton | |
| 99 ┃ | |
| 100 ┃ selectD3 | |
| Delete this definition or add ‘Unison.Util.Star3.select1D3’ as a root to fix this error. | |
| src/Unison/Util/Star3.hs:105:1: error: selectD3 is unused | |
| 103 ┃ -> Star3 fact d1 d2 d3 | |
| 104 ┃ -> Star3 fact d1 d2 d3 | |
| 105 ┃ selectD3 d3s s = Star3 fact' d1' d2' d3' where | |
| 106 ┃ fact' = Set.intersection (R.dom d3') (fact s) | |
| 107 ┃ d1' = R.dom d3' R.<| d1 s | |
| Delete this definition or add ‘Unison.Util.Star3.selectD3’ as a root to fix this error. | |
| src/Unison/Util/SyntaxText.hs:63:1: error: toPlain is unused | |
| 61 ┃ -- Convert a `SyntaxText` to a `String`, ignoring syntax markup | |
| 62 ┃ toPlain :: SyntaxText -> String | |
| 63 ┃ toPlain (AnnotatedText at) = join (toList $ fst <$> at) | |
| Delete this definition or add ‘Unison.Util.SyntaxText.toPlain’ as a root to fix this error. | |
| src/Unison/Util/TQueue.hs:24:1: error: awaitSize is unused | |
| 22 ┃ -- other thread which is consuming elements from the queue. | |
| 23 ┃ awaitSize :: Int -> TQueue a -> STM () | |
| 24 ┃ awaitSize target q = size q >>= \n -> | |
| 25 ┃ if n <= target then pure () | |
| 26 ┃ else retrySTM | |
| Delete this definition or add ‘Unison.Util.TQueue.awaitSize’ as a root to fix this error. | |
| src/Unison/Util/TQueue.hs:48:1: error: dequeueN is unused | |
| 46 ┃ | |
| 47 ┃ dequeueN :: TQueue a -> Int -> STM [a] | |
| 48 ┃ dequeueN (TQueue v _) n = readTVar v >>= \s -> | |
| 49 ┃ if length s >= n then writeTVar v (S.drop n s) $> toList (S.take n s) | |
| 50 ┃ else retrySTM | |
| Delete this definition or add ‘Unison.Util.TQueue.dequeueN’ as a root to fix this error. | |
| src/Unison/Util/TQueue.hs:86:1: error: peekWhile is unused | |
| 84 ┃ | |
| 85 ┃ peekWhile :: (a -> Bool) -> TQueue a -> STM [a] | |
| 86 ┃ peekWhile cond (TQueue v _) = readTVar v >>= \s -> let | |
| 87 ┃ (left, right) = S.spanl cond s in | |
| 88 ┃ if null right then retrySTM | |
| Delete this definition or add ‘Unison.Util.TQueue.peekWhile’ as a root to fix this error. | |
| src/Unison/Util/TQueue.hs:68:1: error: raceIO is unused | |
| 66 ┃ | |
| 67 ┃ raceIO :: MonadUnliftIO m => STM a -> STM b -> m (Either a b) | |
| 68 ┃ raceIO a b = do | |
| 69 ┃ aa <- Async.async $ atomically a | |
| 70 ┃ ab <- Async.async $ atomically b | |
| Delete this definition or add ‘Unison.Util.TQueue.raceIO’ as a root to fix this error. | |
| src/Unison/Util/TQueue.hs:18:1: error: size is unused | |
| 16 ┃ | |
| 17 ┃ size :: TQueue a -> STM Int | |
| 18 ┃ size (TQueue q _) = S.length <$> readTVar q | |
| 19 ┃ | |
| 20 ┃ -- Waits for this queue to reach a size <= target. | |
| Delete this definition or add ‘Unison.Util.TQueue.size’ as a root to fix this error. | |
| src/Unison/Util/TQueue.hs:80:1: error: takeWhile is unused | |
| 78 ┃ -- then return the prefix before that | |
| 79 ┃ takeWhile :: (a -> Bool) -> TQueue a -> STM [a] | |
| 80 ┃ takeWhile cond (TQueue v _) = readTVar v >>= \s -> let | |
| 81 ┃ (left, right) = S.spanl cond s in | |
| 82 ┃ if null right then retrySTM | |
| Delete this definition or add ‘Unison.Util.TQueue.takeWhile’ as a root to fix this error. | |
| src/Unison/Util/TQueue.hs:75:1: error: tryPeekWhile is unused | |
| 73 ┃ -- take all elements up to but not including the first not satisfying cond | |
| 74 ┃ tryPeekWhile :: (a -> Bool) -> TQueue a -> STM [a] | |
| 75 ┃ tryPeekWhile cond (TQueue v _) = toList . S.takeWhileL cond <$> readTVar v | |
| 76 ┃ | |
| 77 ┃ -- block until at least one element is enqueued not satisfying cond, | |
| Delete this definition or add ‘Unison.Util.TQueue.tryPeekWhile’ as a root to fix this error. | |
| src/Unison/Util/TransitiveClosure.hs:24:1: error: transitiveClosure' is unused | |
| 22 ┃ | |
| 23 ┃ transitiveClosure' :: Ord a => (a -> Set a) -> Set a -> Set a | |
| 24 ┃ transitiveClosure' f as = runIdentity $ transitiveClosure (pure . f) as | |
| 25 ┃ | |
| 26 ┃ transitiveClosure1 :: forall m a. (Monad m, Ord a) | |
| Delete this definition or add ‘Unison.Util.TransitiveClosure.transitiveClosure'’ as a root to fix this error. | |
| src/Unison/Util/TransitiveClosure.hs:28:1: error: transitiveClosure1 is unused | |
| 26 ┃ transitiveClosure1 :: forall m a. (Monad m, Ord a) | |
| 27 ┃ => (a -> m (Set a)) -> a -> m (Set a) | |
| 28 ┃ transitiveClosure1 f a = transitiveClosure f (Set.singleton a) | |
| 29 ┃ | |
| 30 ┃ transitiveClosure1' :: Ord a => (a -> Set a) -> a -> Set a | |
| Delete this definition or add ‘Unison.Util.TransitiveClosure.transitiveClosure1’ as a root to fix this error. | |
| src/Unison/Util/TransitiveClosure.hs:31:1: error: transitiveClosure1' is unused | |
| 29 ┃ | |
| 30 ┃ transitiveClosure1' :: Ord a => (a -> Set a) -> a -> Set a | |
| 31 ┃ transitiveClosure1' f a = runIdentity $ transitiveClosure1 (pure . f) a | |
| Delete this definition or add ‘Unison.Util.TransitiveClosure.transitiveClosure1'’ as a root to fix this error. | |
| src/Unison/Var.hs:162:1: error: freshNamed is unused | |
| 160 ┃ | |
| 161 ┃ freshNamed :: Var v => Set v -> Text -> v | |
| 162 ┃ freshNamed used n = ABT.freshIn used (named n) | |
| 163 ┃ | |
| 164 ┃ universallyQuantifyIfFree :: forall v . Var v => v -> Bool | |
| Delete this definition or add ‘Unison.Var.freshNamed’ as a root to fix this error. | |
| src/Unison/Var.hs:157:1: error: joinDot is unused | |
| 155 ┃ | |
| 156 ┃ joinDot :: Var v => v -> v -> v | |
| 157 ┃ joinDot prefix v2 = | |
| 158 ┃ if name prefix == "." then named (name prefix `mappend` name v2) | |
| 159 ┃ else named (name prefix `mappend` "." `mappend` name v2) | |
| Delete this definition or add ‘Unison.Var.joinDot’ as a root to fix this error. | |
| tests/Unison/Test/ANF.hs:118:1: error: backReference is unused | |
| 116 ┃ | |
| 117 ┃ backReference :: Word64 -> Reference | |
| 118 ┃ backReference _ = error "backReference" | |
| 119 ┃ | |
| 120 ┃ denormalizeMatch | |
| Delete this definition or add ‘Unison.Test.ANF.backReference’ as a root to fix this error. | |
| tests/Unison/Test/ANF.hs:108:1: error: denormalizeRef is unused | |
| 106 ┃ | |
| 107 ┃ denormalizeRef :: RTag -> Reference | |
| 108 ┃ denormalizeRef r | |
| 109 ┃ | 0 <- rawTag r = Ty.natRef | |
| 110 ┃ | 1 <- rawTag r = Ty.intRef | |
| Delete this definition or add ‘Unison.Test.ANF.denormalizeRef’ as a root to fix this error. | |
| tests/Unison/Test/ANF.hs:36:1: error: simpleRefs is unused | |
| 34 ┃ | |
| 35 ┃ simpleRefs :: Reference -> RTag | |
| 36 ┃ simpleRefs r | |
| 37 ┃ | r == Ty.natRef = 0 | |
| 38 ┃ | r == Ty.intRef = 1 | |
| Delete this definition or add ‘Unison.Test.ANF.simpleRefs’ as a root to fix this error. | |
| tests/Unison/Test/Codebase/Causal.hs:29:1: error: c is unused | |
| 27 ┃ | |
| 28 ┃ c :: M (Causal M Int64 [Int64]) | |
| 29 ┃ c = merge (foldr cons (one [1]) t1) | |
| 30 ┃ (foldr cons (foldr cons (one [1]) t2) t3) | |
| 31 ┃ where | |
| Delete this definition or add ‘Unison.Test.Codebase.Causal.c’ as a root to fix this error. | |
| tests/Unison/Test/Codebase/Causal.hs:38:1: error: c2 is unused | |
| 36 ┃ | |
| 37 ┃ c2 :: M (Causal M Int64 [Int64]) | |
| 38 ┃ c2 = merge (foldr cons (one [1]) t1) | |
| 39 ┃ (foldr cons (foldr cons (one [1]) t2) t3) | |
| 40 ┃ where | |
| Delete this definition or add ‘Unison.Test.Codebase.Causal.c2’ as a root to fix this error. | |
| tests/Unison/Test/Codebase/Causal.hs:298:1: error: cons'' is unused | |
| 296 ┃ => (Causal m1 h e2 -> m2 (Causal m2 h e1)) | |
| 297 ┃ -> e1 -> Causal m1 h e2 -> Causal m2 h e1 | |
| 298 ┃ cons'' pure e tl = | |
| 299 ┃ Cons (RawHash $ Causal.hash [Causal.hash e, unRawHash . currentHash $ tl]) e (currentHash tl, pure tl) | |
| 300 ┃ | |
| Delete this definition or add ‘Unison.Test.Codebase.Causal.cons''’ as a root to fix this error. | |
| tests/Unison/Test/Codebase/Causal.hs:304:1: error: merge'' is unused | |
| 302 ┃ => (Causal m h e -> m (Causal m h e)) | |
| 303 ┃ -> Causal m h e -> Causal m h e -> m (Causal m h e) | |
| 304 ┃ merge'' pure a b = | |
| 305 ┃ ifM (before a b) (pure b) . ifM (before b a) (pure a) $ case (a, b) of | |
| 306 ┃ (Merge _ _ tls, Merge _ _ tls2) -> merge0 $ Map.union tls tls2 | |
| Delete this definition or add ‘Unison.Test.Codebase.Causal.merge''’ as a root to fix this error. | |
| tests/Unison/Test/ColorText.hs:53:1: error: ex is unused | |
| 51 ┃ | |
| 52 ┃ ex :: Ord a => AnnotatedExcerpt a | |
| 53 ┃ ex = [r|The Tempest | Act 1, Scene 1 | |
| 54 ┃ | |
| 55 ┃ SCENE I. On a ship at sea: a tempestuous noise | |
| Delete this definition or add ‘Unison.Test.ColorText.ex’ as a root to fix this error. | |
| tests/Unison/Test/ColorText.hs:31:1: error: ex2 is unused | |
| 29 ┃ | |
| 30 ┃ ex2 :: AnnotatedExcerpt Color | |
| 31 ┃ ex2 = markup ex (Map.fromList | |
| 32 ┃ [ (Range (Pos 3 1) (Pos 3 5), Red) -- SCENE | |
| 33 ┃ , (Range (Pos 5 9) (Pos 5 14), Blue) -- Master | |
| Delete this definition or add ‘Unison.Test.ColorText.ex2’ as a root to fix this error. | |
| tests/Unison/Test/ColorText.hs:43:1: error: ex3 is unused | |
| 41 ┃ | |
| 42 ┃ ex3 :: AnnotatedExcerpt Color | |
| 43 ┃ ex3 = markup "Hello, world!" $ Map.fromList | |
| 44 ┃ [ (Range (Pos 1 8) (Pos 1 12), Blue) | |
| 45 ┃ , (Range (Pos 1 1) (Pos 1 5), Green) ] | |
| Delete this definition or add ‘Unison.Test.ColorText.ex3’ as a root to fix this error. | |
| tests/Unison/Test/ColorText.hs:48:1: error: ex4 is unused | |
| 46 ┃ | |
| 47 ┃ ex4 :: AnnotatedExcerpt Color | |
| 48 ┃ ex4 = markup "Hello,\nworld!" $ Map.fromList | |
| 49 ┃ [ (Range (Pos 2 1) (Pos 2 5), Blue) | |
| 50 ┃ , (Range (Pos 1 1) (Pos 1 5), Green) ] | |
| Delete this definition or add ‘Unison.Test.ColorText.ex4’ as a root to fix this error. | |
| tests/Unison/Test/ColorText.hs:23:1: error: ex4e is unused | |
| 21 ┃ | |
| 22 ┃ ex4e :: String | |
| 23 ┃ ex4e = toANSI . condensedExcerptToText 1 $ markup "abc" m | |
| 24 ┃ where m = Map.singleton (Range (Pos 1 2) (Pos 1 3)) Red | |
| 25 ┃ | |
| Delete this definition or add ‘Unison.Test.ColorText.ex4e’ as a root to fix this error. | |
| tests/Unison/Test/ColorText.hs:27:1: error: ex4t is unused | |
| 25 ┃ | |
| 26 ┃ ex4t :: String | |
| 27 ┃ ex4t = toANSI $ " 1 | " <> "a" <> ColorText.style Red "b" <> "c" <> "\n" | |
| 28 ┃ | |
| 29 ┃ | |
| Delete this definition or add ‘Unison.Test.ColorText.ex4t’ as a root to fix this error. | |
| tests/Unison/Test/ColorText.hs:40:1: error: renderEx2 is unused | |
| 38 ┃ | |
| 39 ┃ renderEx2 :: String | |
| 40 ┃ renderEx2 = toANSI . condensedExcerptToText 3 $ ex2 | |
| 41 ┃ | |
| 42 ┃ ex3 :: AnnotatedExcerpt Color | |
| Delete this definition or add ‘Unison.Test.ColorText.renderEx2’ as a root to fix this error. | |
| tests/Unison/Test/FileParser.hs:50:3: error: test2 is unused | |
| 48 ┃ | |
| 49 ┃ test2 :: Test () | |
| 50 ┃ test2 = scope "test2" $ | |
| 51 ┃ (io $ unsafeParseFileBuiltinsOnly "unison-src/test1.u") *> ok | |
| 52 ┃ | |
| Delete this definition or add ‘Unison.Test.FileParser.test2’ as a root to fix this error. | |
| tests/Unison/Test/Git.hs:294:1: error: initCodebaseDir is unused | |
| 292 ┃ -- initialize a fresh codebase | |
| 293 ┃ initCodebaseDir :: Branch.Cache IO -> FilePath -> String -> IO CodebasePath | |
| 294 ┃ initCodebaseDir branchCache tmpDir name = fst <$> initCodebase branchCache tmpDir name | |
| 295 ┃ | |
| 296 ┃ initCodebase :: Branch.Cache IO -> FilePath -> String -> IO (CodebasePath, Codebase IO Symbol Ann) | |
| Delete this definition or add ‘Unison.Test.Git.initCodebaseDir’ as a root to fix this error. | |
| tests/Unison/Test/TypePrinter.hs:56:1: error: tc_breaks is unused | |
| 54 ┃ -- Use renderBroken to render the output to some maximum width. | |
| 55 ┃ tc_breaks :: String -> Int -> String -> Test () | |
| 56 ┃ tc_breaks s width expected = tc_diff_rtt True s expected width | |
| 57 ┃ | |
| 58 ┃ test :: Test () | |
| Delete this definition or add ‘Unison.Test.TypePrinter.tc_breaks’ as a root to fix this error. | |
| tests/Unison/Test/Typechecker/Components.hs:11:1: error: test is unused | |
| 9 ┃ | |
| 10 ┃ test :: Test () | |
| 11 ┃ test = scope "Typechecker.Components" $ ok | |
| 12 ┃ -- [ | |
| 13 ┃ -- -- simple case, no minimization done | |
| Delete this definition or add ‘Unison.Test.Typechecker.Components.test’ as a root to fix this error. | |
| unison/System/Path.hs:55:1: error: fileList is unused | |
| 53 ┃ -- | Recursively list the contents of a directory. Depth-first. | |
| 54 ┃ fileList :: FilePath -> IO [FilePath] | |
| 55 ┃ fileList = mtreeList children | |
| 56 ┃ where children path = do | |
| 57 ┃ directory <- doesDirectoryExist path | |
| Delete this definition or add ‘System.Path.fileList’ as a root to fix this error. | |
| Weeds detected: 576 |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment