The static type system of Clean
guarantees that runtime type errors cannot occur.
The terse syntax makes that you have a clear view over
what is actually happening in this function.
the classes in Clean
are more general than the notion of classes in most object oriented languages.
This reads the
increment of item i, is that item with the field quantity set to the increment of that field from the argument record.
To be member of the same class, datatypes need not have any relation. It is sufficient that the appropriate functions are defined for that datatype.
In Clean
a class is a family of functions with the same name. The difference between these family members is the type processed.
In this example the generators are separated by a semicolon, this implies that all possible combinations of elements from the generators are considered.
The scope of local definitions is the function alternative where they are
defined. Local definitions are used to limit the scope of definitions, to share a value or to name an expression.
In general a list
comprehension yields the list of values indicated between [ and \\. These values are computed for each element of the generators (between // and |), that obeys the condition between | and ]
A guard is a boolean expression that can be inserted between the patterns of a function alternative and the symbol =. The symbol |
separates the patterns and the guard. The alternative is only applied when the guards yields True.
An infix operator is in fact just an ordinary function of two arguments that is written between its arguments:
x^n.
Each program in Clean
computes the value of the expression Start.

4Expand

Functional programming - Wikipedia, the free encyclopedia

Tags: programming on 2007-10-09 and saved by4 people -All Annotations (0) -About

more fromen.wikipedia.org

A Case of the MUMPS - Worse Than Failure

Tags: funny, programming on 2007-09-28 -All Annotations (0) -About

more fromworsethanfailure.com

Metaclass programming in Python

Tags: programming, python on 2007-09-19 and saved by3 people -All Annotations (0) -About

more fromwww.ibm.com

17Expand

Revenge of the Nerds

Tags: branch, programming, python on 2007-04-29 and saved by8 people -All Annotations (0) -About

more fromwww.paulgraham.com

Starts talking about industry language "standards" that are safe from a business perspective, compared with cutting edge languages like Python that are much more concise/powerful, and atract the smartest people, since they're often learning the language on their own time.

Then it does into some depth about the lisp language. Has lots of links to articles that look interesting.

post by ratbeard on 2007-04-29

The shape of a program
should reflect only the problem it needs to solve.
Any other regularity in the code is a sign, to me at
least, that I'm using abstractions that aren't powerful
enough-- often that I'm generating by hand the
expansions of some macro that I need to write
Greenspun's Tenth
Rule:

Any sufficiently
complicated C or Fortran program contains an ad hoc
informally-specified bug-ridden slow implementation of half of
Common Lisp.
if he chooses
something that is "industry best practice," and the company
loses, he can't be blamed. He didn't choose, the industry did.
Design your product to please
the users.
This is why we even hear about new
languages like Perl and Python. We're not hearing about these
languages because people are using them to write Windows
apps, but because people are using them on servers.
I can think of three problems that could arise from using
less common languages. Your programs might not work well with
programs written in other languages. You might have fewer
libraries at your disposal. And you might have trouble
hiring programmers.
the biggest win
for languages like Lisp is at the other end of
the spectrum, where you need to write sophisticated
programs to solve hard problems in the face of fierce competition
Most programming probably consists of writing
little glue programs, and for
little glue programs you
can use any language that you're already
familiar with and that has good libraries for whatever you
need to do.
Lisp looks strange not so much because
it has a strange syntax as because it has no syntax;
you express programs directly in the parse trees that
get built behind the scenes when other languages are
parsed, and these trees are made
of lists, which are Lisp data structures.
Lisp and Fortran were the trunks of two separate evolutionary trees,
one rooted in math and one rooted in machine architecture.
The right thing to compare Lisp
to is not 1950s hardware, but, say, the Quicksort
algorithm, which was discovered in 1960 and is still
the fastest general-purpose sort.
the Lisp that we actually ended up with was based
on something separate that he did as a
theoretical exercise-- an effort
to define a more convenient alternative to the Turing Machine.
f you look at these languages in order, Java, Perl, Python,
you notice an interesting pattern. At least, you notice this
pattern if you are a Lisp hacker. Each one is progressively
more like Lisp.
The pointy-haired boss believes that all
programming languages are pretty much equivalent.
What
he's thinking is something like this. Java is a standard.
I know it must be, because I read about it in the press all the time.
Since it is a standard, I won't get in trouble for using it.
But if languages vary, he suddenly
has to solve two simultaneous equations, trying to find
an optimal balance between two things he knows nothing
about: the relative suitability of the twenty or so leading
languages for the problem he needs to solve, and the odds of
finding programmers, libraries, etc. for each.