php is great because it's a statically-typed language with types less expressive than pre-generics java and that lets invalid code run because it doesn't actually do static type checking at all

this toot inspired by my realising php doesn't support return type covariance and will crash out fatally if you try to do covariant things with return types, even though it has a keyword (self) that appears to be specifically intended for doing covariant things with return types

it turns out c♯ also does not support return type covariance

so c♯ sucks actually

@00dani Sorry can you give me an example of what you mean?

@AdrienneCohea sure! here's the simplest possible case:

class Base {
public Base getSelf() {
return this;
}
}
class Derived extends Base {
public Derived getSelf() {
return this;
}
}

this is well-typed from a theoretical perspective, and it typechecks in java and scala, but not in in c♯

@00dani Ah okay... Huh... I guess I haven't had a need for it. I'm sorry the language lacks that feature that you need :(

Does Rust have such a thing?

@AdrienneCohea good question! rust has an excellent type system so i'd kind of expect it to, but iirc it doesn't really do traditional subclassing so the situation mightn't come up?

i suspect the closest equivalent in rust would work. not sure 

@00dani @AdrienneCohea c# can't type check this???
Heck... What error does it give?
@lizardsquid @AdrienneCohea i haven't got a c# compiler handy to check, but probably something about incompatible method signatures? since the subclass version of a method needs to be compatible with the superclass version of the same method, and all that
@00dani *dies*

@Efi oh nooooooo bb

@00dani quick, say something nice about clojure
@Efi lisp macros are fantastic and clojure's focus on immutable data structures is commendable
@00dani I still haven't found an actually good use case for macros, woops
@00dani I mean, for defmacro, not the builtins