Neither covariant nor contravariant.
supertype[] is not a supertype of subtype[] if supertype and subtype alone are in that relationship, because the mutability of arrays means that the Liskov substitution principle doesn't hold.
(These are all something you'll probably find good explanations of on Wikipedia.)
That's not realistic or "fair" - most Haskell projects will use a dozen or so extensions easily. GHC has been a platform for language experimentation for a long time; standardisation efforts keep on cropping up in annual surveys. (Eg, swapping in Text for String in base is long overdue, but it's a hold over from days where FP pedagogy was seen as more important.)
I was very nearly in the same boat. The initial box dialogue was written by and for angry 14-year-old boys. It gets massively better; the characterisation is broad and engaging, and the central-european fairy-rail feel is really quite strong. The two pieces of DLC have great stories themselves.
Unfortunately high. It's the same reason there's a "space force". He didn't know about the coastguard and guessed something else, then doubled down.
They haven't been charged.
That's a good point. You can get away with that with a new language, but adding nullability as a non-default option would break existing code much like making things const by default in C++ would, I suppose.
Lombok had a bunch of great things that should've been part of the java language to begin with. They've slowly been folded in (so now you have to work out which @NotNull annotation you want) but the language does still improve.
At least the potential sentence is long enough to get a jury.
It's one reason the government is so keen to reduce jury trials. Because nobody is going to send granny down for holding a piece of cardboard.
More like "I am the wellspring from which you flow," which is, let's face it, infinitely cooler.
I broke down the outline into a set of boxes by scanning over them.
type Box = (C, C) -- inclusive coordinates
makeBoxes :: [C] -> [Box]
makeBoxes cs =
let cs' = sort cs -- left-to-right first, top-to-bottom second
scanLines = cs' & groupOn fst
in scanOver 0 [] scanLines
where
scanOver lastX currentYs [] = []
scanOver lastX currentYs (new : rest) =
let newX = new & head & fst
closedBoxes = do
[y1, y2] <- currentYs & chunksOf 2
pure ((lastX, y1), (newX, y2))
newYs =
-- Take the new column and remove anything that
-- corresponds to a y value that appears in both
merge currentYs (map snd new)
in -- Close the current boxes
closedBoxes ++ scanOver newX newYs rest
merge [] ns = ns
merge ms [] = ms
merge (m : ms) (n : ns)
| m < n = m : merge ms (n : ns)
| m > n = n : merge (m : ms) ns
| otherwise = merge ms ns
The fiddly bit was handling all the cases for shape subtraction. I don't give it here because it's just a slog, but the gist is this:
type Shape = [Box]
subtractBox :: Box -> Box -> Shape -- returns whatever's left
subtractShape :: Shape -> Shape -> Shape -- this is just a fold.
The idea: take a bounding box that's just large enough to cover all coordinates. From that, subtract the set of boxes above. You get a set of boxes that are in the "outside", ie, illegal region. [I did it this way because managing shape subtraction from the set of "inside" boxes is just more work.]
Then for each candidate rectangle, if it overlaps with any of the "out-of-bounds" boxes, it's not a solution.
The leadership contest uses ranked preference voting. There's no vote-splitting.