weeds.txt

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