|
![](/i/fill.gif) |
>> written in an OO language can create variables, read/write them, take
>> conditional branches (if/then/else, for, while, etc.) and invoke
>> methods. (Object creation can be regarded as a special case of a
>> method call. Indeed, in some languages it *is* a method call.)
>
> And in Smalltalk, conditional branches are also method calls.
Oh yeah - I'd forgotten about that...
Looping too. ;-)
>> Other languages have records. A few other languages have true
>> enumerations. But Haskell has ADTs, which are a weird hybrid of the
>> two. The only other langruage I can think of that approaches this is C
>> with its "union" construct.
>
> Ada and Hermes and heh.
Not things I'm familiar with.
It did seem for a while that every single language I leaned was just new
syntax for basically the same stuff. Every language has named functions
or procedures or subroutines or whatever you want to call them. Every
language has if/then/else, while, for, etc. Every language has local and
global variables. So it's just a question of what the syntax looks like,
and what "features" the language has. (E.g., in Pascal, you can only
loop over numbers, while C lets you write for-loops which don't even
*have* an index variable.)
And then I learned Haskel, which is *completely different*. ;-)
> Heck even Visual Basic has such as "variant" type.
Is VB statically-typed yet?
> I think Pascal has the same thing too.
Not any dialect I've seen.
> That's pretty cool, tho. I love languages where a very simple idea is
> taken to extremes.
Yeah, it's nice. Haskell is a graph-rewrite system. I mean, if you want
any kind of performance, you'll want to hack the basic model a little to
take advantage of the native machine capabilities. But basically, it's a
G-maching. (In the case of GHC, a spineless, tagless G-machine...)
Smalltalk has a nice idea: Absolutely everything is an object. Including
the entire fricking IDE. Shame about the performance though, eh?
(Actually, the most annoying thing is the lack of static typing.)
Lisp has a nice idea: Everything is a tree. Shame the underlying simple
idea had to be implemented in such an over-complicated and arbitrary way.
Although, arguably Haskell has just *so much* syntax sugar it's hard to
see the simple structure underneith. Hence this post. ;-)
Post a reply to this message
|
![](/i/fill.gif) |