arrays.scala

JAVA 语言的函数式编程扩展

    check(xs.length == 6, xs.length, 6);
    check(xs(0) == o0, xs(0), o0);
    check(xs(1) == o1, xs(1), o1);
    check(xs(2) == o2, xs(2), o2);
    check(xs(3) == o3, xs(3), o3);
    check(xs(4) == o4, xs(4), o4);
    check(xs(5) == o5, xs(5), o5);
  }

  def mcheck(xs: Array[Map    ]): Unit = {
    check(xs.length == 3, xs.length, 3);
    check(xs(0) == m0, xs(0), m0);
    check(xs(1) == m1, xs(1), m1);
    check(xs(2) == m2, xs(2), m2);
  }

  def ncheck(xs: Array[Strings]) {
    check(xs.length == 3, xs.length, 3)
    check(xs(0) == n0, xs(0), n0)
    check(xs(1) == n1, xs(1), n1)
    check(xs(2) == n2, xs(2), n2)
  }

  //##########################################################################
  // Miscellaneous checks

  def checkZip {
    val zipped = Array("a", "b", "c").zip(Array(1, 2))
    val expected = Array(("a",1), ("b",2))
    check(zipped sameElements expected, zipped.toList, expected.toList)
  }

  def checkConcat { // ticket #713
    val x1 = Array.concat(Array(1, 2), Array(3, 4))
    val y1 = Array(1, 2, 3, 4)
    check(x1 sameElements y1, x1.toList, y1.toList)

    val x2 = Array.concat(List(1, 2), List(3, 4))
    check(x2 sameElements y1, x2.toList, y1.toList)

    val x3 = Array.concat(<a>aaa</a>, <x>xxx</x>)
    val y3 = <a>aaa</a><x>xxx</x>;
    check(x3 sameElements y3, x3.toList, y3.toList)
  }

  //##########################################################################
  // Arrays

  val uarray: Array[Unit   ] = Array(u0, u1);
  val zarray: Array[Boolean] = Array(z0, z1);
  val barray: Array[Byte   ] = Array(b0, b1, b2);
  val sarray: Array[Short  ] = Array(s0, s1, s2);
  val carray: Array[Char   ] = Array(c0, c1, c2);
  val iarray: Array[Int    ] = Array(i0, i1, i2);
  val larray: Array[Long   ] = Array(l0, l1, l2);
  val farray: Array[Float  ] = Array(f0, f1, f2);
  val darray: Array[Double ] = Array(d0, d1, d2);
  val rarray: Array[AnyRef ] = Array(r0, r1, r2, r4, r4, r5);
  val oarray: Array[Object ] = Array(o0, o1, o2, o4, o4, o5);
  val marray: Array[Map    ] = Array(m0, m1, m2);
  val narray: Array[Strings] = Array(n0, n1, n2);

  //##########################################################################
  // Main

  def main(args: Array[String]): Unit = {

    //######################################################################

    ucheck(uarray);
    zcheck(zarray);
    bcheck(barray);
    scheck(sarray);
    ccheck(carray);
    icheck(iarray);
    lcheck(larray);
    fcheck(farray);
    dcheck(darray);
    rcheck(rarray);
    ocheck(oarray);
    mcheck(marray);
    ncheck(narray);

    //######################################################################

    ucheck(id_Ta_T(uarray));
    zcheck(id_Ta_T(zarray));
    bcheck(id_Ta_T(barray));
    scheck(id_Ta_T(sarray));
    ccheck(id_Ta_T(carray));
    icheck(id_Ta_T(iarray));
    lcheck(id_Ta_T(larray));
    fcheck(id_Ta_T(farray));
    dcheck(id_Ta_T(darray));
    rcheck(id_Ta_T(rarray));
    ocheck(id_Ta_T(oarray));
    mcheck(id_Ta_T(marray));
    ncheck(id_Ta_T(narray));

    ucheck(id_Tr_T(uarray));
    zcheck(id_Tr_T(zarray));
    bcheck(id_Tr_T(barray));
    scheck(id_Tr_T(sarray));
    ccheck(id_Tr_T(carray));
    icheck(id_Tr_T(iarray));
    lcheck(id_Tr_T(larray));
    fcheck(id_Tr_T(farray));
    dcheck(id_Tr_T(darray));
    rcheck(id_Tr_T(rarray));
    ocheck(id_Tr_T(oarray));
    mcheck(id_Tr_T(marray));
    ncheck(id_Tr_T(narray));

    ucheck(id_To_T(uarray));
    zcheck(id_To_T(zarray));
    bcheck(id_To_T(barray));
    scheck(id_To_T(sarray));
    ccheck(id_To_T(carray));
    icheck(id_To_T(iarray));
    lcheck(id_To_T(larray));
    fcheck(id_To_T(farray));
    dcheck(id_To_T(darray));
    rcheck(id_To_T(rarray));
    ocheck(id_To_T(oarray));
    mcheck(id_To_T(marray));
    ncheck(id_To_T(narray));

    ucheck(id_Ta_a(uarray).asInstanceOf[Array[Unit   ]]);
    zcheck(id_Ta_a(zarray).asInstanceOf[Array[Boolean]]);
    bcheck(id_Ta_a(barray).asInstanceOf[Array[Byte   ]]);
    scheck(id_Ta_a(sarray).asInstanceOf[Array[Short  ]]);
    ccheck(id_Ta_a(carray).asInstanceOf[Array[Char   ]]);
    icheck(id_Ta_a(iarray).asInstanceOf[Array[Int    ]]);
    lcheck(id_Ta_a(larray).asInstanceOf[Array[Long   ]]);
    fcheck(id_Ta_a(farray).asInstanceOf[Array[Float  ]]);
    dcheck(id_Ta_a(darray).asInstanceOf[Array[Double ]]);
    rcheck(id_Ta_a(rarray).asInstanceOf[Array[AnyRef ]]);
    ocheck(id_Ta_a(oarray).asInstanceOf[Array[Object ]]);
    mcheck(id_Ta_a(marray).asInstanceOf[Array[Map    ]]);
    ncheck(id_Ta_a(narray).asInstanceOf[Array[Strings]]);

    ucheck(id_Tr_a(uarray).asInstanceOf[Array[Unit   ]]);
    zcheck(id_Tr_a(zarray).asInstanceOf[Array[Boolean]]);
    bcheck(id_Tr_a(barray).asInstanceOf[Array[Byte   ]]);
    scheck(id_Tr_a(sarray).asInstanceOf[Array[Short  ]]);
    ccheck(id_Tr_a(carray).asInstanceOf[Array[Char   ]]);
    icheck(id_Tr_a(iarray).asInstanceOf[Array[Int    ]]);
    lcheck(id_Tr_a(larray).asInstanceOf[Array[Long   ]]);
    fcheck(id_Tr_a(farray).asInstanceOf[Array[Float  ]]);
    dcheck(id_Tr_a(darray).asInstanceOf[Array[Double ]]);
    rcheck(id_Tr_a(rarray).asInstanceOf[Array[AnyRef ]]);
    ocheck(id_Tr_a(oarray).asInstanceOf[Array[Object ]]);
    mcheck(id_Tr_a(marray).asInstanceOf[Array[Map    ]]);
    ncheck(id_Tr_a(narray).asInstanceOf[Array[Strings]]);

    ucheck(id_To_a(uarray).asInstanceOf[Array[Unit   ]]);
    zcheck(id_To_a(zarray).asInstanceOf[Array[Boolean]]);
    bcheck(id_To_a(barray).asInstanceOf[Array[Byte   ]]);
    scheck(id_To_a(sarray).asInstanceOf[Array[Short  ]]);
    ccheck(id_To_a(carray).asInstanceOf[Array[Char   ]]);
    icheck(id_To_a(iarray).asInstanceOf[Array[Int    ]]);
    lcheck(id_To_a(larray).asInstanceOf[Array[Long   ]]);
    fcheck(id_To_a(farray).asInstanceOf[Array[Float  ]]);
    dcheck(id_To_a(darray).asInstanceOf[Array[Double ]]);
    rcheck(id_To_a(rarray).asInstanceOf[Array[AnyRef ]]);
    ocheck(id_To_a(oarray).asInstanceOf[Array[Object ]]);
    mcheck(id_To_a(marray).asInstanceOf[Array[Map    ]]);
    ncheck(id_To_a(narray).asInstanceOf[Array[Strings]]);

    ucheck(id_Tr_r(uarray).asInstanceOf[Array[Unit   ]]);
    zcheck(id_Tr_r(zarray).asInstanceOf[Array[Boolean]]);
    bcheck(id_Tr_r(barray).asInstanceOf[Array[Byte   ]]);
    scheck(id_Tr_r(sarray).asInstanceOf[Array[Short  ]]);
    ccheck(id_Tr_r(carray).asInstanceOf[Array[Char   ]]);
    icheck(id_Tr_r(iarray).asInstanceOf[Array[Int    ]]);
    lcheck(id_Tr_r(larray).asInstanceOf[Array[Long   ]]);
    fcheck(id_Tr_r(farray).asInstanceOf[Array[Float  ]]);
    dcheck(id_Tr_r(darray).asInstanceOf[Array[Double ]]);
    rcheck(id_Tr_r(rarray).asInstanceOf[Array[AnyRef ]]);
    ocheck(id_Tr_r(oarray).asInstanceOf[Array[Object ]]);
    mcheck(id_Tr_r(marray).asInstanceOf[Array[Map    ]]);
    ncheck(id_Tr_r(narray).asInstanceOf[Array[Strings]]);

    ucheck(id_To_r(uarray).asInstanceOf[Array[Unit   ]]);
    zcheck(id_To_r(zarray).asInstanceOf[Array[Boolean]]);
    bcheck(id_To_r(barray).asInstanceOf[Array[Byte   ]]);
    scheck(id_To_r(sarray).asInstanceOf[Array[Short  ]]);
    ccheck(id_To_r(carray).asInstanceOf[Array[Char   ]]);
    icheck(id_To_r(iarray).asInstanceOf[Array[Int    ]]);
    lcheck(id_To_r(larray).asInstanceOf[Array[Long   ]]);
    fcheck(id_To_r(farray).asInstanceOf[Array[Float  ]]);
    dcheck(id_To_r(darray).asInstanceOf[Array[Double ]]);
    rcheck(id_To_r(rarray).asInstanceOf[Array[AnyRef ]]);
    ocheck(id_To_r(oarray).asInstanceOf[Array[Object ]]);
    mcheck(id_To_r(marray).asInstanceOf[Array[Map    ]]);
    ncheck(id_To_r(narray).asInstanceOf[Array[Strings]]);

    ucheck(id_To_o(uarray).asInstanceOf[Array[Unit   ]]);
    zcheck(id_To_o(zarray).asInstanceOf[Array[Boolean]]);
    bcheck(id_To_o(barray).asInstanceOf[Array[Byte   ]]);
    scheck(id_To_o(sarray).asInstanceOf[Array[Short  ]]);
    ccheck(id_To_o(carray).asInstanceOf[Array[Char   ]]);
    icheck(id_To_o(iarray).asInstanceOf[Array[Int    ]]);
    lcheck(id_To_o(larray).asInstanceOf[Array[Long   ]]);
    fcheck(id_To_o(farray).asInstanceOf[Array[Float  ]]);
    dcheck(id_To_o(darray).asInstanceOf[Array[Double ]]);
    rcheck(id_To_o(rarray).asInstanceOf[Array[AnyRef ]]);
    ocheck(id_To_o(oarray).asInstanceOf[Array[Object ]]);
    mcheck(id_To_o(marray).asInstanceOf[Array[Map    ]]);
    ncheck(id_To_o(narray).asInstanceOf[Array[Strings]]);

    //######################################################################

    ucheck(id_TSa_T [Unit   , Array[Unit   ]](uarray));
    zcheck(id_TSa_T [Boolean, Array[Boolean]](zarray));
    bcheck(id_TSa_T [Byte   , Array[Byte   ]](barray));
    scheck(id_TSa_T [Short  , Array[Short  ]](sarray));
    ccheck(id_TSa_T [Char   , Array[Char   ]](carray));
    icheck(id_TSa_T [Int    , Array[Int    ]](iarray));
    lcheck(id_TSa_T [Long   , Array[Long   ]](larray));
    fcheck(id_TSa_T [Float  , Array[Float  ]](farray));
    dcheck(id_TSa_T [Double , Array[Double ]](darray));
    rcheck(id_TSa_T [AnyRef , Array[AnyRef ]](rarray));
    ocheck(id_TSa_T [Object , Array[Object ]](oarray));
    mcheck(id_TSa_T [Map    , Array[Map    ]](marray));
    ncheck(id_TSa_T [Strings, Array[Strings]](narray));

    ucheck(id_TSv_T [Unit   , Array[Unit   ]](uarray));
    zcheck(id_TSv_T [Boolean, Array[Boolean]](zarray));
    bcheck(id_TSv_T [Byte   , Array[Byte   ]](barray));
    scheck(id_TSv_T [Short  , Array[Short  ]](sarray));
    ccheck(id_TSv_T [Char   , Array[Char   ]](carray));
    icheck(id_TSv_T [Int    , Array[Int    ]](iarray));
    lcheck(id_TSv_T [Long   , Array[Long   ]](larray));
    fcheck(id_TSv_T [Float  , Array[Float  ]](farray));
    dcheck(id_TSv_T [Double , Array[Double ]](darray));

    rcheck(id_TSr_T [AnyRef , Array[AnyRef ]](rarray));
    ocheck(id_TSr_T [Object , Array[Object ]](oarray));
    mcheck(id_TSr_T [Map    , Array[Map    ]](marray));
    ncheck(id_TSr_T [Strings, Array[Strings]](narray));

    rcheck(id_TSo_T [AnyRef , Array[AnyRef ]](rarray));
    ocheck(id_TSo_T [Object , Array[Object ]](oarray));
    mcheck(id_TSo_T [Map    , Array[Map    ]](marray));
    ncheck(id_TSo_T [Strings, Array[Strings]](narray));

    mcheck(id_TSm_T [Map    , Array[Map    ]](marray));

    ncheck(id_TSn_T [Strings, Array[Strings]](narray));

    //######################################################################

    ucheck(id_TSa_Ss[Unit   , Array[Unit   ]](uarray));
    zcheck(id_TSa_Ss[Boolean, Array[Boolean]](zarray));
    bcheck(id_TSa_Ss[Byte   , Array[Byte   ]](barray));
    scheck(id_TSa_Ss[Short  , Array[Short  ]](sarray));
    ccheck(id_TSa_Ss[Char   , Array[Char   ]](carray));
    icheck(id_TSa_Ss[Int    , Array[Int    ]](iarray));
    lcheck(id_TSa_Ss[Long   , Array[Long   ]](larray));
    fcheck(id_TSa_Ss[Float  , Array[Float  ]](farray));
    dcheck(id_TSa_Ss[Double , Array[Double ]](darray));
    rcheck(id_TSa_Ss[AnyRef , Array[AnyRef ]](rarray));
    ocheck(id_TSa_Ss[Object , Array[Object ]](oarray));
    mcheck(id_TSa_Ss[Map    , Array[Map    ]](marray));
    ncheck(id_TSa_Ss[Strings, Array[Strings]](narray));

    ucheck(id_TSv_Ss[Unit   , Array[Unit   ]](uarray));
    zcheck(id_TSv_Ss[Boolean, Array[Boolean]](zarray));
    bcheck(id_TSv_Ss[Byte   , Array[Byte   ]](barray));
    scheck(id_TSv_Ss[Short  , Array[Short  ]](sarray));
    ccheck(id_TSv_Ss[Char   , Array[Char   ]](carray));
    icheck(id_TSv_Ss[Int    , Array[Int    ]](iarray));
    lcheck(id_TSv_Ss[Long   , Array[Long   ]](larray));
    fcheck(id_TSv_Ss[Float  , Array[Float  ]](farray));
    dcheck(id_TSv_Ss[Double , Array[Double ]](darray));

    rcheck(id_TSr_Ss[AnyRef , Array[AnyRef ]](rarray));
    ocheck(id_TSr_Ss[Object , Array[Object ]](oarray));
    mcheck(id_TSr_Ss[Map    , Array[Map    ]](marray));
    ncheck(id_TSr_Ss[Strings, Array[Strings]](narray));

    rcheck(id_TSo_Ss[AnyRef , Array[AnyRef ]](rarray));
    ocheck(id_TSo_Ss[Object , Array[Object ]](oarray));
    mcheck(id_TSo_Ss[Map    , Array[Map    ]](marray));
    ncheck(id_TSo_Ss[Strings, Array[Strings]](narray));

    mcheck(id_TSm_Ss[Map    , Array[Map    ]](marray));

    ncheck(id_TSn_Ss[Strings, Array[Strings]](narray));

    //######################################################################

    ucheck(id_TSa_a [Unit   , Array[Unit   ]](uarray).asInstanceOf[Array[Unit   ]]);
    zcheck(id_TSa_a [Boolean, Array[Boolean]](zarray).asInstanceOf[Array[Boolean]]);
    bcheck(id_TSa_a [Byte   , Array[Byte   ]](barray).asInstanceOf[Array[Byte   ]]);
    scheck(id_TSa_a [Short  , Array[Short  ]](sarray).asInstanceOf[Array[Short  ]]);
    ccheck(id_TSa_a [Char   , Array[Char   ]](carray).asInstanceOf[Array[Char   ]]);
    icheck(id_TSa_a [Int    , Array[Int    ]](iarray).asInstanceOf[Array[Int    ]]);
    lcheck(id_TSa_a [Long   , Array[Long   ]](larray).asInstanceOf[Array[Long   ]]);
    fcheck(id_TSa_a [Float  , Array[Float  ]](farray).asInstanceOf[Array[Float  ]]);
    dcheck(id_TSa_a [Double , Array[Double ]](darray).asInstanceOf[Array[Double ]]);
    rcheck(id_TSa_a [AnyRef , Array[AnyRef ]](rarray).asInstanceOf[Array[AnyRef ]]);
    ocheck(id_TSa_a [Object , Array[Object ]](oarray).asInstanceOf[Array[Object ]]);
    mcheck(id_TSa_a [Map    , Array[Map    ]](marray).asInstanceOf[Array[Map    ]]);
    ncheck(id_TSa_a [Strings, Array[Strings]](narray).asInstanceOf[Array[Strings]]);

    ucheck(id_TSv_a [Unit   , Array[Unit   ]](uarray).asInstanceOf[Array[Unit   ]]);
    zcheck(id_TSv_a [Boolean, Array[Boolean]](zarray).asInstanceOf[Array[Boolean]]);
    bcheck(id_TSv_a [Byte   , Array[Byte   ]](barray).asInstanceOf[Array[Byte   ]]);
    scheck(id_TSv_a [Short  , Array[Short  ]](sarray).asInstanceOf[Array[Short  ]]);
    ccheck(id_TSv_a [Char   , Array[Char   ]](carray).asInstanceOf[Array[Char   ]]);
    icheck(id_TSv_a [Int    , Array[Int    ]](iarray).asInstanceOf[Array[Int    ]]);
    lcheck(id_TSv_a [Long   , Array[Long   ]](larray).asInstanceOf[Array[Long   ]]);