-BEGIN PGP SIGNED MESSAGE-
Hash: SHA1
i have some (10 years) experience with difference statically typed
languages and a bit with dynamic ones. i encountered a few typesafe
solutions that don't introduce a lot of overhead - for example the
types of scala. in addition to interfaces and classes, scala has
types. a type can be an arbitrary set of field and method definitions,
for example:
type foo = {
def x:String
val y:Int
}
every instance that has a method x which returns a string and a field
which is an int are compatible to foo. in java, you would say it is a
delayed interface. the code behaves as if someone magically attached
implements foo to any class which would still compile.
so your (not (nil? (:first-name record))) would work in scala if
there was a type like type bar = {
val firstName:String
}
it's implemented via reflection, but the types are checked at compile
time.
Am 24.10.2011 15:28, schrieb Timothy Baldridge:
After watching Rich's talk the other day about Making Simple
Easy, I started thinking about how to incorporate parts of this
talk into the software we're writing at work. During this thought
process, I have begun to wonder, are simple and statically typed
languages mutually exclusive?
Let me explain by a simple example. In the following text, I will
be using C# as my example static language, and Clojure as my
example dynamic language.
For instance, let's say we have two structures, Contact and Staff.
The two are completely unrelated, except for the fact that they
both have a first name, and they both are required fields:
Clojure:
{:first-name Billy :age 42 :record-type Contact} {:first-name
Joe :position manager :record-type Staff}
Now in Clojure, writing a validation check for this is as simple
as:
(not (nil? (:first-name record)))
But how would we do this in C#?
new Person() {firstName=Billy, age=42 }; new Contact() {firstName
Joe, Position=manager};
Person and Contact are unrelated, so I'm left with duplicating my
validation routines (once for each object), or going and making
both implement IFirstName. This gets even more fun when you start
taking into account generics: In C# a ListIFirstName cannot be
casted to a ListPerson because they are considered two completely
different objects.
In the Clojure source code, Rich gets around most of the above
issues by simply referring to everything as a object and then
casting to get the type at runtime. This works fine for code that
will be run in a dynamic language anyways, but makes for some ugly
code when you're actually writing the static language parts:
if (lst[0] is IFirstName) runFirstNameChecks(lst[0]); if (lst[0] is
Person) runPersonChecks(lst[0]);
However, this then requires tons of type checks and casting
throughout the entire system.
So yes, I understand that this is all a bit off-topic for a
Clojure mailing list, but I thought it was applicable to Rich's
talk. Are we getting half way to simple, simply by using Clojure in
the first place? Is it possible to write simple code in a language
that shuns the use of simple containers (List, Dictionary, etc.) as
the primary transport system for data?
If anyone has some thoughts, they are more than welcome to ponder
them out-loud with me on this thread
Timothy
- --
-BEGIN PGP SIGNATURE-
Version: GnuPG v2.0.14 (MingW32)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/
iQIcBAEBAgAGBQJOpZetAAoJENRtux+h35aGhTsP+wUYHLD0i8t4DI7P/d2A13Ca
29hIhICsxJ2IE3svctaobozaT1byzzpYq6NFfqcfdwfOJCAJBCxmrHTiTCQ09EPM
jSZpxiXQSXHtYDpn2AiYA5c5Ut+TXjbWeahKjyRGrUVKjORtPHvaWGccj0b5vzYT
m7QpMy7R0tzEj/w2FCIkWkjqvJeCQ3cYNC78GZ2gIHC9DQwAjeD2uKSX3RfwaD3S
apEJELCYeDS08NIS26uB0ZHbo228rLlr02WaXh/+rx/MlMlEE/MEIq0aqJV59J7J
A6EFqoC43LxpftJRfAJ3MHRoliC0mnGN9SoWKeRiE0i8p1g8pv1e74DpLzI/I/Pq
GeR9TL688wyhnehl8VZW9AEKQVfKOujPIkKdpr4eF98eKdxHdu4xwkKi/ZgL6zCf
h7/eO6QRrKsOLfztMNQsaYqpCP/pFGA2J3p4Q/oVkB2Uqa6xa0auNcY5mBSPNuZp
zKcOg6/gi39eOZxFslVOvnY6ZOcILjRJYoA1VcO834NMd0A+D6lP0UM0ReBb28kg
MLjhDstZC1xVShp9PVJAdMlMeNjRDOPcASQG6uCisTSGfQ7qVXBNYd/SqXyRUODn
YFTSYtncEu+Pq0nRIjl1ItBmP/9saEqqJwiOpW01IAT+mFVv10tqKCxWFJKwNcLQ
iolsrCZa8Yn9Tvt2hFEL
=UbSd
-END PGP SIGNATURE-
--
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
