undefined | Better HN

0 pointsdrivebyops8y ago0 comments

More importantly it isn’t statically typed (like F#, Haskell, etc)

0 comments

4 comments · 2 top-level

flavio818y ago· 1 in thread

>More importantly it isn’t statically typed (like F#, Haskell, etc)

You can statically type variables (bindings) in Common Lisp if you want:

    (defun little-function (x y)
       (declare (type fixnum x y)) 
           (+ x y))

Although type checking is limited at compile time.

kbp8y ago

As well, dynamic typing is much less of an issue in Lisp than it is in most other dynamic languages because the debugging and error handling features are really that good; they pick up most of the slack that the less-present type system creates. It would still make a lot of static typing proponents uncomfortable, of course, because not nearly as much is being statically verified. I think that the reason people become so infatuated with static verification (and testing) (not that they're bad things or anything, but just the reason they get put on such a pedestal by some people) is frustration with languages like Python, Ruby, and Javascript, which all lack a lot of the tooling that Lisp or Smalltalk has to make working in a very dynamic environment not only tolerable, but preferable. People get frustrated with the lack of tooling around mainstream dynamic languages' dynamism and attribute it to being frustrated with the dynamism itself.

phoe-krk8y ago· 1 in thread

Common Lisp has strong dynamic typing. Dynamic, because language runtime maintains type information; strong, because each object has its type and cannot be treated as an instance of another type.

oblio8y ago

True, but he was asking about static typing.

j / k navigate · click thread line to collapse