Python Interoperability

[benjamin-robbins]

As a Python Programmer, I want to be able to utilize native Chapel code directly from a Python program so that I can take advantage of parallelism.

Acceptance Criteria: Write Python program. Write desired Chapel code. Decorate python function to use Chapel Code. Run python application, Chapel compiler is silently invoked, Chapel code runs and returns as needed.

[lydia-duncan]

Features of Chapel that could/should be supported (in no particular order). I'll probably split them out into their own issue but I wanted to have a centralized gathering point as well.

Types to support as arguments/return types for functions

• [ ] Primitive types
  • [ ] ints
  • [ ] default and explicit sizes
  • [ ] bools
  • [ ] uint
  • [ ] real
  • [ ] imag
  • [ ] complex
• [ ] Enums
• [ ] Arrays (domains and ranges probably cannot cross the divide, or can they?)
• [ ] Strings
• [ ] Atomics/syncs/singles
• [ ] Arbitrary Classes/Records
• [ ] Tuples
• [ ] Locales?
• [ ] Unions?

Function details beyond specific types

• [ ] How should intents be handled?
• [ ] Is it possible to support generic functions?
• [ ] what about default values for arguments?
  • [ ] Are there limits to expressions that can be used as default values? (conditional/loop expressions, reductions, query expressions)
• [ ] where clauses?
  • [ ] Are there limits to expressions that can be used in where clauses? (conditional/loop expressions, reductions)
• [ ] Can iterators be called directly?
• [ ] Notion of param/type/const, both for arguments and to return
• [ ] functions that take a variable number of arguments?
• [ ] functions without parentheses?

Design questions:

• [ ] How should parallelism be handled? Should the caller from Python expect it to have completed prior to returning the function called, or should it be allowed to persist through the lifetime of the program?
• [ ] How should locality be handled? Should it be possible for a single node Python program to call into a distributed setting? If this is allowed, should the nodes accessed be released when the call returns or persist through the lifetime of the program?
• [ ] Should interoperability be limited to calling functions, or should any exported type or variable be accessible?
• [ ] Should Python be able to call Chapel library functions directly?