Switching out Vector.toList (Vector.keepAllMap (...)) with calls to V…

…ector.toListKeepAllMap.
MLton · Jun 7, 2018 · d0e2dcc · d0e2dcc
1 parent 3b20239
commit d0e2dcc
Show file tree

Hide file tree

Showing 4 changed files with 26 additions and 28 deletions.
diff --git a/mlton/atoms/int-size.fun b/mlton/atoms/int-size.fun
@@ -23,12 +23,11 @@ fun isValidSize (i: int) =
    (1 <= i andalso i <= 32) orelse i = 64
 
 val sizes: Bits.t list =
-   Vector.toList
-   (Vector.keepAllMap
-    (Vector.tabulate (65, fn i => if isValidSize i
+   Vector.toListKeepAllMap (Vector.tabulate (65, fn i => 
+                                  if isValidSize i
                                      then SOME (Bits.fromInt i)
                                   else NONE),
-     fn i => i))
+     fn i => i)
 
 fun make i = T {bits = i}
 

diff --git a/mlton/atoms/word-size.fun b/mlton/atoms/word-size.fun
@@ -52,7 +52,7 @@ val allVector = Vector.tabulate (65, fn i =>
                                      then SOME (fromBits (Bits.fromInt i))
                                   else NONE)
 
-val all: t list = Vector.toList (Vector.keepAllMap (allVector, fn so => so))
+val all: t list = Vector.toListKeepAllMap (allVector, fn so => so)
 
 val prims = List.map ([8, 16, 32, 64], fromBits o Bits.fromInt)
 

diff --git a/mlton/backend/rssa.fun b/mlton/backend/rssa.fun
@@ -1078,15 +1078,15 @@ structure Program =
                                | Const c => SOME (ApplyArg.Const c)
                                | Var x => SOME (ApplyArg.Var x)
                                | _ => NONE
-                           val applyArgs = Vector.keepAllMap (args, getArg)
+                           val applyArgs = Vector.toListKeepAllMap (args, getArg) 
                            datatype z = datatype ApplyResult.t
                         in
-                           if Vector.length args <> Vector.length applyArgs
+                           if Vector.length args <> List.length applyArgs
                               then keep ()
                            else
                               case (tracePrimApply
                                     Prim.apply
-                                    (prim, Vector.toList applyArgs,
+                                    (prim, applyArgs,
                                      fn ({var = x, ...}, {var = y, ...}) =>
                                      Var.equals (x, y))) of
                                  Apply (prim, args) =>

diff --git a/mlton/elaborate/elaborate-env.fun b/mlton/elaborate/elaborate-env.fun
@@ -456,26 +456,25 @@ structure TypeStr =
                   let
                      val extra = ref false
                      val cons =
-                        Vector.toList
-                        (Vector.keepAllMap
-                         (Cons.dest cons, fn {name, scheme, ...} =>
-                          let
-                             val (tyvars, ty) = Scheme.dest scheme
-                          in
-                             case Type.deArrowOpt ty of
-                                NONE => (extra := true; NONE)
-                              | SOME (arg, _) =>
-                                   let
-                                      val argScheme =
-                                         Scheme.make {canGeneralize = true,
-                                                      ty = arg,
-                                                      tyvars = tyvars}
-                                   in
-                                      case Scheme.checkEquality (argScheme, {layoutPrettyTycon = layoutPrettyTycon}) of
-                                         NONE => (extra := true; NONE)
-                                       | SOME l => SOME (seq [Ast.Con.layout name, str " of ", l])
-                                   end
-                          end))
+                        Vector.toListKeepAllMap (Cons.dest cons, fn {name, scheme, ...} =>
+                           let
+                              val (tyvars, ty) = Scheme.dest scheme
+                           in
+                              case Type.deArrowOpt ty of
+                                 NONE => (extra := true; NONE)
+                               | SOME (arg, _) =>
+                                    let
+                                       val argScheme =
+                                          Scheme.make {canGeneralize = true,
+                                                       ty = arg,
+                                                       tyvars = tyvars}
+                                    in
+                                       case Scheme.checkEquality (argScheme, {layoutPrettyTycon = layoutPrettyTycon}) of
+                                          NONE => (extra := true; NONE)
+                                        | SOME l => SOME (seq [Ast.Con.layout name, str " of ", l])
+                                    end
+                           end)
+
                      val cons =
                         if !extra
                            then List.snoc (cons, str "...")