This document summarizes the changes since the previous release of the FC++ library.

Changes from v1.2.1 to v1.3

Improvements

The run-time performance of the library has been drastically improved. This has all been done "under the hood"; the interface to the library has barely changed. The main sources for the improvements are
- intrusive reference counting
- new implementation of Lists
- new techniques for "reusing" functoids in the prelude implementation
The library now works with both g++2.95.2 and g++3.0. It should also work with any other standard-conforming C++ compiler. See this page for details.
There are now many more example files.

New additions

The Fun3 class has finally been implemented. Like Fun2 it supports automatic currying.
Class IRef (the intrusive version of Ref) has been added.
ListIterator now supports operator->.
The flag FCPP_DEBUG turns on extra run-time checking so that if you try to head() or tail() an empty list, an exception (of type fcpp_exception) is thrown. Without the flag, there is no run-time check (and the code fails un-gracefully).
The flag FCPP_SAFE_LIST adds a destructor to the List class which ensures that list nodes are destroyed iteratively. The reference-counting in list nodes (Caches) works recursively, and as a result, can blow the stack for large lists. In other words,
```
   {
      List<int> l = enumFromTo(1,200000);
      length(l);   // force evaluation of the list (actually create nodes)
   }  // Boom!  Recursion with a call-depth of 200000.
```
is likely to "blow up" unless the FCPP_SAFE_LIST flag is set. Setting this flag degrades the overall performance of lists, however. In order to ensure that a specific instance of a list doesn't blow up, you can always just iteratively destroy that list, as in
```
   {
      List<int> l = enumFromTo(1,200000);
      length(l);   // force evaluation of the list (actually create nodes)
      while(l) l = tail(l);   // iteratively destroys list
   }  // no problem here
```

Changes

The library no longer has a
```
using namespace fcpp;
```
at the end of prelude.h. As a result, you should add this yourself to your .cc files that use the library.
The signature of cat has changed slightly. The first parameter must be a list, but the second parameter can be either a list or a function that returns a list. (It used to be that both parameters could be either lists or functions.)
Due to the new list implementation, the signatures of many of the functions in the prelude have changed. However, this should break very little client code. See this page for details.
The Sigs of Plus, Minus, etc., now better reflect the true signatures of those functoids.

Removals

OneElement (one_element) has been removed. You should use cons(x,NIL) instead.
Nil<T> has been removed. You should just use NIL instead, unless type inference fails, in which case you can always use List<T>().

Obscure flags

The flag FCPP_LEAK turns off the reference counting in the IRef class. As a result, the application leaks away memory (but might run faster).
The flag FCPP_TEMPLATE_ENUM makes enumFrom() and enumFromTo() be template functoids rather than just functoids that work on ints. They really probably should be template functoids, however g++2.95.2 seems to generate slow code for them when they templated, for no obvious reason. (g++3 generates fast code regardless of whether the functoids are templated or not.)
The flag FCPP_OOI_DEBUG turns on some debugging output for the creation of global objects (that may be initialized before main()). This helped us debug order-of-initialization errors.
The prelude functions are written with performance in mind, using OddLists, Reusers, and iteration. The old implementations of many of the functions are still there, enclosed in #ifdef FCPP_SIMPLE_LISTs. We've kept the old implementations in the file mostly for instructional value (they illustrate the simplest ways to create functoids, and also help show the changes necessary to create optimized versions of functoids).

Changes from v1.2 to v1.2.1

The library now compiles with the "-pedantic -ansi" options for g++, which means it will probably compile with more other compilers now, too. The previous release had a number of "typename" problems; C++ requires the "typename" keyword to appear in lots of places inside templates.

Changes from v1.1 to v1.2

New additions

Automatic currying. Now (practically) all functoids are curryable by default. For example,
```
   minus(3,2);   // yields 1
   minus(3);     // yields a new function f, where f(x) = 3-x
   minus(3,_);   // same as above
   minus(_,2);   // yields a new function f, where f(x) = x-2
```
This is accomplished by the CurryableN classes, which serve as wrappers around normal functions. The function makeCurryable() turns an uncurryable function into an automatically curryable version. See http://www.cs.umass.edu/~yannis/fc++/currying.html for more info.
Namespaces. Now the library is in namespace fcpp. However, bugs in the g++2.95.2 compiler force us to keep part of the library in the global namespace. If you have a working compiler, use the compiler option -DFCPP_USE_NAMESPACE to have the whole library be in the namespace. There's a
```
   using namespace fcpp;
```
at the bottom of prelude.h, which dumps it all into the global namespace anyway. We've done that for backwards compatibility (you can drop in the new library and your old code should still work without changes), but feel free to remove it (we certainly will, in a future revision).
There is now an implicit conversion from direct functoids to indirect functoids (FunNs). For example,
```
   Fun1<int,int,int> f          = fcpp::plus;
   Fun1<double,double,double> g = fcpp::plus;
```
both "do the right thing".
A number of "holes" in the library have been filled in; now practically all of the general functions/classes (like ptr_to_fun(), monomorphizeN(), CurryableN, etc.) work for all sets of functions with 0-3 arguments. (Previous versions of FC++ had spotty support.)
This file: we plan to keep track of changes between versions from now on, and put the changes in the distribution.

Changes (from v1.0 to v1.1)

The List class has been completely re-implemented. The old version had a number of problems (the major ones being that (1) it was too eager (not lazy enough) in a number of cases, and (2) that functions like cons had un-intuitive interfaces) that have now been solved. In our limited tests, the new List seems to perform comparably with the old, but let us know if you notice a speed difference.
List::WrappedType has been renamed to List::ElementType. The new name makes more sense, especially in papers/tutorials.
Header dependencies have been minimized; the library should only suck in the headers it needs now, which means faster compile-times.
A number of minor bugs have been fixed throughout the library.
The function list_until has been renamed listUntil (consistent with naming convention of other list functions).

FC++ homepage