Summary
-------

A _collection literal_ is a syntactic expression form that evaluates to
an aggregate type, such as an array, `List`, or `Map`.  Many languages
support collection literals.  A `List` literal in Java might look like:

    List<Integer> list = #[ 1, 2, 3 ];

Collection literals were proposed for Project Coin and naturally
complement the library additions in Java SE 8.  Collection literals can
reduce boilerplate code, improve performance, and increase safety.


Goals
-----

This is a _research JEP_.  The sole goal of this JEP is to explore the
design space sufficiently to be able to propose a feature JEP (or
recommend that the feature not be pursued.)


Non-Goals
---------

It is not a goal of this research JEP to produce a production-ready
implementation or specification.


Success Metrics
---------------

This research JEP will be judged successful if it produces a design that
we wish to move forward to a feature JEP, or else certainty that we do
not wish to proceed with this feature.


Motivation
----------

Collection literals can increase programmer productivity, code
readability, and code safety.


Description
-----------

Being able to initialize arrays, lists, sets, and maps with a compact
expression offers many benefits, including:

  - Clarity (smaller, simpler code);
  - Dynamic footprint (the size is known, so a space-efficient
    implementation can be chosen); and
  - Safety (the resulting object can be made immutable).

While a minimal solution that works for arrays, `List`s, and `Map`s would
be "trivial", we would like to explore beyond such a simple-minded
solution, leveraging target typing and which might enable an extensible
set of types to exploit this feature.