Haskell in the Large [pdf]

Post by codygman » Fri, Jan 30, 2015, 4:13 AM UTC

evincarofautumn wrote: post #121

melling wrote: post #8

Has anyone used both Haskell and OCaml (or F#?)? How do they compare in practice? I've been wanting to put some time into a functional language and I've been debating between Haskell and OCaml. Because of F#, OCaml seems like it might be the more practical language (i.e. direct job opportunities). However, excluding F#, Haskell does seem to much more popular than OCaml.

I have used all three languages professionally—Haskell & some OCaml at Facebook, and some F# at Xamarin—and would recommend learning Haskell. There’s a strong community around Haskell, with a decent library ecosystem and high-quality implementations, and learning it will make it easy to pick up F# or OCaml—the reverse is not necessarily true. F# is a decent choice if you want to write functional code in .NET land, bu…

Post by dllthomas » Fri, Jan 30, 2015, 4:27 AM UTC

tel wrote: post #102

dllthomas wrote: post #98

Earlier quoted context omitted.

Two asides, which I don't think you missed but I just wanted to expand on... First, "Turing complete" means that you can compute anything anyone else can compute. It doesn't necessarily mean you can do it with a reasonable encoding, or do with it what you need to do with it. At the boundary between systems, encoding matters quite a lot! Second, it's certainly true that there are constraints you can express in Haskell…

I bring up the lack of turing completeness because in the space of type languages you can make even more powerful arguments. What you mention about reasonable encodings is sufficient, but we can get more strength. And, yeah... even a type system as primitive as C can catch interesting invariants. This is an important counterpoint to the general idea that "types never say anything interesting".

Post by eru » Fri, Jan 30, 2015, 5:13 AM UTC

dkarapetyan wrote: post #56

eru wrote: post #36

Earlier quoted context omitted.

> I would also like to know how many of the core team members have PhDs and MScs. Don't forget the MDs! (Not joking, one of the people Don's team has an MD.) I used to work for Don at Standard Chartered. Getting good Haskellers seemed way easier than the hiring efforts of my current employer (Google) focussing on more traditional languages. But I guess, that's mostly a function of pent up demand for Haskell jobs.

Where is all this pent up demand? I mean I get what you're saying. Most academics know Haskell and Standard Chartered hires academics but there is a bit of circular thing going on there.

Post by tel » Fri, Jan 30, 2015, 5:59 AM UTC

eru wrote: post #127

tel wrote: post #95

Earlier quoted context omitted.

gergoerdi covered analysis, but composition is simple. For any two Applicatives F and G and value type A the following 4 values are all Applicative values F A G A F (G A) G (F A) But for monads only the first two are monads for general monads F and G. So, Applicatives compose better!

And to get F (G A) with Monads, F needs to be a Monad transformer. In addition to composition, products of Applicatives are also Applicatives: (F A, G A)

    newtype ContT r m a = ContT ((a -> m r) -> m r)

    data (f * g) a = Pair (f a) (g a)

    p1 :: (f * g) a -> f a
    p1 (Pair fa _) = fa

    p2 :: (f * g) a -> g a
    p2 (Pair _ ga) = ga

    instance (Monad f, Monad g) => Monad (f * g) where
      return a = Pair (return a) (return a)
      Pair fa ga >>= k = Pair (fa >>= p1 . k) (ga >>= p2 . k)

    data (f + g) a = Inl (f a) | Inr (g a)

    class Natural f g where
      phi :: f a -> g a

    instance (Applicative f, Applicative g, Natural f g) => Applicative (f + g) where
      pure a = Inl (pure a)
      Inl ff  Inl fa = Inl (    ff      fa)
      Inr gf  Inr ga = Inr (    gf      ga)
      Inl ff  Inr ga = Inr (phi ff      ga)
      Inr gf  Inl fa = Inr (    gf  phi fa)

Post by kyllo » Fri, Jan 30, 2015, 6:35 AM UTC

taeric wrote: post #117

kyllo wrote: post #111

Earlier quoted context omitted.

The entire Java community pines for lisp, whether they know it or not. That's why Apache Ant was invented, it's Java's manifestation of Greenspun's Tenth Rule.

Is it confined to the Java community? Seems a bit more widespread, honestly.