// a[0] = 1, a[1] = 1, and compute a[n+1] = a[n-1] + a[n]
auto fib = recurrence!("a[n-1] + a[n-2]")(1, 1);
// print the first 10 Fibonacci numbers
foreach (e; take(10, fib)) { writeln(e); }
// print the first 10 factorials
foreach (e; take(10, recurrence!("a[n-1] * n")(1))) { writeln(e); }

FR>// print the first 10 factorials
FR>foreach (e; take(10, recurrence!("a[n-1] * n")(1))) { writeln(e); }
FR>

// print the first 10 factorials
foreach (e; take(10, recurrence!(a[n-1] * n)(1))) { writeln(e); }

shared int flag;

E>// print the first 10 factorials
E>foreach (e; take(10, recurrence!(a[n-1] * n)(1))) { writeln(e); }
E>

foreach(e; take(10, recurrence!("a[n - 2] + a[n - 1] ")(1, 1))) {writeln(e);}

foreach(e; take(10, recurrence!((a, n){return a[n - 2] + a[n - 1];})(1, 1))) {writeln(e);}

If a DLL declares any nonlocal data or object as __declspec( thread ), it can cause a protection fault if dynamically loaded. After the DLL is loaded with LoadLibrary, it causes system failure whenever the code references the nonlocal __declspec( thread ) data. Because the global variable space for a thread is allocated at run time, the size of this space is based on a calculation of the requirements of the application plus the requirements of all the DLLs that are statically linked. When you use LoadLibrary, there is no way to extend this space to allow for the thread local variables declared with __declspec( thread ). Use the TLS APIs, such as TlsAlloc, in your DLL to allocate TLS if the DLL might be loaded with LoadLibrary.

I know what I want to say. I can say it in C++, I can say it in Ada, I can say it in Scheme. I adapt myself to the language, but the essence of what I am trying to say is language independent. So far, C++ is the best language I've discovered to say what I want to say.

The most important technical idea is that of generic algorithms, which are a means of
providing functionality in a way that abstracts away from details of representation and basic
operations.

In the generic programming approach we use generic indexing by a generic formal
type Coordinate. Coordinate is instantiated to type Natural for vectors; for linked
lists, however, cells themselves can serve as Coordinate values. A generic Find can thus
return a Coordinate value that can be used to reference the located element directly
The intended semantics for Coordinate is that there are functions
* Initial from Sequence to Coordinate;
* Next from Coordinate to Coordinate;
* Is End from Sequence x Coordinate to Boolean, and
* Ref from Sequence x Coordinate to a third type Element

We stress that the algorithms at this level are derived by abstraction from concrete, efficient
algorithms. As an example of algorithmic abstraction, consider the task of choosing
and implementing a sorting algorithm for linked list data structures. The merge sort algorithm
can be used and, if properly implemented, provides one of the most efficient sorting
algorithms for linked lists. Ordinarily one might program this algorithm directly in terms
of whatever pointer and record field access operations are provided in the programming
language. Instead, however, one can abstract away a concrete representation and express
the algorithm in terms of the smallest possible number of generic operations. In this case,
we essentially need just three operations: Next and Set_Next for accessing the next cell in a
list, and Is-End for detecting the end of a list. For a particular representation of linked lists,
one then obtains the corresponding version of a merge sorting algorithm by instantiating
the generic access operations to be subprograms that access that representation.

Thus in Ada one programs generic algorithms in a generic package whose parameters
are a small number of types and access operations-e. g.,

generic
  type Cell is private;
  with function Next (S : Cell) return Cell ;
  with procedure Set_Next (S1 , S2 : Cell) ;
  with function Is_End(S : Cell) return Boolean;
  with function Copy_Cell(Sl , S2 : Cell) return Cell ;
package Linked_List_Algorithms i s

The subprograms in the package are algorithms such as Merge and Sort that are efficient
when Next, Set_Next , etc., are instantiated with constant time operations.