Question

例如，如何在ATS中构造一个包含从A到Z的大写字母的所有字母的数组？在C中，可以按如下方式完成：

char *Letters()
{
   int i;
   char *cs = (char *)malloc(26);
   assert(cs != 0);
   for (i = 0; i < 26; i += 1) cs[i] = 'A' + i;
   return cs;
}

Answer 1

嗯，这是一种方式，虽然它非常复杂，因为它遵循你概述的方法到字母：它涉及数组的线性证明（也就是数据视图），内存分配和数组初始化while循环。

extern
fun
Letters (): arrayptr (char, 26)
implement
Letters () = let
  val (pf_arr, pf_gc | p_arr) = array_ptr_alloc<char> ((i2sz)26)
  var i: int = 0
  prval [larr:addr] EQADDR () = eqaddr_make_ptr (p_arr)
  var p = p_arr
  prvar pf0 = array_v_nil {char} ()
  prvar pf1 = pf_arr
  //
  val () =
  while* {i:nat | i <= 26} .<26-i>. (
    i: int (i)
  , p: ptr (larr + i*sizeof(char))
  , pf0: array_v (char, larr, i)
  , pf1: array_v (char?, larr+i*sizeof(char), 26-i)
  ) : (
    pf0: array_v (char, larr, 26)
  , pf1: array_v (char?, larr+i*sizeof(char), 0)
  ) => (
    i < 26
  ) {
    //
    prval (pf_at, pf1_res) = array_v_uncons {char?} (pf1)
    prval () = pf1 := pf1_res
    //
    val c = 'A' + (g0ofg1)i
    val () = ptr_set<char> (pf_at | p, c)
    val () = p := ptr1_succ<char> (p)
    //
    prval () = pf0 := array_v_extend {char} (pf0, pf_at)
    val () = i := i + 1
    //
  } // end of [val]
  //
  prval () = pf_arr := pf0
  prval () = array_v_unnil {char?} (pf1)
  //
  val res = arrayptr_encode (pf_arr, pf_gc | p_arr)
in
  res
end // end of [Letters]

您可以在Glot.io

运行代码

Answer 2

您可以使用制表功能来创建线性数组。例如，

extern
fun
Letters(): arrayptr(char, 26)
implement
Letters() =
arrayptr_tabulate_cloref<char>
  (i2sz(26), lam(i) => 'A' + sz2i(i))

如果您不想使用更高阶的功能，可以尝试以下基于模板的解决方案：

implement
Letters() =
arrayptr_tabulate<char>(i2sz(26)) where
{
  implement array_tabulate$fopr<char> (i) = 'A' + sz2i(i)
}

如何在ATS中构建数组？

2 个答案: