In http://www.dalnefre.com/wp/2011/11/fexpr-the-ultimate-lambda
Dale Schumacher writes:
"
One way to look at the difference between functional and object-oriented
algorithms is to consider the relationship between types and operations.
Let’s say I have a small set of types {A, B, C} and operations {f, g, h,
+}.
f
g
h
+
A
f(x:A) → A
g(x:A) → B
h(x:A, y:C) →
B
x:A + y:A → A
B
f(x:B) → B
g(x:B) → C
h(x:B, y:C) →
A
x:B + y:B → B
C
f(x:C) → C
g(x:C) → A
n/a
x:C + y:C → C
Table 1 shows how these operations might be modeled with functions. The
same function name refers to different operations based on the argument
type(s). Operations are grouped by function name, as shown by the
columns of the table."
Consider the table above. You can "walk the type circle" from A->A
by the calls: g(A)->B, g(B)->C, g(C)->A, or equivalently,
g(g(g(A)))->A.
Now consider making the same table for Clojure types and functions.
"A" might be a list, "B" might be a hash-map, etc. The "f" function
might be conj.
Given such a clojure table, the question is: Can we complete the
circle for each data type? Are we missing any functions? Is our
set of chosen functions "orthogonal"? Given the set of types and
a list of functions could we construct the table automatically?
Tim Daly
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
