checkout - ratbeard on Diigo

3Expand

JSONRequest

Tags: checkout on 2007-10-12 and saved by9 people -All Annotations (0) -About

more fromwww.json.org

12Expand

Language Impression

Tags: checkout, functional, programming on 2007-10-10 -All Annotations (0) -About

more fromclean.cs.ru.nl

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.

29Expand

defmacro - Functional Programming For The Rest of Us

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

more fromwww.defmacro.org

Functional languages come with this technique built in. You don't need to manually create a function that wraps the original
currying is used very often to adapt functions to an interface that someone else expects. Since the interface to
functions is its arguments, currying is used to reduce the number of arguments
The code above adapts an interface of a function that raises an integer to an integer power to an interface of a function
that squares an integer.
Any self respecting programmer will tell you that the book is language agnostic
and the patterns apply to software engineering in general, regardless of which language you use
Unfortunately
it is far removed from the truth.
An object oriented approach is to make MessageHandler a base class and specialize the client code
operation in derived classes
That's a lot of
code for such a simple modification though. We have to create two new types just to support different client codes
If you see that a piece of logic within your function needs
to behave differently in different situations, you break it out into a higher order function.
When you see that a particular piece of code is repeated, you break it
out into a function (fortunately they still teach this in schools).
An interesting property of functional languages is that they can be reasoned about mathematically. Since
a functional language is simply an implementation of a formal system, all mathematical operations that could be done on
paper still apply to the programs written in that language. The compiler could, for example, convert pieces of code into
equivalent but more efficient pieces with a mathematical proof that two pieces of code are equivalent⁷.
Relational databases have been performing these optimizations for years. There is no reason the same techniques can't apply
to regular software.
It is even possible to create tools
that analyze code and generate edge cases for unit tests automatically!
n a functional program all state is stored on the stack in the arguments passed to functions. This makes hot deployment
significantly easier!
functional style programs are "future proof"
A functional program is ready for concurrency without any further modifications.
You will
always be able to reproduce your problem because a bug in a functional program doesn't depend on unrelated code paths that
were executed before it.
You can test every function in your program only worrying about its arguments.
In Java or C++
checking a return value of a function is not sufficient - it may modify external state that we would need to verify.
The state is kept in function parameters, on the stack.
We will now make
two modifications to Java: every variable declared in our functional Java will be final by default, and we will
refer to variables as symbols.
All variables can only be assigned to
once.
Not all lambda
calculus ideas transform to practice because lambda calculus was not designed to work under physical limitations.
If we had machines that had infinite computational
power, what problems would we be able to solve?
a formal system called lambda calculus. The
system was essentially a programming language for one of these imaginary machines. It was based on functions
that took other functions as parameters and returned functions as results.
We can't even be sure that natural numbers have full resemblance to the real world
Tetris is one of countless examples of a formal system, a puzzle, that has nothing to do
with the real world.
Tetr
is
>
is
Tetris
is a formal system, just specified using an unusual representation.
we set up a set of
basic non-conflicting principles and a set of rules on how to operate with these principles. We can then stack
these rules together to come up with more complex rules.
It's fairly
clear that there is no perfect circle that we can observe. But we also understand what a perfect circle is and
can describe it via equations.