>>8
I just had to reply to this. You're so annoying. I feel like you are thinking that these are the imageboards.
I feel like he is expecting Lisp and is pissed that it's not lisp.
You may want to read more than what you want to read. Like, the whole thing.
I am sorry that you are retarded.
That's a nice argument to debunk a statement, isn't it?
Many static type users do think that if it compiles, it must work.
Hurrr.
Again, nice argument. You seriously convinced me that letting integer overflowing without throwing an exception is a good idea!
#;> (fixnum? (- (expt 2 30) 1))
#t
#;> (fixnum? (expt 2 30))
#f
#;> (fx+ (- (expt 2 30) 1) 1)
fx+: result is not a fixnum: 1073741824
Keep your own functions in your own modules. You should not be changing module signatures randomly.
He is actually (partially) wrong, but you miss the point.
If the behavior of some function has to be changed, use a functor.
But if it's just a module, you can't do much.
This cannot be avoided wit ad-hoc polymorphism.
It can raise a warning.
Kill yourself. Also, camlp4.
Such a strong argument. Kill yourself! You must be a real man.
Also,
The conspicuous absence of macros cannot be obscured by the presence of preprocessors.
Records are typed. It can be good or inconvenient. Also, variant labels.
I don't see how this:
Cannot have two record types in the same file that have a field with the same name (and before version 3.09, you could not have a record field named contents!)
has something to do with types. Especially the ``contents'' part.
Kill yourself. This is supposed to be strictly typed language. Stop complaining about there being no automatic coersion.
Haskell is too:
Prelude> 2 + 2.0
4.0
KILL YOURSELF.
Oh, I understand now: You see the word ``dynamic'', ``static'', you immediately think of the typing. No, silly. He's talking about dynamically
scoped variables, which are really useful with optional arguments.
Again, strong argument.
I think they are good and very useful. Expecially when using foreign functions.
He thinks that too, he's complaining about OCaml's:
- The default values of the optional arguments cannot depend on positional arguments because of the calling conventions: to make function call delimiters optional, every function call for a function with optional arguments is required to end with a positional argument.
- Values do not match:
val foo : ?arg:string -> unit -> unit
is not included in
val bar : unit -> unit
even though foo can be called exactly like bar, so one has to use (fun () -> foo ()) instead of foo.
- The default values of optional arguments restrict the possible type the argument may take. E.g., in
let max_len ?(key=(fun x -> x)) strings =
Array.fold_left ~init:0 strings ~f:(fun acc s ->
max acc (String.length (key s)))
the type of key is string -> string, not 'a -> string as it would have been if the argument were required.
So, how about you read the article first, and then be an uneducated moron?
He doesn't want to define infix operations or have macros. What the fuck does he want?
Polymorphic arithmetic operators like in Haskell?
This is a function language, retard.
It is not pure, it permits side effects, so the order of evaluation matters.
Sorry you are retarded.
What?
Kill yourself. It's not meant to be b/c this is a functional language, retard. (Also, Stack module)
You have a point. Except that the b/c, ``kill yourself'', and retard make me want to punch you in the face, you don't say why immutable lists are good.
So, in the end,
kill yourself.