intForm(Main) added to execute web pages in
interactive mode.
HtmlElem removed from datatype HTML.
curry2prolog/curry2prolog removed (since everything is now done in the Prolog implementation), new PAKCS option -m added and old option -i PROG F changed to -i PROG -m F
parser removed from distribution (parser/parsecurry moved to bin/.parsecurry)
Prelude.failed made external
GUI.getCursorPosition added
pakcs-v2.0.1-bbe3454dece2ba6f0ad680fbb6bed8bf5c09b24f/GITINSTALL.txt 0000664 0000000 0000000 00000002124 13234315711 0023440 0 ustar 00root root 0000000 0000000 PAKCS Repository
================
Installation Instructions for the GIT Repository
------------------------------------------------
If you want to install the up-to-date version of PAKCS
from the developer's repository, you have to clone the
[git repository](https://git.ps.informatik.uni-kiel.de/curry/pakcs),
e.g., by the shell command
git clone https://git.ps.informatik.uni-kiel.de/curry/pakcs.git
This creates a new directory `pakcs` containing the current version.
Go into this directory by
cd pakcs
and execute
git submodule init
git submodule update
in order to obtain further files managed by git, i.e.,
the Curry system libraries shared by PAKCS and KiCS2.
Then, each future update can be obtained by the executing
git pull
git submodule update
Now you can install the complete system by the command
make
similar to the standard
[PAKCS installation instructions](http://www.informatik.uni-kiel.de/~pakcs/download/INSTALL.html).
-------------------------------------------------------------
Contact: [Michael Hanus](http://www.informatik.uni-kiel.de/~mh/)
pakcs-v2.0.1-bbe3454dece2ba6f0ad680fbb6bed8bf5c09b24f/INSTALL.txt 0000664 0000000 0000000 00000014701 13234315711 0023100 0 ustar 00root root 0000000 0000000 PAKCS: The Portland Aachen Kiel Curry System
============================================
Installation Instructions
-------------------------
The current version of PAKCS runs on Unix-based platforms
and has been developed and tested under Linux (Debian/Ubuntu).
However, it should also run on similar platforms like Mac OS X or SunOS.
If you want to install and run the complete system
on your computer, you need the following software:
* [SICStus-Prolog](http://www.sics.se/sicstus.html)
(Version 4.0 or higher) (recommended)
* [SWI-Prolog](http://www.swi-prolog.org)
(if you do not have SICStus-Prolog, but then the execution is less
efficient and some libraries (e.g., Boolean constraint solvers) are
not available.
How to generate and install the PAKCS kernel:
---------------------------------------------
1. Go into the main directory of PAKCS (which contains
this file). In the following, we assume that `pakcshome`
is the name of this directory.
2. If you have the executables `sicstus` (for SICStus-Prolog)
or `swipl` (for SWI-Prolog) in your path,
execute "`make`" which installs PAKCS.
The environment variables `SICSTUSDIR` or `SWIPROLOG` are automatically
set to appropriate values. These values are also stored in the
home directory in file `.pakcsinitrc` so that they are available
for future installations of new versions of PAKCS.
3. Otherwise, modify in the shell script "`pakcshome/pakcsinitrc`"
the definition of the variables `SICSTUSDIR` or `SWIPROLOG`
according to your local installation, or pass these values to `make`,
e.g., by
make SICSTUSDIR=/opt/sicstus
or
make SWIPROLOG=/usr/bin/swipl
If both variables are undefined, the PAKCS compiler system
cannot be installed.
4. If you install PAKCS from the source code distribution, you need also the
[Glasgow Haskell Compiler](http://www.haskell.org/ghc/)
(i.e., the executable "`ghc`" must be in your path)
to compile the front end of PAKCS.
5. Now, install PAKCS by "`make`" (if you have already an older
installation of PAKCS, do "`make clean`" before).
6. Add the directory "`pakcshome/bin`" to your path, e.g., by the command
export PATH=pakcshome/bin:$PATH
in the `bash`.
If you do no want to have the specific version number of PAKCS
included in your path, you can set a symbolic link like
ln -s pakcs-pakcs/bin into your path.
Now you can start the PAKCS compiler system via the command "`pakcs`".
7. If you want, you can also execute "`make libdoc`"
to generate a local version of the documentation of all system libraries
by the CurryDoc tool into the directory "`pakcshome/lib/CDOC`".
However, this is only necessary if you want to work offline since
you can also access the documentation online at
HTML.addClass added.
/tmp/PAKCS... renamed to
/tmp/Curry... (since they are also used by KiCS2).
assertEqual
instead of assertEqual since the type Assertion
is abstract.
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.
.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).
.curry/pakcs.
IOError and operations
userError, ioError, showError,
and catch added for exception handling in the I/O monad.
negateFloat added to avoid an error
when reading negative numbers.
target parameter of
generateCompactFlatCurryFile
must contain the real name of the target file (i.e., with a
potential suffix ".fcy").
answerEncText added.
tagOf, elemsOf,
textOf added.
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)).
.pakcs.
Prolog code of the run-time system slightly changed to avoid
problems with SWI-Prolog Version 5.7.
renderTaggedTuple added and
type of wuiInForm and wuiWithErrorForm
slightly changed.
tools/ui).
IO.hSeek
cannot be used.
runT has been changed
so that it also returns transaction errors.HtmlElem removed from datatype HTML.
intForm(Main) added to execute web pages in
interactive mode.
cleancurry before you compile your Curry
application again!
pakcs/bin/.pakcs_variables and the setting
of the option "standalone" in .paksrc.
f 0 = 0
f x = 1
--import Mod" but
are now written in the standard syntax as "import Mod".
This section tells you where to find the distribution of PAKCS, what to download and what is needed on the host computer. If you are reading this file, you may have already downloaded and installed the PAKCS distribution. Thus, this section may not be of interest to you.
Q: Where can I run PAKCS?
A: PAKCS runs under Linux, Solaris, and Mac OS X.
Q: What software do I need to install to run PAKCS?
A: The host computer must have installed SICStus Prolog or SWI-Prolog.
Q: Where can I download PAKCS?
A: There is an official site at the University of Kiel. There is also a mirror site at Portland State.
Q: What should I download to run PAKCS?
A: Look for "Download PAKCS" in a PAKCS website. The distribution consists of a gzipped tar archive of about 3 - 5 Mb (depending on your architecture). It includes all you need to run PAKCS plus several libraries, documentation and examples.
Q: Do I need a license to run PAKCS?
A: No. However, you may need a license for both Solaris and SICStus Prolog.
Q: How do I install PAKCS?
A: Open the downloaded archive using the Unix command tar zxf ~/pakcs_....tar.gz. This will create a directory called pakcs. Follow the instructions contained in the file INSTALL.html in this directory.
This section tells you how to execute your first Curry program. It assumes a successful installation of PAKCS. PAKCS is installed by a script that also tests the correctness of the installation.
- Verify that the compiler/interpreter and other tools are in your PATH environment variable. Issue the which command to the shell prompt as shown below:
[antoy@redstar test]$ which pakcs ~/local/pakcs/bin/pakcs [antoy@redstar test]$You should see a line such as ~/local/pakcs/bin/pakcs. The exact content is not important. If you see a line containing no pakcs in ... you must extend your PATH environment variable. Many details depend on your computer system and you should ask them to your system administrator.- Create a file which name extension "curry" for example first.curry. The file contains the following single line of code:
test n = take n [0,2..]- Start the compiler/interpreter as follows:
[antoy@redstar test]$ pakcsSeveral lines are output, including the PAKCS logo till you seeType ":h" for help Prelude>"Prelude>" is the prompt you get when no file has been loaded yet. As suggested, you may try typing ":h" for a list of available commands, or you can load the Curry program you created.- Load your Curry program with the command ":l" followed by a file name, i.e. "first" in this example. It is not necessary to type the file extension ".curry":
Prelude> :l firstSeveral line of informative messages are printed. No error or warning message should be generated for the above program. The prompt is changed to "first>", the name of the program you have just loaded.- Execute some function of your program. In this example, only one function by the name of test has been defined. This function take an argument which should be a non-negative integer. When the argument is n, the list of the first n (starting from 0) even number is printed. E.g.:
first> test 8 Result: [0,2,4,6,8,10,12,14] ?The program is now waiting for your input. If you enter a semicolon followed by a carriage return, the program attempts to find another result for your input. In this case, there are no other results, thus you get the message "No more solutions." and the prompt. If you enter carriage return, you get immediately the prompt.- At this point you can execute again some function of your program, load another file or quit by entering the command ":q".
This section contains links to both resource coming with the distribution and external resources for learning Curry and using PAKCS.This document precisely describes the Curry programming language. It is appropriate as a reference for all the technical aspects of the language, but it may be difficult for the beginner.PAKCS User ManualThis document describes the use of the PAKCS compiler/interpreter and the differences between the implementation and the Curry Report.TutorialThis document, still incomplete at the time of this writing, is an introduction to the Curry programming language suitable for the beginner.LibrariesThe PAKCS distribution comes with a collection of libraries for application programming. The documentation of these libraries is generated by the currydoc tool, which is optionally executed during the installation. It allows a developer to navigate the interfaces of the libraries.ExamplesThis document is an index to a collection of small examples contained in the standard distribution. They may be useful to get a sense of the Curry features and how they can be used.PAKCS Homepage
This site contains the current and latest distributions, links to several resources, information about developers and sponsors, etc.Curry HomepageThis site is the starting point of information about the programming language Curry of which PAKCS is the most advanced compiler/interpreter.CurryWikiThis site contains more information about Curry, tools for Curry, alternative implementations etc.FLP PatternsThis site contains a collection of Functional Logic Patterns, advanced programming solutions to recurring non-trivial problems. It may be interesting to more experienced developers.PNW 2001 ACM ContextCurry implementations of the set of problems of the Pacific NW Regional selection of the 2001 ACM programming context.CurryBrowserThis site describes CurryBrowser, a generic analysis environment for Curry implemented in Curry. CurryBrowser supports browsing through the program code of all modules of an application written in Curry. Each module can be shown in different formats (e.g., source code, interface, intermediate code) and, inside each module, various properties of functions defined in this module can be analyzed. This tool is already included in the distribution of PAKCS.CurryTestThis site describes CurryTest, a simple tool to write and run repeatable unit tests. This tool is already included in the distribution of PAKCS.COOSyThis site describes COOSy, the Curry Object Observation System, a lightweight approach for debugging Curry programs by observations. This tool is already included in the distribution of PAKCS.