Hacker News Reader

zarakshRon Why I still reach for Lisp and Scheme instead of Haskell

I don't see how:

Racket:

  > (define (fact n)
      (if (= n 1)
          1
          (* n (fact (- n 1)))))
  > (fact 6)
  720

OCaml:

  # let rec fact = function
      | 1 -> 1
      | n when n > 1 -> n * (fact (n - 1))
    in fact 6;;
  - : int = 720

zarakshRon Baking the Y Combinator from Scratch

This is not relevant since this de-sugaring cannot be performed if `name` is recursive (i.e., if `term` refers to `name`), which `Y` is. So the author's derivation is still required in the pure lambda calculus.

zarakshRon You Need Subtyping

> because PHP and Javascript will implicitly convert back and forth

If you can provide (valid!) methods `T -> U` and `U -> T` for two types, why wouldn't `T = U` hold? (Atleast for types where `=` makes sense)

This is the definition I am using:

> S is a subtype of T, written S <: T, if a value of type S can safely be used in any context where a value of type T is expected.

from Pierce's "Software Foundations"

Of course, you may not want to make `String <: Number` and `Number <: String` (and thus `String = Number`), because there is no sensible way to do so; but this is an issue with the way PHP/JS handles subtyping, not with the notion of subtyping itself and certainly does not apply to the example of nullable types.

Unfortunately, I am not familiar enough with C++ to comment on the other question, sorry!

zarakshRon You Need Subtyping

> The point is you can't simply treat non-nullable as a subtype of nullable in general, because this case exists.

But surely, you can still use subtyping in other cases -- when it is already unboxed -- right?

Like so: `T <: T?` for all boxed `T`.

zarakshRon You Need Subtyping

> The language can just have an implicit conversion rule for convenience

the presence of an implicit conversion rule `T -> T?` amounts to the observation that `T <: T?`, where <: is the subtyping relation

> make an unboxed integer nullable ...

I don't think any language allows this, in any case disallowing nullability for unboxed types amounts to the observation that `P !<: P?`, where !<: is "does not subtype"

I believe (unless I have misunderstood you) that both your examples are subsumed (heh) by subtyping

zarakshRon In Economics Do We Know What We're Doing? Nobel Prize winner grows disenchanted

Similarly, I was shocked to learn that models of aeroplanes don't even account for the possibility of the plane being blown up mid-flight by a stray anti-air missile.

It seems aerospace engineers are just like priests and counselors in the courts of ancient kings.....

zarakshRon Is it possible to write games like Pac-Man in a functional language? (2008)

Continuation-passing style?

zarakshRon Leo Tolstoy on why people drink (2014)

> If I am in my normal raw intellect, I will begin going deep on some topic thats outside the range of normal human discourse. It will be hard for me to stop, because of my interest. Alcohol removes that to a large degree.

Peak HN.

zarakshRon The Go language's first commit (1972)

How would that even work if git was released in 2005? Am I missing something?

zarakshRon Write it in Garamond

And EB Garamond[0] if you want a free font.

[0] - https://fonts.adobe.com/fonts/eb-garamond

zarakshRon Apple Reports Third Quarter Results

I can't wait for this comment to show up on n-gate.com

zarakshRon Ask HN: Quick and high-level tutorials for Python – or any other language?

Wow, this is really helpful. Thank you!

zarakshRon Seasteading Creates RPG

Under the description of The Co-Op it says "Players pay a membership fee to access resources like food, lodging, clean water, etc."