regression/mlton.share.sml

   1 (* sharing on a non-object *)
   2 val () = MLton.share 13
   3
   4 (* tuple option array *)
   5 val a = Array.tabulate (100, fn i => SOME (i mod 2, i mod 3))
   6 val () = Array.update (a, 0, NONE)
   7
   8 fun msg () =
   9    (print (concat ["size of a is ", Int.toString (MLton.size a), "\n"])
  10     ; Array.appi (fn (i, z) =>
  11                   print (concat [Int.toString i, " => ",
  12                                  case z of
  13                                     NONE => "NONE"
  14                                   | SOME (a, b) =>
  15                                        concat ["(", Int.toString a, ", ",
  16                                                Int.toString b, ")"],
  17                                  "\n"])) a)
  18
  19 val () = msg ()
  20 val () = MLton.share a
  21 val () = msg ()
  22
  23 (* tuple option array with pre-existing sharing *)
  24 val a = Array.tabulate (100, fn i =>
  25                         if i mod 2 = 0
  26                            then SOME (1, 1)
  27                         else SOME (i mod 3, i mod 3))
  28 val () = Array.update (a, 0, NONE)
  29 fun msg () =
  30    (print (concat ["size of a is ", Int.toString (MLton.size a), "\n"])
  31     ; Array.appi (fn (i, z) =>
  32                   print (concat [Int.toString i, " => ",
  33                                  case z of
  34                                     NONE => "NONE"
  35                                   | SOME (a, b) =>
  36                                        concat ["(", Int.toString a, ", ",
  37                                                Int.toString b, ")"],
  38                                        "\n"])) a)
  39 val () = msg ()
  40 val () = MLton.share a
  41 val () = msg ()
  42
  43 (* tuple option ref array *)
  44
  45 val a = Array.tabulate (100, fn i => ref (SOME (i mod 2, i mod 3)))
  46 val () = Array.sub (a, 0) := NONE
  47
  48 fun msg () =
  49    (print (concat ["size of a is ", Int.toString (MLton.size a), "\n"])
  50     ; Array.appi (fn (i, z) =>
  51                   print (concat [Int.toString i, " => ",
  52                                  case !z of
  53                                     NONE => "NONE"
  54                                   | SOME (a, b) =>
  55                                        concat ["(", Int.toString a, ", ",
  56                                                Int.toString b, ")"],
  57                                  "\n"])) a)
  58
  59 val () = msg ()
  60 val () = MLton.share a
  61 val () = msg ()
  62 val () = Array.appi (fn (i, r) =>
  63                      r := (if i = 0 then NONE else (SOME (i mod 2, i mod 3)))) a
  64 val () = msg ()
  65
  66 (* big tuple option array *)
  67 val a = Array.tabulate (100000, fn i => SOME (i mod 2, i mod 3))
  68 val () = Array.update (a, 0, NONE)
  69
  70 fun msg () =
  71    print (concat ["size of a is ", Int.toString (MLton.size a), "\n",
  72                   case Array.sub (a, 1) of
  73                      NONE => "NONE"
  74                    | SOME (a, b) =>
  75                         concat ["(", Int.toString a, ", ", Int.toString b, ")"],
  76                         "\n"])
  77
  78 val () = msg ()
  79 val () = MLton.share a
  80 val () = msg ()
  81
  82 (* non-sharing of vectors *)
  83 datatype t = A | B
  84 val v1 = Vector.fromList [A, B, A, B, A, B, A, B, A, B, A, B]
  85 val v2 = Vector.fromList [A, B, A, B, A, B, A, B, A, B, A, A]
  86
  87 val a = Array.tabulate (4, fn i =>
  88                         if i mod 2 = 0
  89                            then v1
  90                         else v2)
  91
  92 val () = MLton.share a
  93
  94 val () =
  95    if Array.sub (a, 2) = Array.sub (a, 3)
  96       then raise Fail "bug"
  97    else ()
  98
  99 (* sharing of vectors *)
 100 val a =
 101    Array.tabulate (10, fn i =>
 102                    if i mod 2 = 0
 103                      then "abcdef"
 104                    else concat ["abc", "def"])
 105
 106 fun p () = print (concat ["size is ", Int.toString (MLton.size a), "\n"])
 107
 108 val () = p ()
 109
 110 val () = MLton.share a
 111
 112 val () = p ()
 113
 114 val s0 = Array.sub (a, 0)
 115
 116 val s1 = Array.sub (a, 1)
 117
 118 val () = print (concat [s0, " ", s1, "\n"])
 119
 120 (* sharing of vectors in a tuple *)
 121
 122 val t = ("abcdef", concat ["abc", "def"])
 123
 124 fun p () = print (concat ["size is ", Int.toString (MLton.size t), "\n"])
 125
 126 val () = p ()
 127
 128 val () = MLton.share t
 129
 130 val () = p ()
 131
 132 val (s1, s2) = t
 133
 134 val () = print (concat [s1, " ", s2, "\n"])
 135
 136 (* non-sharing of similar looking strings of different lengths. *)
 137 val a =
 138    Array.tabulate (10, fn i =>
 139                    if 0 = i mod 2
 140                       then "a"
 141                    else concat ["a", "\000"])
 142
 143 val () = MLton.share a
 144
 145 val s0 = Array.sub (a, 0)
 146 val s1 = Array.sub (a, 1)
 147
 148 val () =
 149    print (concat [Int.toString (size s0), " ",
 150                   Int.toString (size s1), "\n"])
 151