Quelle  Tuple.js   Sprache: JAVA

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

function TupleToArray(obj) {
  var len = TupleLength(obj);
  var items = std_Array(len);

  for (var k = 0; k < len; k++) {
    DefineDataProperty(items, k, obj[k]);
  }
  return items;
}

// proposal-record-tuple
// Tuple.prototype.toSorted()
function TupleToSorted(comparefn) {
  /* Step 1. */
  if (comparefn !== undefined && !IsCallable(comparefn)) {
    ThrowTypeError(JSMSG_BAD_SORT_ARG);
  }

  /* Step 2. */
  var T = ThisTupleValue(this);

  /* Step 3. */
  var items = TupleToArray(T);
  var sorted = callFunction(std_Array_sort, items, comparefn);
  return std_Tuple_unchecked(sorted);
}

// proposal-record-tuple
// Tuple.prototype.toSpliced()
function TupleToSpliced(start, deleteCount /*, ...items */) {
  /* Steps 1-2. */
  var list = ThisTupleValue(this);

  /* Step 3. */
  var len = TupleLength(list);

  /* Step 4. */
  var relativeStart = ToInteger(start);

  /* Step 5. */
  var actualStart;
  if (relativeStart < 0) {
    actualStart = std_Math_max(len + relativeStart, 0);
  } else {
    actualStart = std_Math_min(relativeStart, len);
  }

  /* Step 6. */
  var insertCount;
  var actualDeleteCount;
  if (ArgumentsLength() === 0) {
    insertCount = 0;
    actualDeleteCount = 0;
  } else if (ArgumentsLength() === 1) {
    /* Step 7. */
    insertCount = 0;
    actualDeleteCount = len - actualStart;
  } else {
    /* Step 8a. */
    insertCount = ArgumentsLength() - 2;
    /* Step 8b. */
    var dc = ToInteger(deleteCount);
    /* Step 8c. */
    actualDeleteCount = std_Math_min(std_Math_max(dc, 0), len - actualStart);
  }

  /* Step 9. */
  if (len + insertCount - actualDeleteCount > MAX_NUMERIC_INDEX) {
    ThrowTypeError(JSMSG_TOO_LONG_ARRAY);
  }

  /* Step 10. */
  var k = 0;
  /* Step 11. */
  /* Step 12. */
  var itemCount = insertCount;

  /* Step 13. */
  var newList = [];

  /* Step 14. */
  while (k < actualStart) {
    /* Step 14a. */
    var E = list[k];
    /* Step 14b. */
    DefineDataProperty(newList, k, E);
    /* Step 14c. */
    k++;
  }

  /* Step 15. */
  var itemK = 0;
  /* Step 16. */
  while (itemK < itemCount) {
    /* Step 16a. */
    var E = GetArgument(itemK + 2);
    /* Step 16b. */
    if (IsObject(E)) {
      ThrowTypeError(JSMSG_RECORD_TUPLE_NO_OBJECT);
    }
    /* Step 16c. */
    DefineDataProperty(newList, k, E);
    /* Step 16d. */
    k++;
    itemK++;
  }

  /* Step 17. */
  itemK = actualStart + actualDeleteCount;
  /* Step 18. */
  while (itemK < len) {
    /* Step 18a. */
    var E = list[itemK];
    /* Step 18b. */
    DefineDataProperty(newList, k, E);
    /* Step 18c. */
    k++;
    itemK++;
  }

  /* Step 19. */
  return std_Tuple_unchecked(newList);
}

// proposal-record-tuple
// Tuple.prototype.toReversed()
function TupleToReversed() {
  /* Step 1. */
  var T = ThisTupleValue(this);

  /* Step 2 not necessary */

  /* Step 3. */
  var len = TupleLength(T);
  var newList = [];

  /* Step 4. */
  for (var k = len - 1; k >= 0; k--) {
    /* Step 5a. */
    var E = T[k];
    /* Step 5b. */
    DefineDataProperty(newList, len - k - 1, E);
  }

  /* Step 5. */
  return std_Tuple_unchecked(newList);
}

// ES 2017 draft (April 8, 2016) 22.1.3.1.1
function IsConcatSpreadable(O) {
  // Step 1.
  if (!IsObject(O) && !IsTuple(O)) {
    return false;
  }

  // Step 2.
  var spreadable = O[GetBuiltinSymbol("isConcatSpreadable")];

  // Step 3.
  if (spreadable !== undefined) {
    return ToBoolean(spreadable);
  }

  if (IsTuple(O)) {
    return true;
  }

  // Step 4.
  return IsArray(O);
}

// proposal-record-tuple
// Tuple.prototype.concat()
function TupleConcat() {
  /* Step 1 */
  var T = ThisTupleValue(this);
  /* Step 2 (changed to include all elements from T). */
  var list = TupleToArray(T);
  /* Step 3 */
  var n = list.length;
  /* Step 4 not necessary due to changed step 2. */
  /* Step 5 */
  for (var i = 0; i < ArgumentsLength(); i++) {
    /* Step 5a. */
    var E = GetArgument(i);
    /* Step 5b. */
    var spreadable = IsConcatSpreadable(E);
    /* Step 5c. */
    if (spreadable) {
      /* Step 5c.i. */
      var k = 0;
      /* Step 5c.ii */
      var len = ToLength(E.length);
      /* Step 5c.iii */
      if (n + len > MAX_NUMERIC_INDEX) {
        ThrowTypeError(JSMSG_TOO_LONG_ARRAY);
      }
      /* Step 5c.iv */
      while (k < len) {
        /* Step 5c.iv.2 */
        var exists = E[k] !== undefined;
        /* Step 5c.iv.3 */
        if (exists) {
          /* Step 5c.iv.3.a */
          var subElement = E[k];
          /* Step 5c.iv.3.b */
          if (IsObject(subElement)) {
            ThrowTypeError(JSMSG_RECORD_TUPLE_NO_OBJECT);
          }
          /* Step 5c.iv.3.c */
          DefineDataProperty(list, n, subElement);
          /* Step 5c.iv.4 */
          n++;
        }
        /* Step 5c.iv.5 */
        k++;
      }
    } else {
      /* Step 5d. */
      /* Step 5d.ii. */
      if (n >= MAX_NUMERIC_INDEX) {
        ThrowTypeError(JSMSG_TOO_LONG_ARRAY);
      }
      /* Step 5d.iii. */
      if (IsObject(E)) {
        ThrowTypeError(JSMSG_RECORD_TUPLE_NO_OBJECT);
      }
      /* Step 5d.iv. */
      DefineDataProperty(list, n, E);
      /* Step 5d.v. */
      n++;
    }
  }
  /* Step 6 */
  return std_Tuple_unchecked(list);
}

// proposal-record-tuple
// Tuple.prototype.includes()
function TupleIncludes(valueToFind /* , fromIndex */) {
  var fromIndex = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
  return callFunction(
    std_Array_includes,
    ThisTupleValue(this),
    valueToFind,
    fromIndex
  );
}

// proposal-record-tuple
// Tuple.prototype.indexOf()
function TupleIndexOf(valueToFind /* , fromIndex */) {
  var fromIndex = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
  return callFunction(
    std_Array_indexOf,
    ThisTupleValue(this),
    valueToFind,
    fromIndex
  );
}

// proposal-record-tuple
// Tuple.prototype.join()
function TupleJoin(separator) {
  var T = ThisTupleValue(this);

  // Step 2
  var len = TupleLength(T);

  // Steps 3-4
  var sep = ",";
  if (!IsNullOrUndefined(separator)) {
    var toString = IsCallable(separator.toString)
      ? separator.toString
      : std_Object_toString;
    sep = callContentFunction(toString, separator);
  }

  // Step 5
  var R = "";

  // Step 6
  var k = 0;

  // Step 7
  while (k < len) {
    // Step 7a
    if (k > 0) {
      R += sep;
    }
    // Step 7b
    var element = T[k];
    // Step 7c
    var next = "";
    if (!IsNullOrUndefined(element)) {
      var toString = IsCallable(element.toString)
        ? element.toString
        : std_Object_toString;
      next = callContentFunction(toString, element);
    }
    // Step 7d
    R += next;
    // Step 7e
    k++;
  }
  // Step 8
  return R;
}

// proposal-record-tuple
// Tuple.prototype.lastIndexOf()
function TupleLastIndexOf(valueToFind /* , fromIndex */) {
  if (ArgumentsLength() < 2) {
    return callFunction(
      std_Array_lastIndexOf,
      ThisTupleValue(this),
      valueToFind
    );
  }
  return callFunction(
    std_Array_lastIndexOf,
    ThisTupleValue(this),
    valueToFind,
    GetArgument(1)
  );
}

// proposal-record-tuple
// Tuple.prototype.toString()
function TupleToString() {
  /* Step 1. */
  var T = ThisTupleValue(this);
  /* Step 2. */
  var func = T.join;
  if (!IsCallable(func)) {
    return callFunction(std_Object_toString, T);
  }
  /* Step 4. */
  return callContentFunction(func, T);
}

// proposal-record-tuple
// Tuple.prototype.toLocaleString()
function TupleToLocaleString(locales, options) {
  var T = ThisTupleValue(this);
  return callContentFunction(
    ArrayToLocaleString,
    TupleToArray(T),
    locales,
    options
  );
}

// proposal-record-tuple
// Tuple.prototype.entries()
function TupleEntries() {
  return CreateArrayIterator(this, ITEM_KIND_KEY_AND_VALUE);
}

// proposal-record-tuple
// Tuple.prototype.keys()
function TupleKeys() {
  return CreateArrayIterator(this, ITEM_KIND_KEY);
}

// proposal-record-tuple
// Tuple.prototype.values()
function $TupleValues() {
  return CreateArrayIterator(this, ITEM_KIND_VALUE);
}

SetCanonicalName($TupleValues, "values");

// proposal-record-tuple
// Tuple.prototype.every()
function TupleEvery(callbackfn) {
  return callContentFunction(ArrayEvery, ThisTupleValue(this), callbackfn);
}

// proposal-record-tuple
// Tuple.prototype.filter()
function TupleFilter(callbackfn) {
  /* Steps 1-2 */
  var list = ThisTupleValue(this);

  /* Step 3. */
  var len = TupleLength(list);

  /* Step 4. */
  if (ArgumentsLength() === 0) {
    ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Tuple.prototype.filter");
  }
  if (!IsCallable(callbackfn)) {
    ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, callbackfn));
  }

  /* Step 5. */
  var newList = [];

  /* Step 6. */
  var k = 0;
  var newK = 0;

  /* Step 7. */
  var T = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
  while (k < len) {
    /* Step 7a. */
    var kValue = list[k];
    /* Step 7b. */
    var selected = ToBoolean(
      callContentFunction(callbackfn, T, kValue, k, list)
    );
    /* Step 7c. */
    if (selected) {
      /* Step 7c.i. */
      DefineDataProperty(newList, newK++, kValue);
    }
    /* Step 7d. */
    k++;
  }

  /* Step 8. */
  return std_Tuple_unchecked(newList);
}

// proposal-record-tuple
// Tuple.prototype.find()
function TupleFind(predicate) {
  return callContentFunction(ArrayFind, ThisTupleValue(this), predicate);
}

// proposal-record-tuple
// Tuple.prototype.findIndex()
function TupleFindIndex(predicate) {
  return callContentFunction(ArrayFindIndex, ThisTupleValue(this), predicate);
}

// proposal-record-tuple
// Tuple.prototype.forEach()
function TupleForEach(callbackfn) {
  return callContentFunction(ArrayForEach, ThisTupleValue(this), callbackfn);
}

// proposal-record-tuple
// Tuple.prototype.map()
function TupleMap(callbackfn) {
  /* Steps 1-2. */
  var list = ThisTupleValue(this);

  /* Step 3. */
  var len = TupleLength(list);

  /* Step 4. */
  if (!IsCallable(callbackfn)) {
    ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, callbackfn));
  }

  /* Step 5. */
  var newList = [];

  /* Steps 6-7. */
  var thisArg = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
  for (var k = 0; k < len; k++) {
    /* Step 7a. */
    var kValue = list[k];
    /* Step 7b. */
    var mappedValue = callContentFunction(callbackfn, thisArg, kValue, k, list);
    /* Step 7c */
    if (IsObject(mappedValue)) {
      ThrowTypeError(JSMSG_RECORD_TUPLE_NO_OBJECT);
    }
    /* Step 7d. */
    DefineDataProperty(newList, k, mappedValue);
  }

  /* Step 8. */
  return std_Tuple_unchecked(newList);
}

// proposal-record-tuple
// Tuple.prototype.reduce()
function TupleReduce(callbackfn /*, initialVal */) {
  if (ArgumentsLength() < 2) {
    return callContentFunction(ArrayReduce, ThisTupleValue(this), callbackfn);
  }
  return callContentFunction(
    ArrayReduce,
    ThisTupleValue(this),
    callbackfn,
    GetArgument(1)
  );
}

// proposal-record-tuple
// Tuple.prototype.reduceRight()
function TupleReduceRight(callbackfn /*, initialVal*/) {
  if (ArgumentsLength() < 2) {
    return callContentFunction(
      ArrayReduceRight,
      ThisTupleValue(this),
      callbackfn
    );
  }
  return callContentFunction(
    ArrayReduceRight,
    ThisTupleValue(this),
    callbackfn,
    GetArgument(1)
  );
}

// proposal-record-tuple
// Tuple.prototype.some()
function TupleSome(callbackfn) {
  return callContentFunction(ArraySome, ThisTupleValue(this), callbackfn);
}

function FlattenIntoTuple(target, source, depth) {
  /* Step 1. */
  assert(IsArray(target), "FlattenIntoTuple: target is not array");

  /* Step 2. */
  assert(IsTuple(source), "FlattenIntoTuple: source is not tuple");

  /* Step 3 not needed. */

  /* Step 4. */
  var mapperFunction = undefined;
  var thisArg = undefined;
  var mapperIsPresent = ArgumentsLength() > 3;
  if (mapperIsPresent) {
    mapperFunction = GetArgument(3);
    assert(
      IsCallable(mapperFunction) && ArgumentsLength() > 4 && depth === 1,
      "FlattenIntoTuple: mapper function must be callable, thisArg present, and depth === 1"
    );
    thisArg = GetArgument(4);
  }

  /* Step 5. */
  var sourceIndex = 0;

  /* Step 6. */
  for (var k = 0; k < source.length; k++) {
    var element = source[k];
    /* Step 6a. */
    if (mapperIsPresent) {
      /* Step 6a.i. */
      element = callContentFunction(
        mapperFunction,
        thisArg,
        element,
        sourceIndex,
        source
      );
      /* Step 6a.ii. */
      if (IsObject(element)) {
        ThrowTypeError(JSMSG_RECORD_TUPLE_NO_OBJECT);
      }
    }
    /* Step 6b. */
    if (depth > 0 && IsTuple(element)) {
      FlattenIntoTuple(target, element, depth - 1);
    } else {
      /* Step 6c.i. */
      var len = ToLength(target.length);
      /* Step 6c.ii. */
      if (len > MAX_NUMERIC_INDEX) {
        ThrowTypeError(JSMSG_TOO_LONG_ARRAY);
      }
      /* Step 6c.iii. */
      DefineDataProperty(target, len, element);
    }
    /* Step 6d. */
    sourceIndex++;
  }
}

// proposal-record-tuple
// Tuple.prototype.flat()
function TupleFlat() {
  /* Steps 1-2. */
  var list = ThisTupleValue(this);

  /* Step 3. */
  var depthNum = 1;

  /* Step 4. */
  if (ArgumentsLength() && GetArgument(0) !== undefined) {
    depthNum = ToInteger(GetArgument(0));
  }

  /* Step 5. */
  var flat = [];

  /* Step 6. */
  FlattenIntoTuple(flat, list, depthNum);

  /* Step 7. */
  return std_Tuple_unchecked(flat);
}

// proposal-record-tuple
// Tuple.prototype.flatMap()
function TupleFlatMap(mapperFunction /*, thisArg*/) {
  /* Steps 1-2. */
  var list = ThisTupleValue(this);

  /* Step 3. */
  if (ArgumentsLength() === 0) {
    ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Tuple.prototype.flatMap");
  }
  if (!IsCallable(mapperFunction)) {
    ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, mapperFunction));
  }

  /* Step 4. */
  var flat = [];

  /* Step 5. */
  var thisArg = ArgumentsLength() > 1 ? GetArgument(1) : undefined;
  FlattenIntoTuple(flat, list, 1, mapperFunction, thisArg);

  /* Step 6. */
  return std_Tuple_unchecked(flat);
}

function TupleFrom(items /*, mapFn, thisArg */) {
  /* Step 1 */
  var mapping;
  var mapfn = ArgumentsLength() < 2 ? undefined : GetArgument(1);
  var thisArg = ArgumentsLength() < 3 ? undefined : GetArgument(2);
  if (mapfn === undefined) {
    mapping = false;
  } else {
    /* Step 2 */
    if (!IsCallable(mapfn)) {
      ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, GetArgument(1)));
    }
    mapping = true;
  }

  /* Step 3 */
  var list = [];

  /* Step 4 */
  var k = 0;

  /* Step 5 */
  var usingIterator = GetMethod(items, GetBuiltinSymbol("iterator"));

  /* Step 6 */
  if (usingIterator !== undefined) {
    /* Step 6a. */
    var adder = function(value) {
      var mappedValue;
      /* Step 6a.i */
      if (mapping) {
        /* Step 6a.i.1. */
        mappedValue = callContentFunction(mapfn, thisArg, value, k);
      } else {
        /* Step 6a.ii. */
        mappedValue = value;
      }
      /* Step 6a.iii. */
      if (IsObject(mappedValue)) {
        ThrowTypeError(JSMSG_RECORD_TUPLE_NO_OBJECT);
      }
      /* Step 6a.iv. */
      DefineDataProperty(list, k, mappedValue);
      /* Step 6a.v. */
      k++;
    };
    /* Step 6b. */
    for (var nextValue of allowContentIterWith(items, usingIterator)) {
      adder(nextValue);
    }
    /* Step 6c. */
    return std_Tuple_unchecked(list);
  }
  /* Step 7 */
  /* We assume items is an array-like object */
  /* Step 8 */
  var arrayLike = ToObject(items);
  /* Step 9 */
  var len = ToLength(arrayLike.length);
  /* Step 10 */
  while (k < len) {
    /* Step 10a not necessary */
    /* Step 10b */
    var kValue = arrayLike[k];
    /* Step 10c-d */
    var mappedValue = mapping
      ? callContentFunction(mapfn, thisArg, kValue, k)
      : kValue;
    /* Step 10e */
    if (IsObject(mappedValue)) {
      ThrowTypeError(JSMSG_RECORD_TUPLE_NO_OBJECT);
    }
    /* Step 10f */
    DefineDataProperty(list, k, mappedValue);
    /* Step 10g */
    k++;
  }
  /* Step 11 */
  return std_Tuple_unchecked(list);
}