[FRIAM] Mathematical Search and Regular Expressions

[Marcus G. Daniels]

I'd say there are several dimensions to consider..

1) Assignments or not:  Are there side effects to operators?  Is it 
possible to directly store to memory locations or bind values to variables?

2) Combinators or not:  Does application of a function involve named 
parameters, or are values curried into combinations of functions?

3) A presence of a typing system.  To what extent can compiler can 
deduce correct usage of an object from context (without a lot of fuss 
declaring things)

Lisp variants are mostly functional, with dialects like DSSSL Scheme 
being purely functional and dialects like R and Common Lisp generally 
facilitating it but not insisting on it.   I mention Lisp because one of 
the first and most famous symbolic math packages, Macsyma is written in 
Lisp, as are simpler systems like JACAL.

http://en.wikipedia.org/wiki/Macsyma
http://maxima.sourceforge.net  (Open source fork -- incidentally it can 
export TeX)
http://www-swiss.ai.mit.edu/~jaffer/JACAL.html

As I understand it, J has #1 and #2, but not much of #3.   Haskell has 
all three.   I think it safe to say that Haskell gets the most attention 
from academic researchers, but there are perhaps other functional 
languages that get broader or more intensive use in practice, e.g. ML, 
OCaml, Erlang.

In most languages it is possible to implement function curries (#2) and 
make programs easier to follow or even faster (e.g. when iterating over 
set of things only passing the parameters that per the iteration and not 
all of the values they need to calculate each value).  In GNU C, for 
example, there are nested functions, and packages like 
http://www.haible.de/bruno/documentation/ffcall/trampoline/trampoline.html 
will do the job.  Here's an example of how it can be done in Scheme:  
http://www.engr.uconn.edu/~jeffm/Papers/curry.html

However, for the purposes of expressing equations/calculations in a 
clear way, and making it easy to reason about those forms (either for a 
computer/compiler or a human), it's useful to pull them all together in 
a unified language as Haskell does (as do others like Mercury).    And 
from a purely practical point of view, no more nasty stuff like memory 
alias identification as is needed in C, etc.