Are implicit classes a good idea, and how should they be implemented?

Want to have:
* short class names when referenced in parameter/variable/field definitions
  (i.e. not long namespace names)
    - it could of course be a convention to have short directory names.
    - but not all people would follow the convention, and that would hurt
      the ecosystem as a whole (decreased readability).
* greppability, e.g. `grep -x "class SomeClass"`
  (but then the record/class distinction becomes a problem!)
* minimal indentation, i.e. not per class if everything in the file belongs
  to the same class.
* ability to quickly create some small utility program, or to quickly
  add some helper/wrapper/builder class.

Can use directories for small utility classes, e.g. `utils`.
This way, one can avoid cluttering the main directory.

Could support some multi-file "container" format, in order to support
single-file usage, e.g. for scripts.


Solution 1
----------

UpperCase filename for implicit class, lowercase for file with utility
code / plain functions.

* Maybe not intuitive/obvious for new users?


Solution 2
----------

Implicitly create class if there's a constructor (or if it's abstract / an
interface, if abstract classes/interface are to be supported)

Implicitly turn functions into methods if they access fields,
or plain functions ("static methods") if not.
(This requires that accessed fields are declared in the function declaration)

Could require the "class"/file identifier to be specified when calling
a plain function, for example:

    same = FileUtils.compare_files "a.txt" "b.txt"