diff --git a/core/src/main/java/org/python/core/ArgParser.java b/core/src/main/java/org/python/core/ArgParser.java
index 652ed2c2e..563be1680 100644
--- a/core/src/main/java/org/python/core/ArgParser.java
+++ b/core/src/main/java/org/python/core/ArgParser.java
@@ -5,7 +5,6 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
-import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringJoiner;
@@ -25,26 +24,78 @@
* in a Python implementation, and arranges them into an array. This
* array is either created by the parser, or designated by the
* caller. The parser may therefore be used to prepare arguments for
- * a pure a Java method (or {@code MethodHandle}) accepting an
- * array, or to insert them as initial values in an interpreter
- * frame ({@code PyFrame}).
+ * a pure a Java method (or {@code MethodHandle}) that accepts an
+ * array, or to insert arguments as initial values of local
+ * variables in an an optimised interpreter frame ({@link PyFrame}).
*
* The fields of the parser that determine the acceptable numbers of
* positional arguments and their names are essentially those of a
* {@code code} object ({@link PyCode}). Defaults are provided
* values that mirror the defaults built into a {@code function}
- * object ({@code PyFunction}).
+ * object ({@link PyFunction}).
+ *
+ * Consider for example a function that in Python would have the
+ * function definition:
Note that "aa" and "kk" are at the end of the parameter
+ * names. (This is how a CPython frame is laid out.)
+ *
+ * Defaults are provided, after the parser has been constructed, as
+ * values corresponding to parameter names, when right-justified in
+ * the space to which they apply. (See diagram below.) Both the
+ * positional and keyword defaults are given by position in this
+ * formulation. The {@link #kwdefaults(Object...)} call is allowed
+ * to supply {@code null} values at positions it does not define.
+ *
+ * When parsed to an array, the layout of the argument values, in
+ * relation to fields of the parser will be as follows.
+ *
+ *
A Python {@code frame}
+ *
+ *
names
+ *
a
+ *
b
+ *
c
+ *
d
+ *
e
+ *
f
+ *
g
+ *
h
+ *
i
+ *
aa
+ *
kk
+ *
+ *
+ *
layout
+ *
posOnly
+ *
+ *
kwOnly
+ *
+ *
+ *
+ *
defaults
+ *
kwdefaults
+ *
+ *
*
* The most readable way of specifying a parser (although one that
* is a little costly to construct) is to list the parameters as
* they would be declared in Python, including the furniture that
* marks up the positional-only, keyword-only, positional varargs,
* and keyword varargs. This is the API offered by
- * {@link #fromSignature(String, String...)} but it only features in
- * unit tests.
- *
- * In practice, we construct the parser with a complex of arguments
- * derived by inspection of the method signature.
+ * {@link #fromSignature(String, String...)}. In practice we only
+ * use this in unit tests. For serious applications we construct the
+ * {@code ArgParser} with a complex of arguments derived by
+ * inspection of the Java or Python signature.
*/
class ArgParser {
@@ -76,16 +127,19 @@ class ArgParser {
* Names of parameters that could be satisfied by position or
* keyword, including the collector parameters. Elements are
* guaranteed to be interned, and not {@code null} or empty. The
- * length of this array is the number of named parameters:
+ * array must name all the parameters, of which there are:
* {@code argcount + kwonlyargcount
+ (hasVarArgs() ? 1 : 0) + (hasVarKeywords() ? 1 : 0)}
+ *
+ * It is often is longer since it suits us to re-use an array that
+ * names all the local variables of a frame.
*/
/*
- * Here and elsewhere we use the same names as the CPython code,
- * even though it tends to say "argument" when it could mean that or
- * "parameter". In comments and documentation "positional parameter"
- * means a parameter eligible to be satisfied by an argument given
- * by position.
+ * Here and elsewhere we use the same field names as the CPython
+ * code, even though it tends to say "argument" when it could mean
+ * that or "parameter". In comments and documentation
+ * "positional parameter" means a parameter eligible to be satisfied
+ * by an argument given by position.
*/
final String[] argnames;
@@ -142,40 +196,45 @@ class ArgParser {
final int varKeywordsIndex;
/**
- * Create a parser, for a named function, with defined numbers of
- * positional-only and keyword-only parameters, and naming the
- * parameters. Parameters that may only be satisfied by arguments
- * given by position need not be named. ("" is acceptable in the
- * names array.)
+ * Construct a parser for a named function, with defined numbers of
+ * positional-only and keyword-only parameters, and parameter names
+ * in an array prepared by client code.
*
- * Overflow of positional and/or keyword arguments into a
- * {@code tuple} or {@code dict} may also be allowed. For example, a
- * function that in Python would have the signature with the
- * function definition:
+ * The array of names is used in-place (not copied). The client code
+ * must therefore ensure that it cannot be modified after the parser
+ * has been constructed.
+ *
+ * The array of names may be longer than is necessary: the caller
+ * specifies how much of the array should be treated as regular
+ * parameter names, and whether zero, one or two further elements
+ * will name collectors for excess positional or keyword arguments.
+ * The rest of the elements will not be examined by the parser. The
+ * motivation for this design is to permit efficient construction
+ * when the the array of names is the local variable names in a
+ * Python {@code code} object.
+ *
+ * @param name of the function
+ * @param names of the parameters including any collectors (varargs)
+ * @param regargcount number of regular (non-collector) parameters
+ * @param posOnly number of positional-only parameters
+ * @param kwOnly number of keyword-only parameters
+ * @param varargs whether there is positional collector
+ * @param varkw whether there is a keywords collector
+ */
+ ArgParser(String name, String[] names, int regargcount, int posOnly, int kwOnly,
+ boolean varargs, boolean varkw) {
+ this(name, ScopeKind.TYPE, MethodKind.STATIC, names, regargcount, posOnly, kwOnly, varargs,
+ varkw);
+ }
+
+ /**
+ * Construct a parser from descriptive parameters that may be
+ * derived from a the annotated declarations ({@link Exposed}
+ * methods) that appear in type and module definitions written in
+ * Java. For;
Note that "aa" and "kk" are given separately, not amongst
- * the parameter names. In the parsing result array, they will be at
- * the end. (This is how a CPython frame is laid out.)
- *
- * Defaults are provided, after the parser has been constructed, as
- * values corresponding to parameter names, when right-justified in
- * the space to which they apply. (See diagram below.) Both the
- * positional and keyword defaults are given by position in this
- * formulation. The {@link #kwdefaults(Object...)} call is allowed
- * to supply {@code null} values at positions it does not define.
- *
- * When parsed to an array, the layout of the argument values, in
- * relation to fields of the parser will be as follows.
+ *
The constructor arguments should specify this layout:
*
*
A Python {@code frame}
*
@@ -197,6 +256,8 @@ class ArgParser {
*
posOnly
*
*
kwOnly
+ *
varargs
+ *
varkw
*
*
*
@@ -205,150 +266,37 @@ class ArgParser {
*
*
*
- * @param name of the function
- * @param varargs name of the positional collector or {@code null}
- * @param varkw name of the keywords collector or {@code null}
- * @param posOnly number of positional-only parameters
- * @param kwdOnly number of keyword-only parameters
- * @param names of the (non-collector) parameters
- */
- ArgParser(String name, String varargs, String varkw, int posOnly, int kwdOnly,
- String... names) {
- this(name, ScopeKind.TYPE, MethodKind.STATIC, varargs, varkw, posOnly, kwdOnly, names);
- }
-
- /**
* @param name of the function
* @param scopeKind whether module, etc.
* @param methodKind whether static, etc.
- * @param varargs name of the positional collector or {@code null}
- * @param varkw name of the keywords collector or {@code null}
- * @param posOnly number of positional-only parameters
- * @param kwdOnly number of keyword-only parameters
- * @param names of the (non-collector) parameters
- */
- ArgParser(String name, ScopeKind scopeKind, MethodKind methodKind, String varargs, String varkw,
- int posOnly, int kwdOnly, String... names) {
-
- // Name of function
- this.name = name;
- this.methodKind = methodKind;
- this.scopeKind = scopeKind;
-
- // Total parameter count *except* possible varargs, varkwargs
- int N = names.length;
- this.regargcount = N;
-
- // Fill in other cardinal points
- this.posonlyargcount = posOnly;
- this.kwonlyargcount = kwdOnly;
- this.argcount = N - kwdOnly;
-
- // There may be positional and/or keyword collectors
- this.varArgsIndex = varargs != null ? N++ : -1;
- this.varKeywordsIndex = varkw != null ? N++ : -1;
-
- // Make a new array of the names, including the collectors.
- String[] argnames = this.argnames = interned(names, N);
-
- if (varargs != null)
- argnames[varArgsIndex] = varargs.intern();
- if (varkw != null)
- argnames[varKeywordsIndex] = varkw.intern();
-
- // Check for empty names
- for (int i = posOnly; i < N; i++) {
- if (argnames[i].length() == 0) {
- // We found a "" name beyond positional only.
- throw new InterpreterError(MISPLACED_EMPTY, name, argnames.toString());
- }
- }
-
- assert argnames.length == argcount + kwonlyargcount + (hasVarArgs() ? 1 : 0)
- + (hasVarKeywords() ? 1 : 0);
- }
-
- /**
- * Construct a parser for a named function, with defined numbers of
- * positional-only and keyword-only parameters, and parameter names
- * in an array prepared by client code.
- *
- * The capabilities of this parser, are exactly the same as one
- * defined by
- * {@link #ArgParser(String, String, String, int, int, String...)}.
- * The parser in the example there may be generated by:
The differences allow the array of names to be used
- * in-place (not copied). The client code must therefore ensure that
- * it cannot be modified after the parser has been constructed.
- *
- * The array of names may be longer than is necessary: the caller
- * specifies how much of the array should be treated as regular
- * parameter names, and whether zero, one or two further elements
- * will name collectors for excess positional or keyword arguments.
- * The rest of the elements will not be examined by the parser. The
- * motivation for this design is to permit efficient construction
- * when the the array of names is the local variable names in a
- * Python {@code code} object.
- *
- * @param name of the function
- * @param varargs whether there is positional collector
- * @param varkw whether there is a keywords collector
- * @param posOnly number of positional-only parameters
- * @param kwdOnly number of keyword-only parameters
* @param names of the parameters including any collectors (varargs)
- * @param count number of regular (non-collector) parameters
- */
- ArgParser(String name, boolean varargs, boolean varkw, int posOnly, int kwdOnly, String[] names,
- int count) {
- this(name, ScopeKind.TYPE, MethodKind.STATIC, varargs, varkw, posOnly, kwdOnly, names,
- count);
- }
-
- /**
- * Construct a parser from descriptive parameters that may be
- * derived from a the annotated declarations ({@link Exposed}
- * methods) that appear in type and module definitions written in
- * Java.
- *
- * @param name of the function
- * @param scopeKind whether module, etc.
- * @param methodKind whether static, etc.
+ * @param regargcount number of regular (non-collector) parameters
+ * @param posOnly number of positional-only parameters
+ * @param kwOnly number of keyword-only parameters
* @param varargs whether there is positional collector
* @param varkw whether there is a keywords collector
- * @param posOnly number of positional-only parameters
- * @param kwdOnly number of keyword-only parameters
- * @param names of the parameters including any collectors (varargs)
- * @param count number of regular (non-collector) parameters
*/
- ArgParser(String name, ScopeKind scopeKind, MethodKind methodKind, boolean varargs,
- boolean varkw, int posOnly, int kwdOnly, String[] names, int count) {
+ ArgParser(String name, ScopeKind scopeKind, MethodKind methodKind, String[] names,
+ int regargcount, int posOnly, int kwOnly, boolean varargs, boolean varkw) {
// Name of function
this.name = name;
this.methodKind = methodKind;
this.scopeKind = scopeKind;
+ this.argnames = names;
// Total parameter count *except* possible varargs, varkwargs
- int N = Math.min(count, names.length);
+ int N = Math.min(regargcount, names.length);
this.regargcount = N;
this.posonlyargcount = posOnly;
- this.kwonlyargcount = kwdOnly;
- this.argcount = N - kwdOnly;
+ this.kwonlyargcount = kwOnly;
+ this.argcount = N - kwOnly;
// There may be positional and/or keyword collectors
this.varArgsIndex = varargs ? N++ : -1;
this.varKeywordsIndex = varkw ? N++ : -1;
- // Make a new array of the names, including the collectors.
- this.argnames = interned(names, N);
-
- assert argnames.length == argcount + kwonlyargcount + (hasVarArgs() ? 1 : 0)
+ assert argnames.length >= argcount + kwonlyargcount + (hasVarArgs() ? 1 : 0)
+ (hasVarKeywords() ? 1 : 0);
}
@@ -412,11 +360,35 @@ static ArgParser fromSignature(String name, String... decl) {
// Total parameter count *except* possible varargs, varkwargs
int N = args.size();
+
+ /*
+ * If there was no "/" or "*", all are positional arguments. This is
+ * consistent with the output of inspect.signature, where e.g.
+ * inspect.signature(exec) is (source, globals=None, locals=None,
+ * /).
+ */
if (posCount == 0) { posCount = N; }
+ // Number of regular arguments (not *, **)
+ int regArgCount = N;
+ int kwOnly = N - posCount;
+
+ // Add any *args to the names
+ if (varargs != null) {
+ args.add(varargs);
+ N++;
+ }
+
+ // Add any **kwargs to the names
+ if (varkw != null) {
+ args.add(varkw);
+ N++;
+ }
+
String[] names = N == 0 ? NO_STRINGS : args.toArray(new String[N]);
- return new ArgParser(name, ScopeKind.TYPE, MethodKind.STATIC, varargs, varkw, posOnly,
- N - posCount, names);
+
+ return new ArgParser(name, ScopeKind.TYPE, MethodKind.STATIC, names, regArgCount, posOnly,
+ kwOnly, varargs != null, varkw != null);
}
/**
@@ -522,21 +494,6 @@ String textSignature() {
return sj.toString();
}
- /**
- * Return a copy of a {@code String} array in which every element is
- * interned, in a new , possibly larger, array. We intern the
- * strings to enable the fast path in keyword argument processing.
- *
- * @param a to intern
- * @param N size of array to return
- * @return array of equivalent interned strings
- */
- private String[] interned(String[] a, int N) {
- String[] s = new String[Math.max(N, a.length)];
- for (int i = 0; i < a.length; i++) { s[i] = a[i].intern(); }
- return s;
- }
-
/**
* Return ith positional parameter name and default value if
* available. Helper to {@link #sigString()}.
@@ -633,26 +590,23 @@ Object[] parse(PyTuple args, PyDict kwargs) {
return a;
}
- private static final String MISPLACED_EMPTY =
- "Misplaced empty keyword in ArgParser spec for %s %s";
-
/**
- * Provide the positional defaults. If L values are provided, they
- * correspond to {@code arg[max-L] ... arg[max-1]}, where
- * {@code max} is the index of the first keyword-only parameter, or
- * the number of parameters if there are no keyword-only parameters.
- * The minimum number of positional arguments will then be
- * {@code max-L}.
+ * Provide the positional defaults. * The {@code ArgParser} keeps a
+ * reference to this array, so that subsequent changes to it will
+ * affect argument parsing. (Concurrent access to the array and
+ * parser is a client issue.)
+ *
+ * If L values are provided, they correspond to
+ * {@code arg[max-L] ... arg[max-1]}, where {@code max} is the index
+ * of the first keyword-only parameter, or the number of parameters
+ * if there are no keyword-only parameters. The minimum number of
+ * positional arguments will then be {@code max-L}.
*
* @param values replacement positional defaults (or {@code null})
* @return {@code this}
*/
ArgParser defaults(Object... values) {
- if (values == null || values.length == 0) {
- defaults = null;
- } else {
- defaults = Arrays.copyOf(values, values.length);
- }
+ defaults = values;
checkShape();
return this;
}
@@ -682,18 +636,17 @@ ArgParser kwdefaults(Object... values) {
}
/**
- * Provide the keyword-only defaults, perhaps as a {@code dict}.
+ * Provide the keyword-only defaults, perhaps as a {@code dict}. The
+ * {@code ArgParser} keeps a reference to this map, so that
+ * subsequent changes to it will affect argument parsing, as
+ * required for a Python {@link PyFunction function}. (Concurrent
+ * access to the mapping and parser is a client issue.)
*
* @param kwd replacement keyword defaults (or {@code null})
* @return {@code this}
*/
ArgParser kwdefaults(Map kwd) {
- if (kwd == null || kwd.isEmpty())
- kwdefaults = null;
- else {
- kwdefaults = new HashMap<>();
- kwdefaults.putAll(kwd);
- }
+ kwdefaults = kwd;
checkShape();
return this;
}
@@ -706,6 +659,7 @@ ArgParser kwdefaults(Map kwd) {
* number of parameters.
*/
private void checkShape() {
+ // XXX This may be too fussy, given that Python function is not
final int N = argcount;
final int L = defaults == null ? 0 : defaults.length;
final int K = kwonlyargcount;
@@ -781,12 +735,12 @@ void setPositionalArguments(PyTuple args) {
* positional or keyword defaults to make up the shortfall.
*
* @param stack positional and keyword arguments
- * @param start position of arguments in the array
+ * @param pos position of arguments in the array
* @param nargs number of positional arguments
*/
- void setPositionalArguments(Object[] stack, int start, int nargs) {
+ void setPositionalArguments(Object[] stack, int pos, int nargs) {
int n = Math.min(nargs, argcount);
- for (int i = 0, j = start; i < n; i++)
+ for (int i = 0, j = pos; i < n; i++)
setLocal(i, stack[j++]);
}
@@ -868,12 +822,13 @@ void setKeywordArguments(PyDict kwargs) {
* @param kwnames keywords used in the call (or {@code **kwargs})
*/
void setKeywordArguments(Object[] stack, int kwstart, String[] kwnames) {
- /*
- * Create a dictionary for the excess keyword parameters, and insert
- * it in the local variables at the proper position.
- */
+
PyDict kwdict = null;
if (varKeywordsIndex >= 0) {
+ /*
+ * Create a dictionary for the excess keyword parameters, and insert
+ * it in the local variables at the proper position.
+ */
kwdict = Py.dict();
setLocal(varKeywordsIndex, kwdict);
}
@@ -906,9 +861,6 @@ void setKeywordArguments(Object[] stack, int kwstart, String[] kwnames) {
throw new TypeError(MULTIPLE_VALUES, name, key);
}
}
-
- if (varKeywordsIndex >= 0) { setLocal(varKeywordsIndex, kwdict); }
-
}
/**
@@ -1226,8 +1178,7 @@ class ArrayFrameWrapper extends FrameWrapper {
* intended use is that {@code start = 1} allows space for a
* {@code self} reference not in the argument list. The capacity of
* the array, between the start index and the end, must be
- * sufficient to hold the parse result. The destination array must
- * be sufficient to hold the parse result and may be larger, e.g. to
+ * sufficient to hold the parse result may be larger, e.g. to
* accommodate other local variables.
*
* @param vars destination array
@@ -1259,6 +1210,12 @@ void setPositionalArguments(PyTuple argsTuple) {
int n = Math.min(argsTuple.value.length, argcount);
System.arraycopy(argsTuple.value, 0, vars, start, n);
}
+
+ @Override
+ void setPositionalArguments(Object[] stack, int pos, int nargs) {
+ int n = Math.min(nargs, argcount);
+ System.arraycopy(stack, pos, vars, start, n);
+ }
}
/**
@@ -1335,11 +1292,12 @@ void parseToFrame(FrameWrapper frame, Object[] stack, int start, int nargs, Stri
*/
// Set parameters from the positional arguments in the call.
- frame.setPositionalArguments(stack, start, nargs);
+ if (nargs > 0) { frame.setPositionalArguments(stack, start, nargs); }
// Set parameters from the keyword arguments in the call.
- if (nkwargs > 0)
+ if (varKeywordsIndex >= 0 || nkwargs > 0) {
frame.setKeywordArguments(stack, start + nargs, kwnames);
+ }
if (nargs > argcount) {
@@ -1376,7 +1334,7 @@ void parseToFrame(FrameWrapper frame, Object[] stack, int start, int nargs, Stri
*
* @param frame to populate with argument values
* @param args all arguments, positional then keyword
- * @param kwnames of keyword arguments
+ * @param kwnames of keyword arguments (or {@code null})
*/
void parseToFrame(FrameWrapper frame, Object[] args, String[] kwnames) {
@@ -1393,11 +1351,12 @@ void parseToFrame(FrameWrapper frame, Object[] args, String[] kwnames) {
*/
// Set parameters from the positional arguments in the call.
- frame.setPositionalArguments(args, 0, nargs);
+ if (nargs > 0) { frame.setPositionalArguments(args, 0, nargs); }
// Set parameters from the keyword arguments in the call.
- if (nkwargs > 0)
+ if (varKeywordsIndex >= 0 || nkwargs > 0) {
frame.setKeywordArguments(args, nargs, kwnames);
+ }
if (nargs > argcount) {
diff --git a/core/src/main/java/org/python/core/BuiltinsModule.java b/core/src/main/java/org/python/core/BuiltinsModule.java
new file mode 100644
index 000000000..87dc896fa
--- /dev/null
+++ b/core/src/main/java/org/python/core/BuiltinsModule.java
@@ -0,0 +1,185 @@
+// Copyright (c)2023 Jython Developers.
+// Licensed to PSF under a contributor agreement.
+package org.python.core;
+
+import java.lang.invoke.MethodHandles;
+import java.util.Iterator;
+
+import org.python.core.Exposed.Default;
+import org.python.core.Exposed.DocString;
+import org.python.core.Exposed.KeywordOnly;
+import org.python.core.Exposed.Name;
+import org.python.core.Exposed.PositionalCollector;
+import org.python.core.Exposed.PythonStaticMethod;
+
+/**
+ * The {@code builtins} module is definitely called "builtins".
+ *
+ * Although it is fully a module, the {@link BuiltinsModule} lives
+ * in the {@code core} package because it needs privileged access to
+ * the core implementation that extension modules do not.
+ */
+class BuiltinsModule extends JavaModule {
+
+ private static final ModuleDef DEFINITION = new ModuleDef("builtins", MethodHandles.lookup());
+
+ /** Construct an instance of the {@code builtins} module. */
+ BuiltinsModule() {
+ super(DEFINITION);
+
+ // This list is taken from CPython bltinmodule.c
+ add("None", Py.None);
+ // add("Ellipsis", Py.Ellipsis);
+ add("NotImplemented", Py.NotImplemented);
+ add("False", Py.False);
+ add("True", Py.True);
+ add("bool", PyBool.TYPE);
+ // add("memoryview", PyMemoryView.TYPE);
+ // add("bytearray", PyByteArray.TYPE);
+ add("bytes", PyBytes.TYPE);
+ // add("classmethod", PyClassMethod.TYPE);
+ // add("complex", PyComplex.TYPE);
+ add("dict", PyDict.TYPE);
+ // add("enumerate", PyEnum.TYPE);
+ // add("filter", PyFilter.TYPE);
+ add("float", PyFloat.TYPE);
+ // add("frozenset", PyFrozenSet.TYPE);
+ // add("property", PyProperty.TYPE);
+ add("int", PyLong.TYPE);
+ add("list", PyList.TYPE);
+ // add("map", PyMap.TYPE);
+ add("object", PyBaseObject.TYPE);
+ // add("range", PyRange.TYPE);
+ // add("reversed", PyReversed.TYPE);
+ // add("set", PySet.TYPE);
+ add("slice", PySlice.TYPE);
+ // add("staticmethod", PyStaticMethod.TYPE);
+ add("str", PyUnicode.TYPE);
+ // add("super", PySuper.TYPE);
+ add("tuple", PyTuple.TYPE);
+ add("type", PyType.TYPE);
+ // add("zip", PyZip.TYPE);
+ }
+
+ @PythonStaticMethod
+ @DocString("Return the absolute value of the argument.")
+ static Object abs(Object x) throws Throwable { return PyNumber.absolute(x); }
+
+ @PythonStaticMethod
+ @DocString("Return the number of items in a container.")
+ static Object len(Object v) throws Throwable { return PySequence.size(v); }
+
+ /**
+ * Implementation of {@code max()}.
+ *
+ * @param arg1 a first argument or iterable of arguments
+ * @param args contains other positional arguments
+ * @param key function
+ * @param dflt to return when iterable is empty
+ * @return {@code max} result or {@code dflt}
+ * @throws Throwable from calling {@code key} or comparison
+ */
+ @PythonStaticMethod(positionalOnly = false)
+ @DocString("Return the largest item in an iterable"
+ + " or the largest of two or more arguments.")
+ // Simplified version of max()
+ static Object max(Object arg1, @KeywordOnly @Default("None") Object key,
+ @Name("default") @Default("None") Object dflt, @PositionalCollector PyTuple args)
+ throws Throwable {
+ // @PositionalCollector has to be last.
+ return minmax(arg1, args, key, dflt, Comparison.GT);
+ }
+
+ /**
+ * Implementation of {@code min()}.
+ *
+ * @param arg1 a first argument or iterable of arguments
+ * @param args contains other positional arguments
+ * @param key function
+ * @param dflt to return when iterable is empty
+ * @return {@code min} result or {@code dflt}
+ * @throws Throwable from calling {@code key} or comparison
+ */
+ @PythonStaticMethod(positionalOnly = false)
+ @DocString("Return the smallest item in an iterable"
+ + " or the smallest of two or more arguments.")
+ // Simplified version of min()
+ static Object min(Object arg1, @KeywordOnly @Default("None") Object key,
+ @Name("default") @Default("None") Object dflt, @PositionalCollector PyTuple args)
+ throws Throwable {
+ // @PositionalCollector has to be last.
+ return minmax(arg1, args, key, dflt, Comparison.LT);
+ }
+
+ /**
+ * Implementation of both
+ * {@link #min(Object, Object, Object, PyTuple) min()} and
+ * {@link #max(Object, Object, Object, PyTuple) max()}.
+ *
+ * @param arg1 a first argument or iterable of arguments
+ * @param args contains other positional arguments
+ *
+ * @param key function
+ * @param dflt to return when iterable is empty
+ * @param op {@code LT} for {@code min} and {@code GT} for
+ * {@code max}.
+ * @return min or max result as appropriate
+ * @throws Throwable from calling {@code op} or {@code key}
+ */
+ // Compare CPython min_max in Python/bltinmodule.c
+ private static Object minmax(Object arg1, PyTuple args, Object key, Object dflt, Comparison op)
+ throws Throwable {
+
+ int n = args.size();
+ Object result;
+ Iterator