Invocations in classic Python:

  f(1, 2, 3)      # positional

  f(1, 2)         # positional with defaults

  f(1, 2, c=3)    # keywords

  f(1, c=3)       # keywords with defaults

  f(1, 2, 3, 4)   # extra positional arguments

  f(1, 2, 3, d=4) # extra keyword arguments

  f(1, 2, *args)  # positional bundles (possibly with defaults)

  f(1, 2, **kw)   # keyword bundles (possibly with defaults)

  Note that f is never fixed before run-time in Python.

Comparison to invocations in C:

  f(1, 2, 3)      # positional, f known at compile-time

  f(1, 2, 3)      # positional, f is appropriate function pointer

                  # ie. (*f)(A, B, C)

Least expensive cases (positional plus defaults):

  f(1, 2, 3)      # put arguments in frame

                  # if f is not known, add arguments vs. parameters check

  f(1, 2)         # to handle defaults, introduce default "filling" where

                  # not enough arguments are given

                  # if f is not known, this is obviously done at run-time

More expensive cases (keywords plus defaults):

  f(1, 2, c=3)    # prepare frame using parameter details

                  # (provided c is a known parameter)

                  # if f is not known, this is obviously done at run-time

  f(1, c=3)       # as with the previous case, with default "filling" done

                  # where not enough arguments are given

                  # if f is not known, this is obviously done at run-time

                  # but with all defaults copied in before keywords are

                  # assigned (since their positions and thus the positions

                  # of missing parameters cannot be known)

Awkward cases (extra arguments):

  f(1, 2, 3, 4)   # put arguments in frame

                  # if f is not known, add arguments vs. parameters check;

                  # to handle superfluous arguments, make a suitable object

                  # and fill it with all such arguments

Very awkward cases:

  f(1, 2, 3, d=4) # extra keyword arguments

  f(1, 2, *args)  # positional bundles (possibly with defaults)

  f(1, 2, **kw)   # keyword bundles (possibly with defaults)

  These cases require additional structures to be created, potentially at

  run-time.

Methods vs. functions:

  f(obj, 1, 2)    # f known as function at compile-time:

                  #   f(obj, 1, 2)

                  # f known as C.m at compile-time:

                  #   m(obj "assert isinstance(obj, C)", 1, 2)

                  # f not known at compile-time:

                  #   f(<context>, obj, 1, 2) for instance-accessed methods

                  #   f(obj, 1, 2) for class-accessed methods

                  #   f(obj, 1, 2) for functions

  (Could either have universal context usage even for functions, which would

   ignore them, or attempt to remove contexts when functions are called.)

Argument lists for functions:

  f(obj, 1, 2)    # f known as function at compile-time

    f   -> f (context is null)

    obj -> argument #1

    1   -> argument #2

    2   -> argument #3

Argument lists for methods:

  f(obj, 1, 2)    # f known as C.m at compile-time (context is C)

    f   -> C.m (context is class C)

    obj -> argument #1 (must be tested against the context)

    1   -> argument #2

    2   -> argument #3

Argument lists for methods:

  f(obj, 1, 2)    # f known as C.m at compile-time (context is an instance)

    f   -> C.m

        -> context is argument #1

    obj -> argument #2

    1   -> argument #3

    2   -> argument #4

Argument lists for classes:

  f(obj, 1, 2)    # f known as C at compile-time

    f   -> instantiator of C

        -> (argument #1 reserved for a new instance made by the instantiator)

    obj -> argument #2

    1   -> argument #3

    2   -> argument #4

  The new instance must be provided as the result of the call.

Argument lists for unknown callables:

  f(obj, 1, 2)    # f not known at compile-time

    f   -> f

        -> load context for argument #1

    obj -> argument #2

    1   -> argument #3

    2   -> argument #4

  Then, check the context and shift the frame if necessary:

    f is class: no change

    <context> is class:

      (<context>, obj, 1, 2) -> (obj, 1, 2)

    <context> is instance: no change

Argument lists in instantiators:

  f(obj, 1, 2)    # f not known at compile-time

    f   -> C.__new__ (known and called at run-time)

        -> load context for argument #1

    obj -> argument #2

    1   -> argument #3

    2   -> argument #4

  f(obj, 1, 2)    # f known at compile-time

    f   -> C.__new__ (known and called at run-time)

        -> argument #1 left blank

    obj -> argument #2

    1   -> argument #3

    2   -> argument #4

Frame re-use in instantiators:

  Need to call C.__init__(<instance>, obj, 1, 2), preferably with the existing

  frame:

    *** -> instance overwrites argument #1

    obj -> argument #2

    1   -> argument #3

    2   -> argument #4

  Then jump without switching frames.

  If no context argument (or blank argument) were provided, a new frame would

  need to be allocated and filled with a new instance and all remaining

  arguments from the current frame.

Defaults for unknown callables:

  f(obj)          # f not known at compile-time

    f   -> f

        -> load context for argument #1

    obj -> argument #2

  Then, check the number of arguments and the availability of defaults against

  the details provided by the callable's structure.

Checking defaults for unknown callables:

  Approach #1 - pre-fill defaults, add arguments, check frame

  Approach #2 - add arguments, add defaults while checking frame

Dynamic functions:

  def f(x):

    def g(y=x):         # dynamic: y depends on non-constant value

      ...

    def h(y=2):         # static: y depends on constant value

      ...

  def f(x):

    g = lambda y=x: ... # dynamic: y depends on non-constant value

    h = lambda y=2: ... # static: y depends on constant value

Representation of dynamic functions:

  f = lambda x, y=nonconst: ...

  def f(x, y=nonconst):

    ...

  Defines instance with method:

    def <lambda>(<context>, x, y=nonconst):

      ...

    def f(<context>, x, y=nonconst):

      ...

  Where default is attribute #1.

  f(obj)          # f not known at compile-time

    f   -> f

        -> load context for argument #1 (f, since an instance is referenced)

    obj -> argument #2

Functions as methods:

  def f(x, y, z): ...

  class C:

      m = f

  c = C()

  ...

  f(obj, 1, 2)    # no restrictions on obj

  obj.m(1, 2)     # f(obj, 1, 2)

  C.m(obj, 1, 2)  # f(obj "assert isinstance(obj, C)", 1, 2)

Context propagation:

  fn = C.m        # has context C

  fn(obj, 1, 2)   # non-instance context -> explicit context required

                  # must perform isinstance(obj, C)

  fn = c.m        # table entry for m on C -> replace context

                  # gives context c

  fn(1, 2)        # instance context -> no explicit context required

                  # context c inserted in call

Star parameters are a convenience:

  max(1, 2, 3)    # call to max(*args) where args == (1, 2, 3)

  max((1, 2, 3))  # but why not just do this instead?

  One motivation: avoid explicitly making sequences.

  Opportunity: avoid expensive dynamic allocation of sequences?

Star parameters, approach #1:

  Make a sequence to hold the extra arguments, either in the caller for known

  callables or in the function itself.

  Such a sequence would need allocating and its contents copying from the

  stack.

Star parameters, approach #2:

  Keep the extra arguments in the stack.

  Access to the star parameter would need to consider assignment to other

  things and "escape situations" for the parameter:

    def f(*args):

        return args # need to allocate and return the sequence

  Access to elements of the extra argument sequence would behave slightly

  differently to normal sequences, but this could be identified at

  compile-time.

Star parameters, known callables and sequences, approach #1:

  g(1, 2, 3, 4)   # g known as function g(a, *args) at compile-time

    g   -> don't get any context information

    1   -> argument #1

    2   -> reference to sequence containing arguments #2, #3, #4

Star parameters, known callables and sequences, approach #2:

  g(1, 2, 3, 4)   # g known as function g(a, *args) at compile-time

    g   -> don't get any context information

    1   -> argument #1

    2   -> argument #2

    3   -> argument #3

    4   -> argument #4

Star parameters, unknown callables, both approach #1 and #2:

  g(1, 2, 3, 4)   # g not known at compile-time

    g   -> g

        -> load context for argument #1

    1   -> argument #2

    2   -> argument #3

    3   -> argument #4

    4   -> argument #5

  Then, check the context and shift the frame if necessary (described above).

  If g has a star parameter - g(a, *args) - then...

  Approach #1 - move arguments #3, #4, #5 (or shifted to #2, #3, #4) into a

                sequence, adding a reference to the sequence in their place

  Approach #2 - maintain special access rules to arguments #3, #4, #5 (perhaps

                shifted to #2, #3, #4) as a C-like array

Tradeoffs for star parameter approaches:

  Approach #1 - potentially costly at run-time as arguments need moving around,

                but the arguments would behave normally in functions

  Approach #2 - need to track usage of the star parameter and to possibly copy

                its contents if assigned, as well as providing special access

                mechanisms, but the invocation procedure would be simpler