Large classes
=============

Some classes are large enough (like over 700 lines) that they might better
span over multiple files.

Ways to do this:

* Uppercase subdirectories, with the directory being the "class" and
  lowercase files inside being merged into the class (and uppercase files
  being nested classes).
    - Should there be a main file?
    - Or a nested `sources.index` file?
    - Or should `Example.slul` be the main file, and `Example/*.slul`
      be the additional contents? I.e. similar to `conf.d` directories.
* Double extensions, like `Output.expr.slul`
    - In this case, maybe there should be some kind of "includes"
      from the main file.


Tricky parts:

* How to find all files? (See above)
* Fields might be referenced before use


Related:

* Should there be a topmost class, which "utility files" extend?
    - Advantages:
        - Logical
        - Makes it possible to have global state
    - Disadvantages:
        - Global state can be a disadvantage
        - Global state won't be accesible from Uppercase/"nested" classes.
        - Unclear when the state should be initialized. Initializing
          everything at process startup is neither secure, safe or fast:
            - It could do bad stuff if given I/O or system capabilities.
            - But there's also no way to selectively limit capabilities.
            - Initialization failure = crash?
            - Slow initialization = slow process creation.
    - Due to the disadvantages, I think it might be a bad idea.