intelligent compiler that interprets a .squiggle file ending in expression as a partial of one binding

[quinn-dougherty]

Currently, we have a divide between .squiggle files which culminate in expressions and partials which are .squiggle files that exist only to export assignments/bindings.

I think ideally squiggle would say "If the file you give me ends in an expression x that is not a record, and I'm being asked to use it in the context of being a partial, then I append the single element record {x: x} to the end of the file automatically".

Really ending a file with a single element record is exactly like export default ... in javascript, right? Though we want a file to be multiple-use; we want it to render the culminating expression when loaded up as a top-level file, but we want it to export that single expression when imported.

Also to keep in mind: for python file x.py, I can hide code that will run in the context of python x.py but will not run in the context of import x (through if __name__ == "__main__":). That sort of thing may be useful as well.

[umuro]

Note: A new compiler interface is on the way

• Partial concept will die
• There will be a separate getBindings related to the the running source. This will work regardless of the end expression of the source code.
• Later there will be events to inspect all local bindings in the code.

Highlights:
-- setSourceCode(project, sourceId, text)
-- evaluate(project, sourceId) => returns the result
-- continuesFromTo(project, source1, source2) // source2 continues source1. A source can be continued by many other sources.
-- getBindings(project, sourceId) => returns the bindings
-- Due to multi pass compilation, all source codes will be in a single project

• Continuing on source will not be via bindings. There will be a continuation for each project item. Bindings will be only for visualization and debugging. Imports will be handled in this way also (importing is just setting source code).
  Summary:
• I will be able to dump out more information without hacking the functional language semantics.
• The language will also behave like all multi source code languages (.e.g rescript)
• Bindings will be available always.

I am switching to a simple project structure instead of source evaluation because I will continue further futures with multi pass compilation. Because supporting compilation related information in runtime is becoming a mess.

When I release this interface, we won't be able to merge it to develop. Instead, other components will need to be upgraded in the same branch.