PAKCS Release Notes

# PAKCS: Release Notes (up to Version 1.10.1)

### Release notes for PAKCS Version 1.10.1 (October 5, 2012)

Changes to version 1.10.0:

- `HTML.addClass` added.
- Auxiliary files `/tmp/PAKCS...` renamed to `/tmp/Curry...` (since they are also used by KiCS2).
- Compiler Makefile changed to make it compatible with newer versions (6.x) of SWI-Prolog.

### Release notes for PAKCS Version 1.10.0 (June 6, 2012)

Changes to version 1.9.2:

- New front end (compatible with newer GHC version) added.
- Distribution does not longer contain the backends TasteCurry and Curry2Java.
- Assertions used in the tool currytest are now operations rather than constructors, i.e., one has to write `assertEqual` instead of `assertEqual` since the type `Assertion` is abstract.
- Library `CLPFD`: new reifiable constraints for negation, conjunction, disjunction added.
- `ReadShowTerm.readsQTerm` also reads unqualified constructor (if they are unique) for compatibility with other Curry implementations that show terms always without qualifiers.

### Release notes for PAKCS Version 1.9.2 (April 30, 2011)

Changes to version 1.9.1:

- Bug fix for the translation of as-patterns with non-deterministic arguments (sharing was missing in previous releases).
- Intermediate representations of Curry programs (files with suffixes .fint/.fcy/.acy) are now stored in a specific directory `.curry` so that they are not directly visible. The libraries FlatCurry, FlatCurryRead, AbstractCurry etc are adapted to deal with these new file names. In order to be independent on the specific names of intermediate files, application programs should use the corresponding operations to obtain the name of an intermediate file from the program name (see FlatCurry.flatCurryFileName, FlatCurry.flatCurryIntName, AbstractCurry.abstracCurryFileName).
Generated Prolog files (.pl/.po) are now stored in specific directory `.curry/pakcs`.
- Non-ASCII characters removed from source files.
- Printing of free variables in results improved. They are now printed in the form "_a", "_b" etc instead of "_9435", "_4325".
- Prelude: type `IOError` and operations `userError`, `ioError`, `showError`, and `catch` added for exception handling in the I/O monad.
- Prelude: `negateFloat` added to avoid an error when reading negative numbers.
- Library List: inits, tails, isInfixOf added
- Library CompactFlatCurry: The `target` parameter of `generateCompactFlatCurryFile` must contain the real name of the target file (i.e., with a potential suffix ".fcy").
- Library Profile: profileTime/profileSpace measures execution of an I/O action, profileTimeNF/profileSpaceNF added to measure the execution of a normal form computation.
- Libraries Constraint, GlobalVariable, SetFunctions, KeyDatabaseSQLite added.
- Library HTML: operation `answerEncText` added.
- Library XML: selector operations `tagOf`, `elemsOf`, `textOf` added.
- Implementation of tool currytest changed from ports to sockets for the internal communication.
- Tool erd2curry improved: String attributes where null values are allowed are no longer represented as type `Maybe String` but as type `String` where a null value corresponds to the empty string. This representation simplifies many application programs. Furthermore, the type specifying cardinalities in relationship has been slightly changed to make it more readable. For instance, (Range 0 Nothing) is now written as (Beetween 0 Infinite), and (Range 0 (Just 2)) is now written as (Beetween 0 (Max 2)).

### Release notes for PAKCS Version 1.9.1 (May 9, 2009)

Changes to version 1.9.0:

- Method to ask for more solutions slightly changed to options yes/no/all.
- PAKCS commands ":modules" and ":programs" added (to show all currently loaded modules and all available programs), command ":dir" removed.
- PAKCS command ":analyze igraph" removed (the same functionality is available in the CurryBrowser).
Generated Prolog files (.pl/.po) are now stored in specific directory `.pakcs`. Prolog code of the run-time system slightly changed to avoid problems with SWI-Prolog Version 5.7.
- Handling of global environment variables for PAKCS changed in order to make it compatible with recent releases of SICStus Prolog. Environment variables SICSTUS and SPLD (usually stored in $HOME/.pakcsinitrc) replaced by SICSTUSDIR.
- PAKCS is called with the readline wrapper "rlwrap" (if it is available on the local machine) to support line editing or history functionality.
- Exit codes of PAKCS: PAKCS terminates with a non-zero exit code if the evaluation of the last goal had a run-time error (exit code 1) or terminated with "No more solutions" (exit code 2).
- Library AbstractCurry: constructor CmtFunc added to represent functions with documentation comments.
- Library CLPR is now available for SWI-Prolog (Vers. 5.6). To support it, the code generator has been slightly modified which requires the recompilation of existing Curry programs.
- Library Directory: removeFile, removeDirectory, renameFile, renameDirectory,setWorkingDirectory added.
- Library System: Implementation of (un)setEnv changed from primitive to an implementation using library Global.
- Library Traveral added.
- Library WUI: `renderTaggedTuple` added and type of `wuiInForm` and `wuiWithErrorForm` slightly changed.
- Tool erd2curry: all generated operations contain documentation comments.
- Libraries for declarative user interface programming added (in `tools/ui`).

### Release notes for PAKCS Version 1.9.0 (December 14, 2007)

Changes to version 1.8.1:

- Implementation made compatible to SICStus Prolog 4.0.2. However, the implementation of PAKCS with SICStus Prolog 4.0.2 is still incomplete due to missing features in this Prolog version. In particular, the library CLPB and the operation `IO.hSeek` cannot be used.
- The internal Prolog representation of characters has been changed. Therefore, all compiled Prolog files (programs, databases) must be recompiled. Usually, this is automatically done when Curry programs are compiled with the new PAKCS version.
- Memory leaks due to unnecessary creation of choice points removed.
- Bug in failure printing (option +consfail) fixed.

### Release notes for PAKCS Version 1.8.1 (October 21, 2007)

Changes to version 1.8.0:

- Implementation made compatible to SICStus Prolog 4.0 (however, there are problems due to bugs in this Prolog version).
- Parser reports better shadowing warnings.
- parsecurry: Option "-q" should now work (which is the default when reading Curry programs with the libraries FlatCurry or AbstractCurry).
- Command line options of some tools (parsecurry, currydoc, currytest) changed. For compatibility, the old parameters are still accepted.
- Library Database improved with better reporting of transaction errors. For this purpose, the type of `runT` has been changed so that it also returns transaction errors.
- Library Global added.
- Library IOExts: connectToSocket removed (use Socket.connectToSocket), choiceStreamOrMsgs removed (use IO.hWaitForInputsOrMsg).
- Library Socket: listenOn is now rigid in its argument, listenOnFresh added, socketListen removed.
- Library System: evalTime/evalSpace moved into library Profile.
- Library NamedSocket added.
- Library HTML: implementation improved and communication changed from library Ports to library NamedSocket.
- Tool `erd2curry` to compile entity-relationship diagrams into Curry programs added.

### Release notes for PAKCS Version 1.8.0 (March 13, 2007)

Changes to version 1.7.3:

- Code generation changed: eta-expansion (i.e., translation of all equations to first-order rules) removed. This has some consequences to the implementation of I/O actions that has been changed accordingly.
- Implementation of dynamic web pages (library HTML) changed. The new implementation starts a server process for the first invocation of a web page. The server keeps the event handlers for this page so that the communication with the central event handler server (as in version 1.7.3) is no longer necessary.
- Libraries Database and KeyDatabase added as a replacement for Dynamic and KeyDB with a better interface for transaction-safe programming.

### Release notes for PAKCS Version 1.7.3 (February 27, 2007)

Changes to version 1.7.2:

- COOSy Observation Debugger added to PAKCS distribution (executable by new command ":coosy").
- External function interface improved. The PAKCS compiler now generates a standard interface for external functions that do not suspend so that an external function of arity N can be simply implemented by a Prolog predicate of arity (N+1). The old raw interface is still used if the entry name specified in the corresponding "*.prim_c2p" file is suffixed by "[raw]".
- PAKCS program option "-i" added to load a Curry program and evaluate an initialization operation (typically an I/O operation) directly after loading.
- Option "+consfail" extended to report complete failure traces and examine them in an interactive mode.
- Prelude: operation "getSomeValue" added to extract a single value from a nondeterministic computation.
- Tool "currycreatemake" to create simple makefiles for a Curry application added.
- Library CLPB (Boolean constraint solver) added.
- Library CompactFlatCurry for reducing the size of Curry applications added.
- Libraries Distribution, PropertyFile, and ReadNumeric added.
- Library System: functions getLoadPath, getLoadPathForFile, findFileInLoadPath moved into new library Distribution.
- Library CLPFD: all_different and scalar_product renamed.
- Library Directory: createDirectory, removeFile added, getModificationTime returns a ClockTime instead of an Int
- Library Dynamic: checking of type restrictions on dynamic predicates extended (e.g., it is not allowed to store handles or IORefs in dynamic predicates).
- Library FileGoodies: findFileInPath renamed to lookupFileInPath.
- Library GUI: appendTaggedValue replaced by appendStyledValue which offers more flexibility. addRegionStyle and removeRegionStyle added.
- Library HTML.curry: updated for conformity with XHTML, in particular, constructor `HtmlElem` removed from datatype `HTML`. `intForm(Main)` added to execute web pages in interactive mode.
- Library HTML_Parser: renamed to HtmlParser and updated for conformity with XHTML, i.e., reading extended for XHTML documents.
- Library Mail for sending emails added.
- Library System: setEnviron,unsetEnviron added, Date and getDate removed (since library Time contains equivalent functionality).
- Library Time: internal representation of ClockTime changed, functions for transforming to and from ClockTime modified in order to distinguish between UTC and local time values.
- currybrowser: User interface redesigned so that it contains less frames.
- currytest: Handling of syntax errors in test programs added.

### Release notes for PAKCS Version 1.7.2 (March 29, 2006)

Changes to version 1.7.0:

- Name of standard prelude changed from "prelude" into "Prelude". Important note: due to this name change, for all Curry applications the old code must be deleted and then recompiled, i.e., perform `cleancurry` before you compile your Curry application again!
- Changing of maximal arity of tuples enabled (see installation instructions).
- Option "+consfail" added for reporting errors due to non-exhaustive pattern definitions.
- Bug fix in front end w.r.t. polymorphic expression in list comprehensions.
- Front end extended to support function patterns (see pakcs/examples/testFuncPattern.curry for an example and more information).
- Front end extended to allow for transformations on FlatCurry files after parsing and before compiling in order to integrate optimization phases (see pakcs/parser/README for details).
- Usage of old front end no longer supported.
- Prelude extended with functions like $!!, $#, $##, compare. Comparison operations defined as polymorphic on ground data terms.
- Library Array added.
- Library CLPFD: made available for SWI-Prolog-based implementation.
- Library FlatCurryTools renamed into FlatCurryShow.
- Library FlatCurryXML modified (implementation simplified by using XmlConv).
- Library FlatCurryGoodies added.
- Library Float: comparison operations removed (since the corresponding prelude operations can now be used).
- Library GUI: controlling of GUIs via stream handlers added. Type of reconfiguration options changed from (WidgetRef,ConfItem) into ReconfigureItem in order to support dynamic addition of new stream handlers.
- Library HTML extended with concept of HTML pages and parameters (extension by Marco Comini).
- Library IO extended with direct access operation (hSeek) on files.
- Library KeyDB extended.
- Library Ports: openStdInOutPort removed (replaced by operations in library IO).
- Library Socket added.
- Library WUI added.
- Library XmlConv added.

### Release notes for PAKCS Version 1.7.0 (December 5, 2005)

Changes to version 1.6.1:

- Free variable mode changed: as a default, free variables in initial goals must now be declared (by let-free or where-free). The declaration is not necessary of the option "+free" is set.
- New front end (adapted from the Muenster Curry Compiler by Wolfang Lux) added. Since the front end is implemented in Haskell, Java is no longer necessary to execute PAKCS (however, the Glasgow Haskell Compiler is necessary for developers to compile the front end).
- Implementation of Curry2Prolog modified so that it can be also executed with SWI-Prolog.
- Library HTML: implementation of dynamic web pages based on a new client/server architecture. Now, a local server stores all event handlers and previous input fields so that they are no longer encoded in the web page (which could cause security problems).
- Library AllSolutions: getFirstSolution renamed into getOneSolution, getOneValue added, getAllValues moved into prelude.
- Documentation currydoc: option "onlyindex" added (used for generation of library documentation).

### Release notes for PAKCS Version 1.6.1 (September 30, 2005)

Changes to version 1.5.0:

- Possibility to suppress front-end parsing and Prolog loading messages added (see .pakcsrc).
- Format of FlatCurry and .fcy files slightly changed w.r.t. datatype CombType. This change requires the deletion and recompilation of all .fcy files!
- Separate compilation introduced.
- New concept to connect primitive operations to Curry2Prolog (see curry2prolog/external.pl).
- Curry2Prolog, library FlatCurry, and corresponding tools extended to support recursive let's.
- PAKCS command ":eval" eliminated since the same functionality is contained in the new browser tool.
- New browser tool added (see PAKCS command ":browse").
- New library GUI for programming graphical user interfaces added.
- Libary HTML: Passing of logical variables to event handlers supported. Image buttons, redirections, and headed tables added. Event handler expressions are not passed in web pages but stored on the server side via a server process (see library HtmlServer).
- Primitive prelude.seq does no longer suspend on free variables.
- New primitives prelude.ensureNotFree and prelude.ensureSpine for suspension on free variables added.
- Defaults for "eval" annotation changed to "flex".
- Library Ports improved: new operations waitAndConnectPort and connectPortWait added which supports waiting until an external port has been registered. Furthermore, there are new operations newObject, newNamedObject, and runNamedServer to create a new port and run a server object on it. It is recommended to use these operations instead of openPort/openNamedPort since the latter are more primitive and might not be supported in the future.
- New improved mode for (X)Emacs added that supports also the use of PAKCS in an Emacs buffer (see tools/emacs/README).
- Parameters for "makecurrycgi" changed in order to simplify its use for small web scripts.
- Tool currytest improved so that it can be also used with a GUI.
- New tool "dataToXml" to generate conversion functions between data types and XML representations.
- New tool "addtypes" for adding type signatures to source programs.
- Library "Tk" improved so that event handlers can also be reconfigured.
- Libraries CategorizedHtmlList, Dequeue, Dynamic added.
- Libraries TermDB and Term removed (the functionality of Term is available in ReadShowTerm, and TermDB is no longer supported by Sicstus-Prolog).
- Module lib/meta/CurryStringClassifier added and all libraries for meta-programming moved to lib/meta
- prelude: (?) added.
- Module lib/Combinatorial: (!) and allSubsets omitted.
- Module lib/HTML extended.
- Support for generating standalone executables with Sicstus-Prolog added. This requires the definition of the Sicstus-Prolog application builder as variable SPLD in `pakcs/bin/.pakcs_variables` and the setting of the option "standalone" in .paksrc.
- New FlatCurry representation introduced. The corresponding intermediate representation files are now suffixed with ".fcy" (instead of ".flc).
- FlatTools.writeFLC and FlatCurryTools.writeFLC are omitted. Use Flat2Fcy.writeFCY instead and change file suffix into ".fcy".
- Warnings for non-adjacent function rules are provided.
- Handling of external functions in the compiler improved.
- Configuration file pakcsrc added. In order to use it, one can copy it as ".paksrc" into the home directory and change some values according to the local preferences.
- Module system is now fully supported.
- New module lib/IO with functions for reading and writing files.
- New module lib/Sort with functions for sorting and string comparisons.
- Module lib/Tk: Resizing improved by using grid structures, configuration options TkFill* added and composition options TkExpand* removed since they are no longer necessary.
- Modules lib/SetRBT and lib/TableRBT: Interface has changed: the ordering predicate must be supplied only for the empty set and table and not for all insert operations. (The old versions are still available as SetRBT0 and TableRBT0 but will be deleted in the future).
- New tools "importgraph" and "importcalls" added which are accessible via the new PAKCS command ":analyze".
- prelude.readFile does no longer support reading of URLs (use URL.getContentsOfUrl)
- Library "Term" renamed to "ReadShowTerm" and extended.
- New printer for FlatCurry interface files added.
- Module lib/FlatCurry(Tools) with an improved representation of FlatCurry programs added.
- Command "runcurry" omitted since it is no longer necessary because the saved state is always patched (by bin/.makesavedstate) with necessary environment information.
- New modules FlatCurry/FlatCurryTools with improved representation of FlatCurry programs added.
- Representation of characters in compiled Prolog files changed so that all old programs must be recompiled.
- Implementation of sharing improved so that some memory leaks in tail recursive programs are eliminated.
- Functions AbsCurry.readCurryFile and Flat.readFlatCurryFile changed so that the suffix (".acy" or ".flc") must be contained in the filename for these functions.
- Front-end extended to deal with qualified identifers. As a consequence, function composition "." must be surrounded by blanks (which is conform with the language specification but was not necessary up to now).
- -compact option added for producing more compact code.

### Release notes for PAKCS Version 1.5.0 (May 25, 2003)

Changes to version 1.4.5:

- In rules with multiple guards all guards must be of type "Bool".
- Case expressions are now supported.
- Let bindings of variables supported in top-level of curry2prolog.
- Library Flat supports reading of FlatCurry programs with and without implicit parsing.
- Translation of literate into standard programs integrated into the parser (this speeds up the entire parsing process).
- Handling of external port communication changed:
  - constructors are prefixed by their module name
  - external ports can be also send as data
  - syntax of sent messages changed to standard Curry syntax
- unsafePerformIO and trace moved from prelude into library Unsafe

### Release notes for PAKCS Version 1.4.5 (November 7, 2002)

Changes to version 1.4.1:

- Long command formats (e.g., ":load" instead of ":l") added.
- Parser bugfix: parser can now read files ending with local declarations.
- Options "-l" and "-c" added to pakcs/curry2prolog
- Compiler issues a warning in case of non-trivial overlapping rules, i.e., rules that have different patterns in overlapping cases, like in

          f 0 = 0
          f x = 1

- Debug mode moved from command (":d") to an option (":set +debug") and debug commands changed into options.
- Header information included in generated Prolog files so that the system can check the compiler options and can automatically recompile and reload programs when options (printfail/debug) are changed.
- Option ":set printfail" included in PAKCS. This option adds special code during compilation so that failures during the reduction of expressions are shown.
- Change in frontend: internal names have now the form "<module_name>.<local_name>" instead of "<module_name>_<local_name>". The previous name caused problems when the module name contained underscores.
- Modules HTML and HTML_Parser: all tags and attribute names are now in lowercase letters.
- curry2prolog backend changed so that characters are no longer equivalent to integers but are represented as a distinguished data type at run time (i.e., characters are represented as one-letter atoms in Prolog). This change requires the recompilation of all compiled Curry programs!

### Release notes for PAKCS Version 1.4.1 (September 17, 2002)

Changes to version 1.4:

- Defaults for flex/rigid functions changed according to new Curry report (i.e., functions of type IO are rigid, all other flexible).
- Names of functions in modules CLPR and CLPFD changed to make them more conform.
- Commands in interactive environment changed (command ":set..." introduced).
- Restrictions on free variables in initial goals introduced (must be start with an uppercase letter; this default can be relaxed by the command ":set -free").
- Command "pakcs" is equivalent to "curry2prolog" and no longer starts implicitly the server

### Release notes for PAKCS Version 1.4 (May 23, 2002)

This version contains the following changes (apart from the usual bug fixes) in comparison to the previous version 1.3:

- Module system added (not yet fully implemented; see the manual for a description of the current restrictions). As a consequence of this addition, import declarations are no longer written as "`--import Mod`" but are now written in the standard syntax as "`import Mod`".
- CurryTest tool added (see manual for a description).
- System modules "Combinatorial", "Integer", and "Random" added (thanks to Sergio Antoy).
- CurryDoc documentation tool added (see manual for a description).
- Internal implementation of ports changed so that all port communication is now done over one Unix socket which can be specified by the environment variable PAKCS_SOCKET. This is useful for distributed Curry programs running behind a firewall based on simple socket number filtering.
- System module "DaVinci" added. This module supports the visualization of graphs by the daVinci graph drawing tool.
- System modules "SetRBT" and "TableRBT" added. These modules contains efficient implementation of sets and tables (finite maps) by red-black trees. SetRBT also contains a efficient generic sort function "sortRBT" based on red-black trees.
- System module "TermDB" for storing data terms in an external persistent database added.
- System module "Directory" for accessing the directory structure added.
- Prelude extended with some useful functions (catchFail, unsafePerformIO, trace,...).
- XML support for FlatCurry programs added, i.e., Flat.readFlatCurry and curry2prolog can now read programs in XML format (see here for a more detailed description of this format) so that curry2prolog could also be used as a back end for other functional logic languages that can be translated into the FlatCurry format. In addition, the pakcs/curry2prolog environment offers a new command ":xml" for translating Curry programs into this XML format.
- Interface generator added: The pakcs/curry2prolog environment offers a new command ":if" for showing the interface of a Curry module, i.e., the data types and the types of all top-level functions defined in this module. Since this command can be also applied to system libraries, it is useful for getting a quick overview of the functionality offered by a library.
- Partial evaluator integrated: The pakcs/curry2prolog environment offers a new command ":peval" for the partial evaluation of Curry programs (compare manual).
- Structure of FlatCurry programs modified (system module Flat).
- Reading of programs with Flat.readFlatCurry and curry2prolog modified so that it is now possible to read .flc files where there is no corresponding source file.
- Structure of .flc changed so that they are compatible with the definition of FlatCurry. Due to this change, it is necessary to recompile all existing Curry programs (i.e., by "cleancurry" and compiling again).

### Release notes for PAKCS Version 1.3 (December 15, 2000)

This version contains the following changes (apart from the usual bug fixes) in comparison to the previous version 1.2:

- The definition of ports (datatype `Port` and its associated operations for distributed programming) has been moved from the prelude into the new system module `Ports.lcurry`. Thus, all applications using ports must now have the import declaration "`--import Ports`".
- The functionality of ports has been extended: ports can now be named by arbitrary symbolic names (instead of socket numbers as in the previous version). The name resolution is done by a specific Curry port name server (which is actually implemented in Curry).
- The Curry2Prolog compiler is based on a new intermediate language (*.flc files instead of *.flat files) which is closer to the definition of FlatCurry in the corresponding system module. The precise syntax of the new intermediate language is described in the PAKCS manual.
- The system library (a short description of all modules can be found here) has been extended with new modules for parsing HTML documents and tools for supporting meta-programming based on FlatCurry.

Back to Homepage of PAKCS