On that note, calculus come from physics. AI should really hand back all those jacobians and hessians.

Have you also wondered how many of them owe their college degree to the colored worker that prepped their meals?

Where are your formalizations of your proofs using Lean? Go away and don’t come back until you have them.

Syntax is wildly continuous with semantics, what’s the problem?

> As for how the orange peels were able to regenerate the site so effectively in just 16 years of isolation, nobody's entirely sure.

Another data point to the thesis that it's not the earth that needs saving, it's human systems. If disruption becomes the order of the day, who's impacted the worst?

My guess is that Del Oro would have a competitive advantage in its waste disposal costs.

Applicative operators effect from left to right. So the order of effects in

  getPerson :: IO Person
  getPerson =
    Person
      <$> (putStrLn "Enter your first name:" *> getLine)
      <*> (putStrLn "Enter your last name:"  *> getLine)

is transparently clear (to a seasoned Haskeller).

That’s only true when you use the IO monad as an Applicative. It’s not true if you use for example the Concurrently type from the async package (which is quite wonderful btw). The ApplicativeDo language extension makes it possible for you to use do notation in this case as well.

https://hackage-content.haskell.org/package/async-2.2.6/docs...

Do you have a concrete example using Concurrently where the effect semantics is harder to understand--possibly even misleading--with effect combinators than with do notation?

Here's a silly but simple example:

    newtype FlippedIO a = MkFlippedIO { runFlippedIO :: IO a }
      deriving Functor
    
    instance Applicative FlippedIO where
      pure = MkFlippedIO . pure
      liftA2 f (MkFlippedIO x) (MkFlippedIO y) =
        MkFlippedIO ((flip . liftA2 . flip) f x y)
    
    data Person = Person String String
      deriving Show
    
    putStrLnFlipped = MkFlippedIO . putStrLn
    
    getLineFlipped = MkFlippedIO getLine
    
    getPerson :: IO Person
    getPerson = runFlippedIO $
      Person
        <$> (putStrLnFlipped "Enter your first name:" *> getLineFlipped)
        <*> (putStrLnFlipped "Enter your last name:"  *> getLineFlipped)

It runs things "backwards":

    ghci> getPerson
    One
    Enter your last name:
    Two
    Enter your first name:
    Person "Two" "One"

When you use Concurrently you are implying that you want things to happen concurrently and you don’t care about effect ordering. You leave the effect ordering to the GHC runtime in how it schedules these green threads. Using do notation here works but it is slightly misleading. A seasoned Haskeller would never see do notation and assume anything about the ordering of effects.

Immature in what way? TFA advocates a certain coding style over a different one.

Pilot, co-pilot killed in runway collision at New York LaGuardia airport

> I'd like to stay a little bit unique for a year or so, if possible

You have six months, for that’s their release cycle.