Clean up elaborator and evaluator warnings

Author: mio-19

modules/cli/shared/src/main/scala/chester/cli/Evaluator.scala

@@ -153,14 +153,14 @@ object Evaluator:
         evalWithEnv(body, extended)
       case Builtin(_, arity, run) if args.length == arity =>
         runner.pure(run(args))
-      case b: BuiltinIO[F] if args.length == b.arity =>
-        b.run(args)
+      case b: BuiltinIO[?] if args.length == b.arity =>
+        b.run.asInstanceOf[Vector[Value] => F[Value]](args)
       case _ =>
         runner.pure(UnitV)
   }
 
   private def sequence[F[_], A](fs: Iterable[F[A]])(using runner: Runner[F]): F[List[A]] =
-    fs.foldLeft(runner.pure(List.empty[A]))((accF, f) => accF.flatMap(acc => f.map(v => acc :+ v)))
+    fs.foldLeft(runner.pure(List.empty[A]))((accF, f) => accF.flatMap(acc => f.map(v => v :: acc))).map(_.reverse)
 
   def valueToString(v: Value): String = v match
     case IntV(n)               => n.toString

modules/core/shared/src/main/scala/chester/tyck/Elaborator.scala

@@ -1216,18 +1216,16 @@ object ElabHandler extends Handler[ElabConstraint]:
             fillResultOnce(resultCell, accessAst)
             module.readStable(solver, targetTy) match
               case None =>
-                lhs match
-                  case CST.Symbol(sym, _) =>
-                    (for
-                      id <- ctx.lookup(sym)
-                      tyCell <- ctx.lookupType(id)
-                      ty <- module.readStable(solver, tyCell)
-                    yield (id, ty)) match
-                      case Some((id, AST.RecordTypeRef(recId, _, _))) =>
-                        ctx.lookupRecordById(recId).flatMap(_.fields.find(_.name == field)) match
-                          case Some(param) => fillResultOnce(inferredTyCell, param.ty)
-                          case None        => fillResultOnce(inferredTyCell, AST.AnyType(span))
-                      case _ => ()
+                val CST.Symbol(sym, _) = lhs: @unchecked
+                (for
+                  id <- ctx.lookup(sym)
+                  tyCell <- ctx.lookupType(id)
+                  ty <- module.readStable(solver, tyCell)
+                yield (id, ty)) match
+                  case Some((_, AST.RecordTypeRef(recId, _, _))) =>
+                    ctx.lookupRecordById(recId).flatMap(_.fields.find(_.name == field)) match
+                      case Some(param) => fillResultOnce(inferredTyCell, param.ty)
+                      case None        => fillResultOnce(inferredTyCell, AST.AnyType(span))
                   case _ => ()
                 if !module.hasSomeValue(solver, inferredTyCell.asInstanceOf[module.CellAny]) then
                   fillResultOnce(inferredTyCell, AST.MetaCell(HoldNotReadable(targetTy), span))
@@ -3039,8 +3037,8 @@ object Elaborator:
     module.run(solver)
 
     val reports = reporter match
-      case vr: VectorReporter[ElabProblem] => vr.getReports
-      case _                               => Vector.empty
+      case vr: VectorReporter[?] => vr.getReports.asInstanceOf[Vector[ElabProblem]]
+      case _                     => Vector.empty
 
     results.map { (resCell, tyCell) =>
       val astOpt = module.readStable(solver, resCell).map(r => substituteSolutions(r)(using module, solver))