A Taste of Haskell | Hacker News Reader

A Taste of Haskell

hookrace.net

157 pointsdef-116 comments

As for the Java bashing in the beginning I'm not saying Java is anywhere near the expressive power of Haskell but many people think different things based on Java because of features they either don't know about, outdated libraries used, or experiences with older versions and codebases.

For example most don't know that Java actually does have macro like capabilities through APT (annotation processor that will work automagically I might add). Some might say ewww its not macros but then again annotation processing might just be 80/20 good enough (aka what OCaml learned with ppx vs camlp) and that Java now sort of has traits and that its code swapping is actually fairly good (jrebel). There are even sadly people that don't know Java has lambdas, and even some (usually C++ dudes) that don't know it has generics. Most don't even know that you can combine interfaces with generic types as in: `<T extends Comparable & Serializable> void someFunc(T t)`.

Yes Java is not Rust, Haskell or even OCaml in expressiveness but it certainly is more powerful than Golang and definitely compiles fast (albeit starts up slow).

That being said OCaml is still my favorite. Compiles fast and easier for me to understand. Super mature and lots of companies use it.

It's not Java what makes Java platform one of the most popular but rather JVM. That's why Clojure grows in popularity. Because it brings the expressiveness.

Please show me how Clojure is growing in popularity. Clojure has never been more than a niche language.

A language can grow in popularity while still remaining a niche language. Haskell is a very good example of that, but I really can't say the same thing about Clojure.

https://xkcd.com/1102/

well for one, it's being used in the industry quite a lot. Citi, Walmart, Amazon, CapitalOne, Facebook, and Spotify are just some of the names from this list.

http://clojure.org/community/companies

> and lots of companies use it

Curious, who uses ocaml other than FB and Jane Street?

https://ocaml.org/learn/companies.html

That's not really the Sieve of Eratosthenes. The list data structure is not well suited for the algorithm. See [1] for a proper discussion. As someone who wants to write Haskell(and loves it) for code with mathematically well defined guarantees, the propagation of such examples, where the guarantees or behavior is not clear to the author, is not helpful.

[1]: https://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf

Cannot agree more. I think the usual example of quicksort also falls under this category.

[1]: http://stackoverflow.com/questions/7717691/why-is-the-minima...

It's the same example displayed in haskell.org though.

Totally fair point. haskell.org has a very . . . casual approach to presenting the language. It's been such an issue some people made an alternate homepage at haskell-lang.org.

Or if Python's your thing: http://www.kylem.net/stuff/sieve_eratosthenes.html

I got started with Haskell recently, and I'm really regretting not having picked it up earlier. Most of what I knew about types came from C, C++, or Java; so it's a big leap.

I've been using Haskell for Mac IDE [0] while experimenting, and it's been great fun.

The thing that prompted me to give Haskell a a try was this video [1] of a guy using Haskell to generate Elm types, in order to maintain consistent types across the stack. This idea captivated my interests. I'm confident that GraphQL and Relay, or something along those lines, is gonna be the future.

My experience so far has been that Elixir feels more welcoming and beginner friendly. There's nothing wrong with the Haskell community (or my limited interactions with it so far), but so far it's just felt a bit drier.

[0] http://haskellformac.com/

[1] https://www.youtube.com/watch?v=sh4H8yzXnvw

Of course Elixir is more welcoming—the language is "practically" functional, easy, and made for building stuff. Haskell's purity and academic background is definitely a big impact on its culture.

I wish there was a haskell-without-the-warts language with the same culture as Elixir - developer friendliness, practicality etc.

As it stands I can't help but feel discouraged when learning Haskell. Haskell feels like a research tool for furthering other programming languages...

I'm still going to learn Haskell, promised myself I would! But I do look to the Elixir folk with a bit of jealousy..

If you delve deep enough into C++ TMP, it's just as expressive (more expressive in some ways) as Haskell. You can actually do dependent types in C++.

You can, but would you?

From what I understand, C++ can do anything! But sadly, it lets you do anything.

Haskell restricts what you can do hugely. But also lets you accomplish a whole lot within what it thinks of as safety.

I like Haskell - but think it's really just a playground for trying how far functional purity can be pushed, rather than being the actual best version of that paradigm.

Probably in 10-20 years time there will be a language around which takes all those concepts and comes together as a really pleasant unsurprising friendly developer experience. Maybe it'll come from slow evolution of Haskell... stack helps a lot, and a whole bunch of GHC extensions... but it's still got a lot of very impractical elements and hangovers from the past that really need to go.

Depends what you mean by anything. You have dependent types and subtyping, but can't express, say, a GADT.

I think Scala can probably do anything.

I agree that Haskell is probably not great for writing real world code and should be reserved for toying with ideas about PL and type theory.

It's a far cry from Haskell but I've found Rust's type system to be a breath of fresh air coming from C++. Stuff like destructuring assignment and matching on enums (or anything really) while not as powerful as their equivalents in Haskell, are still much nicer than what you can do in C++.

Don't know about Haskell, but what really got me (a long time CSharp programmer) into functional programming was this awesome site [1] (and a man behind it with his awesome talks) - which is focused on core aspects of FP (applicable in most languages nowadays) in real-world applications.

[1] https://fsharpforfunandprofit.com/

I love that site. The best part about it is that it gives you all of the common names for stuff like category theory concepts. Eg: the various ways map, flatMap, bind, etc are called across languages.

Because its a pain in the ass to learn those concepts from scratch when you're looking at code in one language but reading a tutorial in another...the concepts are language agnostic, the naming conventions however are not.

Nice link. One related question : where have you used Haskell in real life. Do some top companies use Haskell to solve problems

I second this question and would like to add another one:

Where is it that Haskell shines?

This State of the Haskell Ecosystem doc[1] is very informative. If you're looking at application domains, Haskell(and OCaml etc) is usually well suited for writing compilers, but its not bad for your usual server-side application either. The only domain its fundamentally unsuited for is systems/embedded programming.

[1]: https://github.com/Gabriel439/post-rfc/blob/master/sotu.md

My impression from having tried it briefly is that it's not great at real-time stuff because of its lazy evaluation. Do you find that to be true, or is that not an issue in real life?

Lazy evaluation does make understanding performance/memory behavior hard, but usually you'll be using pipes/conduit/machines instead of lazy lists in production code, so its not much of an obstacle for real-time behavior.

However GHC's garbage collector can be an issue for real-time code, having high 99th percentile latencies.

There are a bunch of fussy little problems that Haskell solves nicely. One example is looking up a value in a map

    map.get("foo") // returns null

is the value of the key null, or was there no key? Different languages have different approaches. Haskell let's you build up deep structures, a list of maps of list of maps ... and you'll have an indication of what path you took down the data structure to get a result. You can do this in any language, but it relies on programmer discipline, and everybody doing it the same way every time. In Haskell, it's the easy thing to do, and often the only way to do it. You'll wind up with something like

[Just ["foo"], Just ["bar"], Nothing]

The first two maps had once answer each, the final map had nothing.

Laziness means you have control of the order of evaluation. in practice you can make your own control structures without macros. bracket is a good example,

    bracket open_socket do_stuff close_socket

the socket always gets cleaned up, with an ordinary function. No try/catch.

One of the biggest hassles in programing is leaky abstractions. The type system means you can steal abstractions from mathematicians that just don't leak. There's some good stuff here [1] about the kinds of things you can say.

Purity means values can't change behind your back. there's no function to call that'll change the state of some object you're working with.

All together, it's nice for languages. You can build up parse trees any way you wish, and traverse those trees to execute the semantics. So if you can think of a dsl for your problem, you can whip up an interpreter pretty quick. If you change your mind, and want to turn it into a compiler, it's relatively painless.

It's a fun language.

[1] https://wiki.haskell.org/Typeclassopedia

I'm writing a compiler in Haskell for a university class this semester. I don't think "painless" is the word I would use to describe it. Would you care to elaborate on your thoughts here?

You're writing a compiler! It won't be painless in any language.

Have you tried writing a compiler in another language? In my experience, functional languages are a very nice fit.

Sure :) First, i have to say i feel your pain. Writing a compiler is hard. If there's anything left you don't understand, this project will be punishing. Just know that at the end of the semester, there is absolutely no magic left. Your mental model of computation will be spectacular. Hang in there.

There are a couple of things. First, haskell lets you build up the language incrementally. So if your parse tree is like

    data AST = Prim Op |
               Immediate Int

you can just throw in

               Variable String

And the compiler will tell you all the functions with non-exhaustive matches. It's tough to do this in C because you have to remember all of your switch/case statements. Also, in C those switches are going to be based on a tag in a data structure rather than a direct type. The compiler won't really help very much.

Second, the thing that implements the semantics for the parse tree can be a typeclass.

    class Semantics where
        eval (Prim op) :: Prim -> a
        eval (Immediate i) :: Immediate -> a
        eval (Var name) :: Variable -> a

In haskell, you are free to implement an interpreter which is way way easier than a full compiler. It's nice to have an interpreter for your language, because you can run the same program both ways, interpreted and compiled.

so...

    instance Semantics Interpreter where
        eval (Prim op) = case op of
            Plus l r = eval l + eval r
            Minus l r = eval l - eval r
            ...
        eval (Immediate n) = n
            ...
        -- variables need an environment, but i think you get the idea, just look up the string in the env.

Then, you can write a compiler.

    instance Semantics Compiler where
        eval (Prim op) = case op of
            (Plus l r) = eval l ++ "MOV r1 r2 \n" 
                      ++ eval r "ADD r1 r2 -> r1\n"
            ...
        eval (Immediate a) = "STORE " ++ a ++ " r1\n"
            ...
        -- again, variables require an env to be passed around, it's just another arg to eval
        -- this time around though, instead of a simple lookup
        -- you need the memory address to load into r1
        -- you have to encode what lookup would do. 
        -- [2] talks about this a bit.

This is a pretty crappy evaluation strategy, just sticking the last result in r1, but i'll work. You can do much much fancier things.

Another super cute trick with haskell, you can use LLVM to generate your machine code at haskell run time, and then dynamically link it [1]. This lets you mix and match evaluation, interpret parts, compile parts, and use them interchangeably. Much much easier debugging. That link should get you generating machine code for a toy language in a day. Basically, instead of loading up the dynamic library, you just make an executable instead.

Anyway, there's lots of good stuff out there. I'd suggest out 3imp [2] (warning postscript file) That's Kent Dybvig's dissertation on writing scheme compilers. The second implementation is unbelievably elegant. full support for call with continuation, so much cool stuff. It compiles to a VM rather than assembly, but that makes a lot of complex things clear.

An obvious typeclass is a pretty printer for your parse tree, so you can make sense of what a program is supposed to be doing and you don't have to swear quite as much when your resulting assembly doesn't work.

A less obvious typeclass pass is a typechecker, if someone is adding a string to an integer, you can return a new AST that injects the Int -> String conversion. Constant folding is a good one to do as well.

An even less obvious typeclass will ensure that every malloc has a free. I don't think it's possible for any C program, but you can get a lot of it, and spit out a warning when your algorithm isn't sure.

If you can handle academic papers, Oleg's finally tagless is the coolest way to swap out interpreters, compilers, and partial compilation [3] (pdf)

C won't help you with that, like at all. you can play a game with a table of function pointers, that you swap out for the various eval cases. Debugging that, imho, is hard. With haskell the compiler just tells you you're being dumb.

I guess the main thing is, a compiler has a ton of special cases. Half the battle is just mananging those special cases. Haskell eases a lot of those burdens. The other half of the battle is coming up with good algorithms for getting stuff done (like register selection above!). Haskell lets you slice things up, so you can give your algorithm everything it needs to do its job efficiently. It's not that you can't do that in other languages (clearly, there are a ton of compilers in a ton of languages) it's more that it really encourages and supports the kinds of things you need to do when writing a compiler.

Again, writing compilers is hard. you will feel stupid. You are not stupid, you're doing something very few of the 7 billion people on the planet have even attempted. It takes years of practice to get good enough to even try. You're a badass. You'll solve it.

[1] http://augustss.blogspot.com/2009/01/llvm-llvm-low-level-vir...

[2] ftp://www.cs.indiana.edu/pub/scheme-repository/doc/pubs/3imp.ps.gz

[3] http://okmij.org/ftp/tagless-final/JFP.pdf

edit

In retrospect that register allocator blows. any right associative operations will get stomped on. It's what i get for slapping something together at 1 am. let's just pretend this is for fourth, and you always work on the top of the stack.

So which part do you find difficult? The parser? Haskell has the best library for parsing, parsec. The interpreter/code generator? I can't see how Haskell is different from any other languages on this part.

For me, I think the answer to this is really that Haskell is pure and immutable.

Equational reasoning[1] is immensely useful when debugging. It isn't unusual to debug pieces of Java code that look like this.

    MyClass c = new MyClass(..);
    c.method1(..);
    c.method2(..);
    c.method3(..);
    assert(c.someField == ..) // fails!

To figure what went wrong, you have to read through all three methods and depending on whether you have dynamic dispatch coming into play, you might need to read through _multiple_ versions of all three methods.

[1]: http://www.haskellforall.com/2013/12/equational-reasoning.ht...

Haskell shines at large codebases. It shines in a lot of other domains, but there's no mainstream competitor on dealing with messy, badly defined, big, changing problems.

Haskell shines on refactoring, API designing, and constrain setting (want to enforce safety? atomicity? thread ordering?). As a bonus, it'll also reduce your codebase an order of magnitude or two.

I mean, yes, if you never wrote a complex parser on Haskell, you should try. But that won't change your life too much.

Haskell and its advocates talk a big, big game about its supposed strengths in these areas, but there are suspiciously few examples of these strengths actually manifesting in anything but toy or academic projects. I've been hearing about Haskell's supposed miracles for years and years, and I've never, never seen them.

Then you haven't been paying much attention to Haskell which can be forgiven because it's still pretty niche compared to Python or JS.

The best example I can give you is the Haxl project at Facebook [0].

[0] https://github.com/facebook/Haxl

Haxl is one of the standard two or three examples. I want to see a non-Haxl example.

Many things that emerged at Facebook during recent years can be attributed to the influence of Haskell. React, Immutable.js, GraphQL, etc. Haskell is extremely powerful but allow me to rephrase Euclid "There's no royal road to functional programming". If you want something more pragmatic, yet still quite expressive and powerful - try Clojure and Clojurescript. Especially Clojurescript - it's probably one of the best languages out there to use for front-end and mobile app development.

A lot of stuff happens behind closed doors. Standard Chartered Bank has 1.5 million LOC of GHC Haskell and another 1 million LOC of their own internal Haskell implementation.

I'm also aware of another 5 or so big banks having/building Haskell teams for developing internal tools, but all this stuff is hidden. The biggest, public, project I'd say is FaceBook's Haxl (as pointed out elsewhere in this thread).

Standard Chartered is the other standard example. The only significant Haskell codebases anyone mentions are Standard Chartered, Haxl, maybe Barclays, and the GHC itself. It's pretty damning.

Galois, several startups ...

Haskell is very strict in what the compiler allows you to do where. It's a really great alternative to just requiring developer discipline. It means that you can do some things (like refactoring) with much greater confidence because the compiler rules out some big classes of bugs. Same with using other people's libraries. You can only use them certain ways and they are explicit.

A side effect of being so strict (in the sense of picky) about what is allowed where is that it needs some really powerful abstractions to keep that from slowing you down. Its type system shines here. Often, these abstractions have a nice syntax in haskell and it makes for some really clean code, relative to a direct translation in other languages.

I've loved Haskell for decades, but not yet had a chance to use it to pay bills. IMO, Haskell, more than any of the 1e3+ other PLs I know, shines in enabling 1) elegant and 2) robust ("better bugs") solutions.

Elegance comes from the non-strict functional part, enabling succent and modular implementations.

Robustness comes from the static typing which forces you to be explicit about the range and domain of functions.

What's unique about Haskell is that the type system is _very_ expressive, making this a practical approach. IMO, the type system is absolutely key to Haskell.

Where Haskell disappoints: Int. For reasons that I still cannot phantom, someone chose to infest a beautiful language that is almost free of pitfalls with the atrocity of a "C-like" Int type. Indeed, in Haskell, this isn't always true:

  a < a + 1 where a :: Int

which is a real shame IMO. It fails the largest value of Int (which BTW is implementation dependent). The correct answer would either to have (my preference) Int == Integer, that is arbitrary sized integers always, or at the _very_ least, have (+) fail on overflow, that is, return bottom like head [].

Writing parsers is really nice in Haskell: http://www.cs.nott.ac.uk/~pszgmh/pearl.pdf

Trifecta is a nice modern parsing library: https://hackage.haskell.org/package/trifecta

https://code.facebook.com/posts/745068642270222/fighting-spa...

This goes into detail about how Facebook uses haskell to fight spam. There's a talk that goes alongside it and the talk was one of the motivating factors for me to start learning Haskell.

Yes, but only recently. The most notable example in a top company is Facebook's spam detection service, powered by their library called Haxl[0]. The language allows some very skilled programmers to build this library that makes it very easy to write spam rules. Lower-level engineers can then write very simple and elegant code that looks sequential but is automatically parallelized by the library.

The service is a big deal, because every action or request that anyone makes on Facebook touches this service.

[0]: https://code.facebook.com/posts/302060973291128/open-sourcin...

Facebook is the new FedEx. Name a technology, Facebook's probably using it!

It's interesting that you said the Haskell allows programmers to build Haxl, with the implication being that other languages would disallow it.

I wrote a port of Haxl to C#[0]. At this point one might expect me to recite the whole Turing-completeness-means-all-languages-are-the-same banality, but my experience porting Haxl has actually led me to the opposite opinion.

Haxl probably wouldn't have been written in any other language other than Haskell. Because Haxl leans so heavily on concepts that other languages have no words for, I think it's inexpressible in C#, or most other mainstream languages. Obviously not literally inexpressible (there's an existence proof of a C# Haxl) but in an Orwellian, "these concepts are unthinkable in other languages" sort of way.

[0]: https://github.com/joashc/HaxlSharp

Standard Chartered has some 3 million lines of Haskell, but they don't use GHC, they have their own internal compiler.

About one million of those lines are actually compiled with GHC and about two million with Mu (or at least that was roughly accurate last time I checked).

Yes http://ambiata.com/

This question gets asked regularly, and every time Facebook's spam detection service, Standard Chartered's (never-seen) codebase, and maybe one or two other firms that no one's ever heard of get invoked. These are seemingly the only examples.

Facebook references all over this thread and literally the comment below yours is in regard to Standard Chartered :D

Barclays Capital: http://neilmitchell.blogspot.co.uk/2016/09/full-time-haskell...

Since when is visibility expected from corporate codebases?

I'm currently using Haskell to do supply chain optimization at Target. It's pretty awesome! The language lets us express our models in ways that feel natural.

We're both solving some specific problems (ie inventory control, network/transport optimization) and building a pretty general framework for expressing, analyzing and solving large stochastic optimization problems. Haskell is a great fit because it's extremely expressive and lets us write and reason about our problems in a natural, expressive way. It helps that we have a very mathy team in a mathy field :).

Our team also has a bunch of people with programming language research backgrounds, and our long-term remit is to apply programming language ideas to operations research. Turns out that—for a whole class of PL problems and PL people—Haskell is the perfect language :).

I also know people use Haskell at Facebook (already mentioned), Google (Ganeti and some unnamed X project), a few banks (JP Morgan, Barclays and Standard Chartered) as well as a whole bunch of startups and small companies.

We're a startup in London (shameless plug: www.nstack.com) using Haskell to develop a containerised microservices platform, bringing in lots of low-level Linux coding along with high-level concepts such as typed DSLs.

So far it's working extremely well for us and has been a great decision - letting us build complex/reliable systems really quickly and effectively. It is also very good for attracting amazing people, and we have found a small Haskell team can deliver truly spectacular product. This does on how you architect a Haskell codebase: e.g. you could spend a ton of time focusing on the most pure approach vs. pragmatism, so it's a balancing act.

kittyhawk has an opening for a full time Haskell software engineer https://kittyhawk.aero/

Well, someone seems to show up to Boston Haskell every month having used it in industry, and I've used it for a paper on probabilistic modelling in my copious free time.

I really want to warn people from using long-to-compile languages in big projects. And by long, I mean longer than C++. From what I heard Haskell has compile time issues.

You will regret it once your in that position and it is hard to get out of once your there.

It's a common misconception that Haskell is slow to compile but not really true, see for example: http://www.shimweasel.com/2016/10/24/fast-tests-and-static-l...

That feels like a limited optimization in the context of practical development.

I guess it depends on your expectations. I'm working on a ~38000 SLOC Haskell program (an optimising compiler: http://futhark-lang.org), and with GHC 8.0.1, a full build takes about 7 minutes. I can cut off a minute or two by passing `--fast` to Stack. However, even small incremental builds take a significant amount of time due to linking, which is what annoys me the most. It's still far from making me disavow Haskell, but it's definitely not among the fastest-compilable languages.

This program is also too big to load in GHCi, at least on my laptop with 8GiB of memory.

That's pretty uncanny, swift has a fairly sloc to time ratio too. The memory usage although is significantly less.

No, it's a very common issue brought up within the community that GHC takes a lot of time and memory.

That blog post just says that interpreting Haskell can be faster than compiling.

I worked with Haskell professionally on a pretty large codebase. It was split up into many separate libraries and binaries. There were a lot of coffee breaks when recompiling.

https://www.reddit.com/r/haskell/comments/45q90s/is_anything...

I've spent quite a bit of time with Haskell, and all the beginner text like this link are easy to grok, but where I've constantly come up short is trying to write an app with, for example, a configuration and a database connection. Having multiple levels of Monad transformers just confuses me and I never get anywhere useful. Something like:

App MaybeT IO (StateT IO (EitherT IO Text SomeRecord))

Or something. I haven't figured this out.

Use IO for everything at the beginning. Use wai/warp to run an app directly and setup handlers. Use postgresql-simple to send queries. Read the settings object once, then pass it everywhere.

You can slowly start writing generic types for your pure code after a while. For example, replace types such as `[t]` with `Functor f => f t` if the only list-related operation done in that function is `map` (fmap). Try to take advantage of the stuff here: https://wiki.haskell.org/Typeclassopedia

After a while of doing this, you can start looking into how you can write your code in a way to have more generic types, then specialise it for the concrete problems you're solving

Finally at this point transformers should become easier and more obvious. Perhaps the first one would be to replace passing the config everywhere with ReaderT. Implementing a few transformers by yourself should help. Start with MaybeT and continue with ReaderT. Tip: `liftIO` magically works but you don't have to always understand how. Maybe also try free monads if transformers seem too annoying!

I almost forgot; use MVar [1] to keep mutable state around. Its seriously helpful.

https://hackage.haskell.org/package/base-4.9.0.0/docs/Contro...

You shouldn't need this stuff if you don't want to use it. Just write a few IO functions for interaction with the real world, and pure functions for the rest. I made the same mistake in the past, and I was completely lost. I'm still nowhere near advanced, but sticking to simple stuff and learning slowly I am able to be quite productive now.

I hit the same problem... I had decided to start with a little toy 'dice rolling' program, but since it involved random numbers I unwittingly got hit with the monad problem up front.

It seemed I had two options: either I could pass a seed value around everywhere, or I could lift all my values into monads, necessitating the use of the 'monadic' version of all the operators etc everywhere.

I was unable to achieve what you suggest... I could not find a way to keep the 'inner' part of the code as pure functions just expressing simple operations.

I submitted here http://codereview.stackexchange.com/questions/114725/my-firs...

I had some useful feedback but no one addressed the "monad pollution" issue.

Apart from the different mindset of Haskell (which I found interesting) I struggled with having multiple ways to do everything, how to find the 'right' or monadic version of a particular function or operation, poor docs.

> App MaybeT IO (StateT IO (EitherT IO Text SomeRecord))

Ouch! I've written Haskell commercially for the last four years and I've never written (or had to read) anything like this!

There are some book recommendations at the bottom of the article, which are missing the (IMHO) latest-and-greatest introductory resource to Haskell: the book Haskell from First Principles.

http://haskellbook.com

I love Haskell, but if you hate Java, but still want to leverage the nice Java ecosystem, (libs, IntelliJ, JVM, tooling, etc) try Kotlin! :) https://kotlinlang.org/

Does kotlin have the same compile time, binary size and IDE indexer choking issues as Swift? I've heard that it has similar problems. I would not use Kotlin for a large project if that is the case.

I used Kotlin for basically all of our machine learning/classifier code in a pretty large map/reduce + storm pipeline and have had no problems.

IntelliJ also does not seem to have any problem with it either. (The IntelliJ authors being the the creator of Kotlin) In terms of code size, Kotlin is definitely smaller and easier to maintain. In terms of raw/clean compile speed, I would expect it to be a bit slower, but there are ways to improve it. One of the bigger ways is via incremental builds. I.e. Only build changed chunks of code, which Kotlin supports, and is comparable to, and in some cases faster than Java: https://medium.com/keepsafe-engineering/kotlin-vs-java-compi...

In terms of executable size, I don't have good data, but will investigate, but I'd say likely not a major deterrent given all the other value adds. :)

So how long would a generic heavy 100 kloc project take to compile?

Full compile and changing one 200 line library file used by 1/4th of the project?

I don't know. The experiments in the post only shows a limit set of examples.

My hunch is that if you are using a modern compiler/IDE, you will not be coding -> compiling -> running that frequently. I typically code a lot before I actually actually run anything, so I'm not usually waiting around on a compiler. I don't even notice, at all, Java's incremental compilation when coding in IntelliJ. I refactor like a madman.

Also, Kotlin is not very ambiguous, and the type inference that it does enable does not escape the scope of a function so the compiler doesn't have to do that much work. (functions require strict typing). I would guess much of that lambda work gives it a small headache, but probably not that much worse than Java's. If Kotlin grows mainstream, it's already pretty good compiler, will only get better.

Of course, that is all a hunch. :)

If you love Haskell I guarantee you will not love Kotlin in the same way. Your best overall bet for Haskell-like FP on the JVM is Scala+cats/scalaz and other Typelevel-endorsed libraries. Unlike Kotlin, it gets pretty close.

I mean, if you like Scala, you'll most likely like Kotlin, there are a LOT of similarities between the two.

Forgot to say, I agree with your statement. :) A pure Haskell fan, will likely not appreciate Kotlin the same way that a Java person appreciates Kotlin.

That would be an odd choice for a Haskell alternative. Lacking higher kinded types and type classes is a bit of a show stopper.

The obvious choice for Haskell on the JVM is Scala.

Nope - the obvious choice for a functional language on JVM is not Scala and not Kotlin - it's Clojure.

Haskellers tend to be fond of their type system.

In a standard conversation, I would totally agree with you. However, since the OP is comparing Java vs Haskell, I figured I would offer something that's, imo, better than Java, and perhaps good enough that a pragmatic Haskeller can accept.

Granted, Closure is probably a more pure alternative.

The project is not super mature yet, but you could give Frege a try. Frege, as opposed to other solutions, is Haskell in a JVM.

https://github.com/Frege/frege

Started learning Haskell just a couple of weeks ago. My only complaint with the language so far is that I cannot have the same name for a field in two records in the same module.

Other than that it is amazing the confidence it gives me; if it compiles it works (r).

This may help you:

https://www.reddit.com/r/haskell/comments/2z248l/language_ex...

Thanks!

If you are using GHC, the newest version (8.0.1) actually supports duplicate record fields with the [DuplicateRecordFields](https://downloads.haskell.org/~ghc/latest/docs/html/users_gu...) extension. Check it out!

Ahh awesome! Thanks!

Nice ! Does it work well with lenses ?

So you can do something like this:

    data Foo = Foo { _bar :: String }
    data Buzz = Buzz {_bar :: String}

And derive lenses? I think it doesn't - this is more than just a duplicate record name, you also end up with a duplicate `bar` lens

This may sound (and probably is) quite superficial, but I am immediately put off by any language that uses syntax like this: foldr' (+) :: Num t1 => t1 -> [t1] -> t1 Why? Because of things like => and -> are just a pain to write all the time and make you chase all over the keyboard, even more so on non-english keyboards. Just my very personal preference of course, but still...

It is quite superficial. Code being easy to read is much more important than code being easy to write. I'm not saying it's a bad idea to have both, but look at Java or C# that are a pain to write without a very smart IDE (just because of the amount of boilerplate). Even they have been saved by tooling.

Also, modern popular languages tend to use arrows (Java, C#, ES6). Not to say that popularity matters, but people are used to it nowadays.

How bad is it looking at the examples and thinking "I love that lambda symbol as a prompt. I want"

I have to revisit my base setup soon. The 1990s wants its bash_profile back

How difficult is it in your experience for developers to learn Haskell while on the job?

In my experience at IMVU, surprisingly not very difficult. It's easier to learn Haskell in a team environment than on your own because your peers can help you connect the dots and accomplish your task at hand.

It did seem like less experienced people picked it up faster, perhaps because they had less to unlearn. The hardest things were learning to parse GHC's error messages and learning all of the names of the functions to transform between various data types.

I basically learned Haskell at my first job (writing a compiler), and it was pretty easy to productively contribute starting on day 1, especially because there seems to be less risk of breakage than in many other languages. I also helped teach it at the next job, and developers found it pretty easy to pick up, just different from what they were used to.

Prior to this, I had some experience using it for hobby projects, but there was a lot more to learn for real-world use. My colleagues and I helped each other learn new concepts and write better code, as best we could, but we did end up making some questionable design decisions. I think you still need an experienced Haskeller to advise on good program architecture.

Compilers are a bit easier to start with because you can just deal with pure functions for the majority of the time

You can, but that’s not to say we did, haha. One of the aforementioned questionable design decisions.

I tried haskell queues a while ago - under the advice of a friend and compared with a straightforward C++ queue - it was about 100x slower. Abandoned the idea.

Let me guess ... you used [a]

What are you implying? What should they have used?

The list datatype is horrendously unsuited for being used a queue. They should have used a datatype designed for use as a queue.

There are better pure queue types and STM channels and suchlike that are designed for the job, so if bench-marking then you want to be fair to Haskell and use the right type.

You should do a write-up on it and show your tests. As it stands, this post has almost no real value for anyone else and no one knows anything about what you used and how.

I taught myself Haskell because people say it improves you as a programmer. I didn't see that, but I have a math PhD so maybe I'm just too familiar with abstract types to gain new insight from Haskell.

As a language, it's sterile. You can tell it was designed by committee.

Are you still using it? If not, what did you switch to for expressive, "fast" (faster than python) language?

No not still using it. I use C or q (as in kdb+) when I want speed and expressiveness. Python if I want quick easy prototypes.

If you think Haskell is a weird language that challenges what you think about programming, it's nothing compared to q! :)

Not looking for a challenge, it's more like python is often too slow, and it spoiled me, I find every other language too verbose and missing expressiveness. I've started looking at Haskel as the possible solution here.

> As a language, it's sterile. You can tell it was designed by committee.

This remark is puzzling. How do you tell if a language is sterile?

Hard to put a finger on it but it lacks a certain "playfulness" which real-world languages have.

It's like the difference between Lojban/Esperanto (artificially constructed spoken languages) and English/Spanish. English/Spanish are "imperfect" but their warts are the results of thousands of years of culture (and may not be imperfections after all, they may be a case of some kind of coding theory emerging organically)

That's surprising since "playful" is exactly how I would experience how I perceive Haskell. I guess it only goes to show how worthless subjective impressions usually are.

In any case, I think suggesting Haskell isn't a "real-world" language comes of a bit trollish, even though you probably didn't mean it like that.

I must agree with feanaro: Haskell IS a playful and experimental language. Its unofficial motto is "avoid success at all costs", which should tell you something about the playfulness of its community.

As for what you learn from it... you say you didn't see any gains? I take this to mean in your previous languages you already programmed in a functional style, with purity, referential transparency and lazy-by-default evaluation? I find that hard to believe :)

Reply on news.ycombinator.com