
Boost C++ Libraries - jacquesm
http://www.boost.org/
======
keeptrying
Without this set of libraries I think people would have given up coding with
c++ years ago. Simplfies everything from statecharts to pointer handling to
graph traversal. Absolute must for any serious c++ coder.

~~~
mahmud
Yes, the libraries make the language tolerable but not unique. I jumped the
C++ ship in 2001 to Lisp, while BOOST was still an infant, and from what it
looks like, my hunch was right and I didn't miss anything.

The following is a line-by-line comparison between most of the Boost libs and
their corresponding Common Lisp functionality. CL has most of them builtin,
wherever that makes sense, or as a defacto community-standard library.

<http://www.boost.org/doc/libs>

\----

Any (list-sets, keywords or all the unique objects using EQ/EQL)

Array (Arrays)

Assign (customizable assignment with SETF)

Bitmap (bidirectional maps library for C++, use hash-tables)

Bind (a crippled form of generic dispatch)

Call Traits (a crippled form of generic dispatch)

Conversion (automatic type promotion built into Lisp, there is also COERCE)

Dynamic Bitset (bit-vectors)

Enable If (#+ #- , etc. EVAL-WHEN)

Exception (yeah, a crippled subset of the condition system)

Filesystem (see pathnames)

Foreach (a crippled form of LOOP)

Format (a pale imitation of FORMAT)

Function (lambda, generic function)

Function Types ( _sigh_ )

Functional (no comment)

Functional/Hash (hash-tables with custom test function)

Fusion (A pale immitation of CL sequences)

Integer (CL has a numeric _tower_ )

Iostreams (CL streams, gray-streams, simple-streams)

Iterators (Loop, Iterate)

Lambda ( lambda :-)

Math (most built into lisp, including complex numbers)

Multi-Array (builtin)

Numeric Conversion (builtin, again, see COERCE for the manual manipulation)

Operators (all user-defined functions, macros and types are first class values
in CL)

Optional (multiple-values)

Parameter (keywords arguments, &key, &rest, &optional)

Proto (the whole of CL is a toolkit for creating DLS, specially the macro
system)

Python (CMUCL/SBCL ;-)

Random (random, random-state, builtin)

Rational (rationals are builtin and are integrated into the numeric tower)

Ref (fixes a C++ limitation, unneeded)

Regex (cl-ppcre)

Scop Exit (unwind-protect)

Serialization (cl-serialize)

Signals (condition system; make your own custom "signals", or use iolib for
unix signals)

Smart Ptr (fixes a C++ limitation, unneeded)

Static Assert (eval-when + check-type or assert)

String Algo (builtin, split-sequence from cliki)

System (builtin, implementation specific or use protable libs in cliki, also
see CFFI)

Test (FiveAM)

Thread (bordeaux-threads)

Timer (sb-timer, trivial-timeout)

Tokenizer (split-sequence)

Tuple (multiple-values, unneeded, fixes a C++ limitation)

Type Traits (unneeded by a reflective language like Lisp)

Value Initializes (Lisp has bindings)

Xpressive (yeah, cl-ppcre regexes can be written as strings or as lisp s-exp)

~~~
keeptrying
True but how many companies use lisp for anything major? If you work on wall
street like I do, and u don't want to do java then boost becomes absolutely
necessary. I hated c++ before I found boost.

