GF 3.6 Release Notes
June 2014

==Installation==

See the [download page http://www.grammaticalframework.org/download/index.html].

==What's new==

Over 1300 changes have been pushed to the source repository since the release
of GF 3.5 in August 2013.

Closed [issues http://code.google.com/p/grammatical-framework/issues/list]:
 25, 30, 41, 57, 60, 61, 68, 80, 81, 82.

===GF compiler and run-time library===

====New features and notable changes====

- The default character encoding in grammar files has been changed from
  Latin-1 to UTF-8. Also, alternate character encodings should now be specified
  as ``--# -coding=``//enc//, instead of ``flags coding=``//enc//.
  See the separate document
  [GF character encoding changes encoding-change.html] for more details.
- Record update: in record objects (but not types) of form ``r ** s``, the values assigned
  in ``s`` now overwrite those in ``r``. In previous versions, record extensions with
  overlapping assignments in ``r`` and ``s`` were not supported, and their behaviour was
  unpredictable.
- The PGF file format has changed in minor but backward incompatible ways.
  GF can still read the old format, thanks to a backward compatibility
  module. The C run-time system supports only the new format. Old PGF files
  can be converted to the new format by loading them in the GF shell and
  writing out a new PGF file with the ``pg -pgf`` command.
- The PGF run-time Haskell library includes some new modules, e.g.
 ``PGF.Lexing`` which contains lexing and unlexing functions, and
  ``PGF2``, which is a binding to the C run-time system. The latter is included
  only if GF is configured with ``-fc-runtime``, which is not the default,
  since the C run-time system still has to be compiled and installed
  separately before installing GF. The binary packages for GF 3.6 available
  from the download page will include C run-time support.
- ``nonExist`` now exists. It can be used in concrete syntax to mark
  non-existing morphological forms.
- Token gluing: ``BIND`` and ``SOFT_BIND`` can be used in concrete syntax to
  mark that the surrounding tokens should not be separated by space.
% - Unicode characters in identifiers [...] (not documented, not tested)


====Bug fixes and minor changes====

- Nonlinear patterns (i.e., patterns where the same variable appears more than
  once) in concrete syntax are now detected and reported as errors.
  (Section C.4.13 in the GF book states that patterns must be
  linear.)
- A pattern matching bug which prevented variables in patterns to be bound to
  table values has been fixed.
- A bug with local variable name shadowing has been fixed.
- Type checking fixes: correction of
  subtyping check for ``Ints n<=Ints m`` and contravariance in table types.
- The refresh pass
% (and thus the command line option --dump-refresh)
  had become obsolete and has been removed.
- The old partial evaluator
  (and thus the command line options ``--new-comp`` and ``--old-comp``)
  has been removed.
- A missing rewrite rule has been added to the partial evaluator. It
  can significantly reduce the compilation time for certain grammars.
- Some additional datestamp checks have been added to ``gf -make`` to avoid
  recreating a PGF file when an uptodate PGF file already exists.
- The ``--output-dir`` option now applies also to PGF files.


===Resource Grammar Library===

- New languages in the Resource Grammar Library: Estonian
  (see the [updated synopsis ../lib/doc/synopsis.html]).
- Grammars and dictionaries for wide coverage translation
  ([source ../lib/src/translator/]).
- Bug fixes and some new inflection paradigms in many languages.
% - [...]


===GF Cloud services===

- There is a preliminary new [Wide Coverage Translation Demo http://cloud.grammaticalframework.org/wc.html] web app. The same wide coverage translation
  method has also been added to the
  [Simple Translation Tool http://cloud.grammaticalframework.org/translator/].
- PGF web service API:
  - the ``lookupmorpho`` request has been added to lookup the morphological
    analysis of a word.
  - Requests like ``parse`` and ``translate`` that parse text input now
    accept a ``lexer`` parameter to apply a lexer to the input text before
    parsing. The lexer can be ``text``, ``code`` or ``mixed``.
  - Requests like ``linearize`` and ``translate`` that produce
    linearizations now accept an ``unlexer`` parameter to apply an unlexer to the
    linearizations. The unlexer can be ``text``, ``code`` or ``mixed``.
  - Preliminary new requests to access the C run-time system have been added:
    - ``c-parse``, ``c-linearize``, ``c-translate``, ``c-lookupmorpho``,
      ``c-grammar``. These work in the same way as the corresponding requests
      without the ``c-`` prefix. Since the ``c-parse`` and ``c-translate`` can
      produce very many (even infinitely many) results when used with large
      ambiguous grammars, using the ``limit`` parameter to restrict number of
      results, e.g. ``limit=10``, is recommended.
    - ``c-wordforword``: this works as ``c-translate`` but does a
      word-for-word lookup to create a (potentially very low quality)
      translation that can be used if all else fails.