Do people actually like this weird shitty language? I've

>>57497498
thats because you are not smart.

>weird shitty language
Sucks to be dumb.

>>57497586
>>57497533
this is the same attitude that got donald trump elected

>>57497593
I'm ok with that.

File: the_fox_and_the_grapes_by_leticiakao-d2xv9zm.jpg (191KB, 900x1193px) Image search: [Google]

191KB, 900x1193px

>>57497498
That's ok. It's not for everybody. Stick with the ones you can understand.

>>57497533
I am tho

>>57497593
Try a Hitler analogy for more (You)'s.

>>57497498
>Do people actually like this weird shitty language?
Yes.
>I have no idea what this would be used for
Mostly for saying you wrote something in it. For CS profs/grads it is useful for modelling ideas and systems that they design on paper.
>What someone would find appealing about it
The type system abstractions are very nice, it makes generic programming a lot easier to reason about. Again it is for Computer sic Information Science people, they don't care how computers _actually_ work, they just want to model the pure logic their field depends on.

>>57497645
I'll also mention it's really good for complex math, especially when you venture outside of the high school/college freshman "algebra" and calc.

>>57497498
>I've been looking into it online and I have no idea what this would be used for or what someone would find appealing about it

Types and type classes, abstract data types with built in pattern matching, static typing, polymorphism, first class functions, monads, lazy evaluation.
Also functional languages can make the programmer more efficient.
See this case study:
http://web.cecs.pdx.edu/~apt/cs457_2005/hudak-jones.pdf

>>57497498
>Do people actually like this weird shitty language?
Yes. Once you get to learn it, it's neither weird nor shitty.

To me, non-Haskell languages are weird and shitty. It's all a matter of perspective.

>>57497855
agreed, just try simply transposing a matrix in any object oriented language.
then do it haskell.
the haskell code will probably be a lot easier.

I like it but I was using it only for small toy projects. It's good to know the basics of FP if you're a programmer.

>>57497498
I use it for my day-to-day scripting and computation. I use it for almost everything I do, although I'll fall back to other languages for when I want to use C libraries that don't have Haskell bindings already.

Some examples of projects I recently wrote in Haskell, if you want an idea of kinds of things I apply it to:

https://github.com/haasn/hsbooru (gelbooru scraper based on xapian)
https://github.com/haasn/heroline (DPS simulator and brute-force optimizer for Hero Line wars)
https://github.com/haasn/-/blob/master/server.hs (server-side component of my personal file hosting service)
https://github.com/haasn/DiabloM6 (M6 sentry DPS simulator for Diablo 3)
https://github.com/haasn/random_haskell_stuff (large dump of little files that didn't make the cut for their own repo)
and more stuff like that

Usually small 1-file projects, and anything there the answer to my question requires more code than just a few lines. Everything else I do interactively in GHCi, from simple mathematical expressions to more complex evaluations.

GHCi is pretty much my go-to calculator for day-to-day computation.

I hope that gives you some insight as to what Haskell that is actually used in the real world looks like.

>>57497498
I understand Haskell reasonably well.
But I can't say I don't like it, rather I'm not impressed.

File: post_number.png (306KB, 593x540px) Image search: [Google]

306KB, 593x540px

>>57497855
>it's really good for complex math
You mean Coq or Mathmatica right? No mathematician I know uses Haskell.

Recursion is easy
Good type systems are a blessing
Immutability is actually just fine

>>57497498
I'm currently reading Learn You a Haskell.
For some reason, it all makes sense. Though, I'm still at the 'Syntax in Functions' chapter.

>>57498020
As for why I like Haskell, it just makes everything so easy - in the way that it actually makes development faster (unlike e.g. python which really cripple your efficiency)

For example, to make the gelbooru scraper that I mentioned scrape pages concurrently instead of one at a time, I had to change

retry retryCount $ scrapePage

to

forConcurrently [1..n] $ retry retryCount . scrapePage

(And unlike python, I didn't have to test the program 10 times and debug various runtime type errors until it worked)

>>57498088
Do you know how fast Haskell is?
Is it Python fast? Or more like Java?

>>57498180
I'd say it's about as fast as Java in practice

>>57498020
Would you write a web application or any long-running service in Haskell? I appreciate that it has the most advanced type system in a somewhat mainstream language (that is not a mess like Scala's) but I can't get over the fact that it's lazy. I haven't used it much but I'd expect it to gobble up memory due to subtle programmer errors. Am I wrong?

>>57498220
>>57498180
Disclaimer: It depends very strongly on how much you're willing to optimize your code

“elegant” one-liners can be stupidly slow (python-tier), but optimized haskell can be stupidly fast (faster than C).

Like most things, it depends strongly on how much effort you're willing to make it fast. But GHC is a low-level compiler that directly targets machine code, so there's no runtime interpreter overhead.

Also, most of the haskell features are static only, like the entire type system, meaning it has no runtime cost at all.

>>57498088
What are some good resources for learning Haskell?

>>57498049
>No mathematician I know uses Haskell.
Do you know any mathematicians who use Coq? In my six years as a math major I never met one.

>>57498233
>optimized haskell can be stupidly fast (faster than C).
That's incorrect. (If you did comparisons yourself, then you did something wrong in C.)

>>57498233
>faster than C
Yeah I doubt that.

>>57498226
In practice I almost always write strict-by-default Haskell. In GHC 8's terms, this would mean turning on the Strict and StrictData extensions. This is usually not only better for memory use but also performance. I also agree that laziness-by-default makes for nice and elegant theory but not the best programs in practice.

As for memory leaks, Haskell is garbage collected - so a memory leak in Haskell is pretty much equivalent to a memory leak in other garbage collected languages, meaning you left around a reference to some big chunk of memory you no longer need.

Fortunately, since haskell is entirely pure and and lexically scoped, it's much harder to leave around references, because all resources are generally tied to their scope unless you're using some sort of mutatable state. I wouldn't worry too much about memory leaks in long-running services, but I would worry much more about memory *inefficiency* (e.g. large thunks and poor in-memory representations)

Strictness helps for that, as does using the right datatypes (e.g. Text instead of String for anything where you care at all about memory use)

>>57498276
http://aosabook.org/en/posa/warp.html is an example of where Haskell ended up faster than equivalent C, due to Haskell's inherent ability to reuse shared data in a 0-copy manner.

In the nginx version, a copy was mandated not by any language architectural reason, but simply due to not knowing what the downstream functions are going to do with data. Basically, the fact that you can pick more powerful abstractions in Haskell lets you cascade information about what is and isn't required, which you struggle doing in less powerful languages.

The thing to realize when talking about languages being faster or slower is not necessarily what's _possible_ in that language. Of course you can take any optimized x86 fragment and transliterate it to compiler intrinsics in C to get the exact same runtime as any other language. But that's not the point.

>>57498272
The language is a fad for hipsters. It's useless in production on real machines.

>>57498277
>>57498298
The point is comparing _idiomatic_ code written in a given language. And often, C's idioms mandates inefficient code due to code simplicity reasons (where the more efficient algorithm would be very difficult to implement correctly in C)

As a C programmer myself, I'm fully aware of how many sacrifices I have to make when writing real-world, complex C programers - because the language is so shitty and unsafe that you need to be extremely careful about what you do.

Very often, that means taking a hit in code runtime just to make sure you're doing the right thing. For example unnecessarily freeing and reallocating resources during a reinitilization, copying around data even in cases where downstream would only use it in a read-only manner, or recomputing shared state just to avoid having to synchronize the results.

>>57498298
>>57498326
Also, another thing to never forget is how stupidly easy Haskell makes parallel computation and concurrency, which alone can be a big boost to your performance where doing the equivalent in C would require lots of complicated pthread API usage, synchronization overhead, thread spawning / governing logic, and more annoyances.

>>57497952
in what language is this not trivially implementable as a nested loop?

>>57497498
it is great for circlejerking

>>57498049
Why don't they use python? The way python is written is almost syntactically the same as how math is written and it's got great math libraries

File: 1433812357266.jpg (76KB, 500x464px) Image search: [Google]

76KB, 500x464px

could any haskell bros post online learning stuff? already reading LYAH.

>>57498233
I mean fast as in: suitable for general purpose applications (web servers, scrapers etc.).
I'm a Java (Android) developer, but I don't like the syntax. It mostly boils down to being too verbose. The same goes for C++. Python is cool, but is too slow. Rc<RefCell<Box<Rust>>> is meh. You pay too much for memory safety. I don't know about D though. It looks OK, but it doesn't wow me. Go is a complete joke.
So my bet is now on Haskell as a comfy language that I can use for my pet projects.

>>57498461
work through the typeclassopedia.

>>57498298
>you struggle doing
You don't struggle in C. It's just laziness.
You can't benchmark languages by comparing complex pieces of software because they depend on decision of the design: the bigger software is, the stronger they depend.

On the other hand, analyzing how data model of the language is translated to machine code is much more enlightening.
Haskell must be slower, than C, because it endows each data type from the default kind with an additional value. That means every top-level function operates on boxed data and returns boxed data which incurs a performance penalty.
Polymorphism is implemented the same way as c++'s virtual functions. That's passing pointer tables around. Not the fastest way, but probably, the only possible with separate compilation.

>>57498490
>I mean fast as in: suitable for general purpose applications (web servers, scrapers etc.).
Most general purpose applications are not at all computationally intensive, and most people scale horizontally instead of trying to micro-optimize their code either way.

That said, I wouldn't try and write HEVC decoder in Haskell, for example. I would do that in x86 assembly and call it _from_ Haskell. Same for most low-level performance intensive stuff. If you need some particular algorithm done very efficiently, you can write it in optimized C and call it from higher-level Haskell very easily.

As for whether people run web servers in Haskell, they sure do. That seems to be one of the most popular ways to use Haskell in practice, actually. (Judging by how many web server-related questions from newcomers in #haskell I see)

Look up warp, yesod, snap, happstack, scotty, etc. to name-drop a few.

>So my bet is now on Haskell as a comfy language that I can use for my pet projects.
The important thing to realize about Haskell is that if you're a primarily imperative-learned programmer (which judging by your language list it's safe to say you are), you don't want to approach Haskell as “just another language”, since it will be your first time doing functional programming at all. You have to approach it as a completely new world view and way of thinking about problems.

Had you already mastered the art of functional programming, Haskell would become “just another language” to you, but that's something you can only realize in hindsight. Anyway, if you want to learn Haskell, forget about everything you know about programming and approach it from a fresh point of view.

>>57497498
i studied it in college (i mean, functional programming using haskell, not haskell itself, as always in college the language is just a tool to learn a concept) and damn its the best. its so much more interesting to solve problems with that than with the usual programming style

for some reason normies hated the shit out of it, but if you're smart its very interesting

>>57498505
>You don't struggle in C. It's just laziness.
I don't really see a difference between the two. If something is difficult to do, then it's difficult to do. Doesn't matter whether you want to call it being too lazy to go the roundabout way, or whether you want to call it the language being difficult - the net effect is the same.

When I write C, and I'm not a new C programmer by the way, I routinely struggle doing basic things over and over again. It's the curse of any low-level language. The less you get from the language, the more you have to do yourself - and due to the low abstraction ceiling I often find myself doing it over and over again. It just gets tiring, and since my time and energy budget is limited, that means I end up doing less than I could do in another language for the same amount of effort.

I realize that C is _capable_ of some amounts of abstraction, in the sense that you can pass around void* and function pointers, but the problem is that the cost of shoehorning your problem onto these abstractions is usually just as high and annoying as the cost of reimplementing your data structure or whatever from scratch every time.

Plus, by using void* you often lose something in exchange, for example safety (is my pointer cast safe? What pointer was this originally? Can I guarantee that? etc.) or even performance (since the compiler can't readily inline your comparison function or whatever).

Haskell comes pretty close to the dream of “write once, reuse all the time”, which many other languages fail at in a variety of different ways. (For example, enterprise Java fails in the sense that reuse and generalization are both extremely verbose and often require hacks to shoehorn it into the type system, which is why you get abstractboilerplatefactory nonsense)

>>57498562
>>57498642
For an example of just how powerful Haskell's abstraction ceiling is, this library implementants O(n) sorting and grouping for arbitrary (algebraic) data types:

https://hackage.haskell.org/package/discrimination-0.2.1/docs/Data-Discrimination-Sorting.html

What other language gives you a

sort :: Sorting a => [a] -> [a]

function that works in O(n) time no matter what ‘a’ is?

Enjoy your free performance boost out of using this library instead of the standard O(n log n) comparison sorts.

>>57498642
tl;dr lol

>>57498660
It parametrized only by one method.
Just write it in C and pass a function pointer.
Not impressed.

>>57498772
If you want to understand why things aren't as easy as you make it sound, feel free to write the same in C. I'll wait.

>>57498562
>Most general purpose applications are not at all computationally intensive, and most people scale horizontally instead of trying to micro-optimize their code either way.
That's true, but it's 'free' performance you get by simply using another language. Obviously, it doesn't justify rewriting an entire codebase, but it could be a good selling point when starting a new project. Aside from Google shilling, that's why Go gains so much traction. It's much faster than Python, and as long as you have all the libraries you need, so why not use that?
>As for whether people run web servers in Haskell, they sure do.
It makes sense to me writing a REST API in Haskell. Properly implemented, those applications are stateless. The database determines the state.
>you're a primarily imperative-learned programmer
That's correct. The most FP I've done, is in Rust.
Obviously, I can use Python for all my work, but I want a challenge. I'm a professional code monkey, so I want some challenge when I work on my own projects.

>>57497952
>transposing a matrix
I thought you said high level math.

And in OOP a matrix transpose is as simple as returning .get(j,i) instead of .get(i,j)

>>57498490
A few other options for you to consider:
1. Practical today
- Kotlin - it's an improved Java with a better syntax
- Elixir specifically for web/socket stuff
- OCaml, which is like a working class Haskell
2. Give them a year or two
- Swift - a well-rounded curly brace language with generics, etc. Unlike D it stands a chance in the market.
- Nim - a fast, statically typed language somewhat like Python
- Crystal - a fast, statically typed language a lot like Ruby

>>57498840
And that's your argument?

>>57498884
Haskell won't be a challenge to your ability to write code per se (in fact, the goal of Haskell is to make it *easy*, not hard) - but Haskell will be a challenge to your ability to break the mold and think from a new perspective.

And that will be a great benefit to any programmer who succeeds in doing so. Prolog would be another good language to try and learn, simply for its didactic purpose (forcing you to think outside the imperative box)

>>57498924
>Kotlin
I'd like to use that language in a new Android project if my boss allows it. I know Tachiyomi (https://github.com/inorichi/tachiyomi) and the PostNL apps are written in Kotlin. The syntax looks familiar and it looks a lot better than Java.
>Swift
I don't know about that one. One of my coworkers told me it's a pain in the ass to work with because the spec keeps changing.

I'll look into the other programming languages, thanks. I know that FFTW is written in OCaml and the rest I know by name.

>>57499120
I meant with challenge, the change of mindset you need in order to write Haskell compared to imperative programming languages.
Captcha: negro spencer

>>57499249
Personally I don't think OCaml is really worth learning, especially not as your first FP language. Haskell is much more modern and advanced than OCaml, which is limited by its object-oriented shoehorning

>>57497952
It will also be 10000 times slower unless you're using mutable array libraries which are a mess in Haskell.

>>57498252
you have to learn to look for resources
try haskell.org

>>57498049
> muh category theory

Haskell is for "elitists" that like to pretend they're mathematicians. Actual mathematicians working in the field don't ever use Haskell.

>>57498180
Much closer to Python than Haskellers like to admit. They rarely benchmark things properly though so they don't usually get exposed like Snap and Yesod did.

>>57500013
I use Haskell and I have no idea of category theory doe

>>57500013
Pretending Haskell is for category theory elitists is for “elitists” that like to pretend they're computer scientists

>>57498298
>is an example of where Haskell ended up faster

That paper was debunked and nobody can reproduce the results. Odd that actual Haskell web servers and web frameworks are Python/Ruby tier in terms of speed.

>>57500030
>claims Haskell is not sufficietnly benchmarked
>claims to know how Haskell performs in the real world
one of these contradicts the other. which is it, shitposter?

>>57500056
>debunked
got a link for that?

>>57500063
Techempower Web Frameworks benchmarks and the Debian Benchmarks Game (before Haskell faggots rewrote everything using the FFI) basically prove that Haskell is not a fast language.

>>57500063
>claims Haskell is not sufficietnly benchmarked

The claim is that benchmarks by Dons and other Haskellers aren't reliable. Remember when Snap and Yesod were incredibly fast? Where are those Haskellers now that everyone knows they're both slow as shit? Neither of them could even handle file uploads without leaking memory for years. Pathetic.

>>57497855
I literally don't see how, it feels so primitive. There's not even a for loop.

>>57500143
>Remember when Snap and Yesod were incredibly fast?
No

I always remember snap being a shittier version of warp and yesod being a gigantic bloated clusterfuck

>>57500066

Just trust me, it's debunked.

>>57500056
Odd, people who wrote a language based on their needs, decided to use preexisting tools that meet their needs when available? That's not odd, that's sensible. People who demand everything be done in their favored language are generally idiot fanboys, or insane zealots.

>>57500207
>Just trust me you dumb fucks
“okay”

>>57500066
>>57500207
> Haskell web server 10x faster than C web server that is used by almost every major company/website on the planet!

Google is hard. Even Dons doesn't try to defend this shit anymore.

>>57499473
>your first FP language
IMO nothing beats Standard ML for that.
>limited by its object-oriented shoehorning
How? Most projects written in OCaml ignore its object system and it causes them exactly zero issues. It is not Scala where inheritance messes with the type inference or anything like that.

As for Haskell being more advanced over all (especially when it comes to concurrency and parallelism), I agree, but mind that ML modules have one major advantage: https://stackoverflow.com/questions/36927169/ml-modules-vs-haskell-type-classes.

>>57500326
>that answer
Modern Haskell can actually pretty much do all of this, e.g. that Monoid example particular can be solved using ‘constraints’ and ‘reflection’ (haskell packages)

e.g. letting you write code like

withMonoid (+) 0 $ mappend 3 5

The thing to realize about Haskell is that it moves stupidly quickly. every single GHC version brings new and advanced features with it. With the advent of GHC 8, for example, Haskell even killed off the distinction between types and kinds - it's now pretty much almost a fully dependently typed language (like idris or agda), lacking only dependent pairs

>>57498924
>kotlin
what a useless fucking language. Like, Scala offers a seamless integration of OOP features with the purely functional ones, Clojure is a functional lisp that just werks out of the box, and this abomination?
>its jus bettur java wid bettur sintacs
yeah, fuck off you russian intellij marketer

haskell is a meme

>>57500422
Kotlin compiles faster, has no implicit conversions and uses Java's stock collections. Also note that its primary competitor is Android's freak fork of Java 6, not Scala.

>>57500403
>With the advent of GHC 8, for example, Haskell even killed off the distinction between types and kinds
Whoa.
>The thing to realize about Haskell is that it moves stupidly quickly
No kidding. Do major releases break old code badly?

>>57500490
Why is there a need for yet another JVM language? I mean, what's the niche?

>>57500537
Because Scala is a mess and a lot of Android developers would prefer to work in something better than Java 5.

>>57500597
and what about clojure?

>>57500629
Dynamic typing is a mistake and it uses far too much memory for serious Android development.

>>57500637
But it gives you an ungodly amount of flexibility in your code. The slow startup is a bitch though, the author is working on it.

>>57500637
>>57500629
>Dynamic typing is a mistake
True. If it's your thing Clojure is one of the best dynamically typed languages if not the best one but everyone who enjoys Clojure should check out statically typed FP.

File: I just had too.png (149KB, 300x300px) Image search: [Google]

149KB, 300x300px

>>57497623

>>57500521
>No kidding. Do major releases break old code badly?
No, because it's hidden behind 100 billion language extensions

There are a few breaking changes to major versions, but they are usually changes that were announced years earliar and hardly break production code

For example, Applicative was made a superclass of Monad after many years of deliberating and advance preparation

>>57500653
Startup time is just one serious problem. The biggest issue is that it generates too much garbage at runtime to be used for Android development. Clojure apps tend to be really memory hungry and they spend much more time in garbage collection than Java and Kotlin.

Java apps rarely spend more than 4-5% of their runtime on garbage collection. Clojure apps are basically always 20-30% or slightly more.

File: 1479065011367.png (128KB, 300x300px) Image search: [Google]

128KB, 300x300px

>>57500730

>>57500758
Thanks, anon. You've convinced me to give Haskell another look.

>>57500758
>>57500806
re: 100 billion language extensions

https://downloads.haskell.org/~ghc/master/users-guide/lang.html

>>57500706
Typing is just a way to validate your variables - and to tell the compiler how to optimize your code. To validate stuff clojure uses specs, which are currently in the beta release. While, for the compiler optimization - well, it has a lot of type inference going on (that eliminates the problem of Integer and int present in java, for instance) and the complex types are java code anyways (take any object from any java API as an example). If properly optimized, clojure is almost as fast as java itself.
>>57500759
I'm currently work on the development of a server-side app in clojure. We've not yet at the optimization part, but we're getting there; will post results then.

>>57500894
I'm pretty sure >>57500759 was pointing out GC pressure as a problem on Android, not so much the server.

>>57500920
Yeah, but it's always about the JVM. Which is the main reason any fucking android phone ever has a stupid amount of RAM (2GB on a 2014 nexus 4...)

>>57500894
It's not nearly as much of a problem on the server. You usually have a lot more memory to work with, the memory is faster, and the Oracle JVM garbage collector is significantly faster than Android's especially when it comes to the short lived objects that Clojure tends to create. You'll notice that Clojure still spends more time in garbage collection that you're typical Java app but not so much that it's a problem.

Haskell threads are the best. They are like an alternative really /g/ (or /prog/).

>>57500965
see >>57500945
It's about the JVM - even if you have dalvik (now ART, I suppose) and I have the official oracle one.
By the way, you're right about GC not being a problem in the application I'm working on - but apparently clojure is not trying to target mobile devices, so probably it's not really usable on them without any kind of preprocessing.

>>57500894
I had hopes for core.typed but apparently it's a pain in the ass.

https://circleci.com/blog/why-were-no-longer-using-core-typed/.

can somebody walk me through the applicative instance of ((->) r)

>>57502047
Sure

First thing's first, do you understand the functor instance?

>>57497498
I learned C#, Haskell and C++ in university.
I liked learning Haskell and had a ton of fun doing the practicals. Had a lot of those moments where everything suddenly clicked. Since I'm more interested in game development I now pretty much only still use C++, but learning Haskell definitely made me a better overall programmer. Just gives you a radically different perspective on programming languages which is very valuable.

>>57502103
yes, its function composition

>>57502103
>>57502367
Sure, that's how it's implemented. But in a general sense, I mean

((->) r) a

represents a computation that hasn't been completed yet. It's still waiting for input

(I'll just call it (r ->) for readability's sake btw)

If you apply (r ->) to some type ‘a’, you get r -> a, which is a function - or equivalently, a computation of an ‘a’ that's still waiting for an input ‘r’.

So if we look at

fmap :: (a -> b) -> (r -> a) -> (r -> b)

we see that we're “hanging on” another computation. You're still waiting for an ‘r’, but this time you'll get a ‘b’ instead of an ‘a’, because the ‘a -> b’ is applied on top.

Based on this mental model, let's look at the applicative instance functions:

pure :: a -> (r -> a)

‘pure x’ represents some form of computation that does nothing and just returns x. In this case, it's a computation waiting for an ‘r’ that simply ignores the ‘r’ it receives and always returns ‘a’, so the definition is

pure a _ = a

That leaves the other operation (‘ap’). Personally, instead of thinking about Applicative primarily in terms of ‘ap’, I like to think about it in terms of ‘liftA2’. Basically, it lets you do this:

liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> fc

Or even more specifically, I like to think about applicative in terms of

liftA2 (,)

:

liftA2 (,) :: Applicative f => f a -> f b -> f (a, b)

This operation is basically like taking two computations, running them both, and returning both results. (The implementation doesn't really matter, but it could either run one after the other, or it could run them both simultaneously in parallel, or whatever makes sense for the applicative in question)

So let's apply that to our (r ->) model:

liftA2 (,) :: (r -> a) -> (r -> b) -> (r -> (a, b))

(cont)

File: IMG_2804.png (597KB, 800x800px) Image search: [Google]

597KB, 800x800px

>>57497952
And a lot slower. Stick to your LAPACK if you want to be taken seriously, pleb.

>>57502517
(cont)

Basically we want to join two functions (“partial computations”) together to a single function that returns us both results. What the implementation of this looks like is relatively straightforward

liftA2 (,) f g r = (f r, g r)

We literally just apply both functions to the received input ‘r’ and return both results. This alone is already enough to completely characterize and understand the Applicative instance in question.

Although in practice, we would like to go one step further and implement ‘ap’ (aka <*>) instead of this liftA2 (,) primitive, because that's how Applicative is defined in practice.

First off, a refresher of the types and an explanation of how liftA2 (,) and ‘ap’ are equivalent:

liftA2 (,) :: Applicative f => f a -> f b -> f (a, b)
(<*>)      :: Applicative f => f (a -> b) -> f a -> f b

-- defining one in terms of the other
liftA2 (,) fa fb = pure (,) <*> fa <*> fb

fab <*> fa = fmap (\(ab,a) -> ab a) $ liftA2 (,) fab fa

To implement (<*>) directly, it's easiest to just look at what the type ends up as:

(<*>) :: (r -> a -> b) -> (r -> a) -> r -> b

We have a function that generates an ‘a -> b’, and a function that generates an ‘a’, both given the context ‘r’. And we want to produce a ‘b’ given the context ‘r’. So the implementation is relatively straightforward:

(rab <*> ra) r = rab r (ra r)

If you're familiar with lambda/SK calculus, this is also known as the S-combinator (“apply”) - while ‘pure’ is also known as the K combinator (“const”). Together they are actually turing complete. So you could write any program you want using just the Applicative ((->) r) instance! But that's not really relevant here

Proving that these definitions obey the applicative laws is left as an exercise to the reader

>>57502583
> <*> :: (r -> a -> b) -> (r -> a) -> r ->b
this line is what made it more clear
I always thought of it as ... -> (r -> b)

but then reading it as "an eventual a to b applied to an eventual a will eventually give b" made it click

thanks pham

>

>>57502583
unrelated, but what is lambda calculus concerned with
the properties of anonymouse functions?

>>57502813
Lambda calculus is a model of general computation, developed by Alonzo Church, similar to turing machines. They were developed at around the same time to fulfill the same purpose: allowing mathematical analysis of the fundamentals of computation. Turing machines eventually won out because people could get their heads around them better, though.

One of the most important results of early computer science was the church-turing thesis, which in layman's terms states that all models of general computation are pretty much equivalent, which is embodied by the term “turing complete”. No matter what turing complete system you look at, you will be able to compute the exact same space of functions. And in particular, the turing machine itself is a good model of this general class of computation. (But so is the lambda calculus)

So roghly speaking, the lambda calculus isn't inherently “good” for anything, but it's a model upon which you can prove things about computation - for example the halting problem, which in the context of lambda calculus becomes a statement about whether a lambda term has a normal form or not. We just ended up basing most of our theoretical work on top of the turing machine instead, and the lambda calculus lost in popularity except among functional programmers. (who still prefer the LC due to its similary to functional programming languages, and its sheer elegance)

>>57502583
something tells me you about arrows too
I would ask, but I don't wanna trouble that much.
>inb4 "oh, like you're doing now"

>>57502887
Arrows are actually conceptually extremely similar to Applicatives. Their differences are subtle. But basically, Arrows are like a bit more powerful version of Applicatives in that they let the computation also depend on a second input which can be the output of another computation.

In expressive power, this sort of puts them somewhere in between Applicative and Monad. But in practice, the abstraction is different enough that you usually don't directly compare them.

I think the best introduction to arrows from a neutral point of view (without any applicative/monad baggage) is by considering them as ‘signals’ and signal processing. This article illustrates it quite nicely: https://www.haskell.org/arrows/

Basically an arrow is some sort of computation or side effect that has an input and produces an output, and you can “connect” the arrows together

this allows us to represent signal graphs relatively succinctly (using arrow notation), which can be used to model all sorts of dynamic systems

So is learning haskell and using xmonad a better idea than learning lua and using awesome?

>>57502997
btw, here's an example of what arrow notation looks like

proc do key -> do
    let acceleration = case key of Left -> -1; Right -> 1; None -> 0
    speed <- integrate -< acceleration
    position <- integrate -< speed
    returnA -< position

Basically this represents an arrow that receives as input a key (which here means either ‘Left’ or ‘Right’ or ‘None’) and returns as output a position

It does this by turning the key into an acceleration (-1 for left, 1 for right), feeding this as input to the ‘integrate’ wire producing a speed (v = ᚦ∫a dt), and feeding this speed into another ‘integrate’ wire producing a position (x = ∫v dt).

This is not necessarily the most complicated example, but it's an example of the kind of programming techniques you can expect when using arrows.

>>57503127
as an xmonad user I say yes, simply because xmonad is so stupidly flexible. It's basically not even a window manager - it's a window manager framework. You can program your own behavior, and there are hundreds of community-contributed helpers and modes for it.

For example, I use it with the binary space partitioning layout:
https://hackage.haskell.org/package/xmonad-contrib-0.12/docs/XMonad-Layout-BinarySpacePartition.html

This gives me a bspwm-like experience, while also allowing me to benefit from all of my other changes to xmonad.hs. There really is a gigantic list of contributed modes and functions:
https://hackage.haskell.org/package/xmonad-contrib

Anyway, this is my configuration if you want an example of what it looks like in practice:
https://github.com/haasn/gentoo-conf/blob/xor/home/nand/.xmonad/xmonad.hs

>>57503135
Here's a more involved example (a simple “asteroids” game):
https://github.com/ocharles/netwire-classics/tree/master/asteroids

This is the definition of the overall game circuit:
https://github.com/ocharles/netwire-classics/blob/master/asteroids/Asteroids.hs#L238

It also actually uses arrows for sound effects, which is pretty fascinating to see:
https://github.com/ocharles/netwire-classics/blob/master/asteroids/Sounds.hs

Basically the “signals” here are literally just treated like a normal analog sound processing circuit.

>>57503224
>Basically the “signals” here are literally just treated like a normal analog sound processing circuit.
An example, rewritten to be a bit easier to process and with some comments added

death = proc _ do
    -- Start out with some random noise
    n <- noise -< ()
    -- Quantize the noise into steps of 0.2
    q <- quantize -< (n, 0.2)
    -- Reduce the sampling rate to 3 kHz
    r <- rateReduce -< (q, 3000)
    -- Apply a gate filter (only pass samples above 0.3)
    g -< gate -< (r, 0.3)
    -- Reduce the volume over the course of 5 seconds
    returnA -< decay 5 -< g

You're literally just constructing analog circuitry in software :^)

How do I get into the hacky haskell code which is super short and uses things like applicative and liftM and that stuff.

My code works but I think it could be a lot nicer.
I read lyah and now I'm reading real world haskell, on chapter 16.

Some of my crappy code:

https://github.com/ZedPea

>>57503289
danm!
I'll look at those links once I read that introduction article

>>57498298
You mean that fake benchmark where the c code is made as intentionally slow as possible and the Haskell is optimized in a benchmark that's 99% IO based and nobody can produce the results?

>>57502997
im sorry but that link makes no sense to me

>>57498642
>complains about lack of abstractions in C
>likes high level languages that don't make you pay performance penalties for abstractions
Why are you using C instead of C++?

>>57500403
Does this mean Idris is kill?

>>57498490
If you think Java is verbose you'll absolutely fucking hate D. Also, D is dead. It's standard libs are garbage and almost completely undocumented.

Modern C++ shits on D by every objective measurement (i.e. performance, documentation, etc). Also, modern C++ is much less pedantic than Java. The only thing that pisses me off about C++ is the header bullshit-- modules are coming next year I heard.

I agree that Go is a joke.

I want to like Rust, but I'm holding back until it really starts to mature and prove itself (also, sjw bullshit).

For a comfy language to write non-performance-critical stuff in: try Ruby. Ignore the hipster faggotry and it's really quite pleasant. Everything I used to do with Python is so much nicer to do with Ruby-- especially doing things like invoking shell commands.

You might also like C# if you're coming from Java... even if C# has M$'s fingerprints all over it.

>>57498660
>standard O(n log n) comparison sorts
What??? How exactly would one sort without comparing elements?

>>57504397
Nah, Haskell still isn't fully dependently typed and it's not sure if it ever will.

Plus, Idris and Agda both satisfy a much more important use case: they're not turing complete (unlike Haskell)

>>57504443
radix sort, bucket sort, counting sort, etc.

>>57504529
Couldn't you trivially make Haskell not Turing complete via a compiler extension or patch? Like, insert code to count function calls and abort if there has been more than N.

>>57504529
How can a general purpose language not be turing complete

>>57504420
Since you brought up C# in a Haskell thread, mentioning F# in practically required by law. Too bad about the modules in that one.

File: 84a54eb27336dabd7191abb89151c79b6620e3c38b2f8a69abc304a2e3fa0d4f.jpg (69KB, 777x932px) Image search: [Google]

69KB, 777x932px

>>57498461
here is the best way to learn haskell:
https://github.com/bitemyapp/learnhaskell

this series of lectures it great too if you prefer video, the guy is amazing:
https://www.youtube.com/watch?v=UIUlFQH4Cvo

>>57497593
All's good over here

>>57499977
How so? From my understanding the haskell library utilizes a manner through which everything is treated as if it were on the stack.

I know 10000 is an overstatement but I'd like to know about the jump from equal to 2x as slow. Assuming it's a slow process to begin with.

>>57504732
do the videos teach me how to get a job?

File: 3586f2bccaf0809936e4f74fb15b4d0b44b243884e2fb883ff159c34ff596461.png (244KB, 474x435px) Image search: [Google]

244KB, 474x435px

>>57504775
nice meme, go back to coding enterprise software in java pajeet

>>57504775
It depends. Do you want a job in porn?

>>57502517
What is

((->) r) a

?

>>57505000
a function which takes an r and returns an a
better read as

 r -> a 

thus

r -> or (->) r

is a function wich takes an r and will returns a given input

>>57505057
In which context?
Can you provide me a link to its applicative or functor instance?

>>57497952
>agreed, just try simply transposing a matrix in any object oriented language.
>MATLAB
matrix'
>R
t(matrix)

>>57505101
read the thread

File: 1470091939157-1.png (11KB, 307x373px)

11KB, 307x373px

Are there any open source video game projects in C that need contributors?

I asked on reddit but everyone posted projects in C++ which I don't want. The only open source game in C I know is Space Nerds in Space but that's a bit too complicated for me with the 5 pc setup and the fact that it's 3D.

>>57504641
Well you could make it trivially not turing complete, but the challenge is making it non-TC while still being a useful language.

That requires a good termination checker, which is non-trivial. It also requires some new language features so you can do stuff like drive infinite loops without requiring turing completeness.

>>57498252

Learn You a Haskell is the "bible"

>>57504683
A few notes:

1. Non-TC languages aren't usually designed as general programming languages, but as domain-specific languages for constructing proofs via the Curry-Howard isomorphism. Look up Coq for a great example of a programming language which is entirely based around being a proof assistant.

2. Non-TC AKA forced termination lets you statically avoid a lot of bugs like infinite loops and compiler non-termination (e.g. what happens in C++ and Haskell if you try and construct an undeciadble type)

3. You can still write a gigantic class of useful real-world programs without requiring turing completeness, including interactive programs (by using codata and a RTS capable of driving your infinite request/reply outer loop)

4. Both Agda and Idris let you manually turn off the termination checker for a specific function. So if you're absolutely certain that it will halt, but it's too complicated for the termination checker to prove the same, you can still gain access to general computaiton that way.

>>57505741
It's not quite video game development, but mpv uses OpenGL and (in development) Vulkan heavily. If you want to work on a graphics engine, you could help mpv, especially w.r.t to the vulkan support. (Which is currently stalled, waiting for motivated people)

File: 1472125253470.jpg (140KB, 960x540px) Image search: [Google]

140KB, 960x540px

>>57505862
eh...I kinda don't, but I might have to settle for a compromise. I really want to try video games though, seems like it could be fun.

Maybe I just have to start my own thing, something simple like a metroidvania or a shmup, only C and SDL2 as the only dependency, light and portable. It's just that when I work alone, half the time I spend making the assets and when I work in something really high level like LOVE, the assets take more time than code and usually don't look that good since I'm only a hobby artist.

When I eventually make a startup we will use Haskell. It's probably an enormous mistake but I don't really care. I want to use it.

>>57506105
Haskell is a good lingo, just because a language isn't used everywhere doesn't make it bad. There are companies that use it and afaik it cuts development time by a decent bit. The worst part will be finding programmers who can code in it though.

>>57506303
There are more programmers willing to write Haskell then there are companies hiring I'd guess.
The worst part will be writing libraries, although I do think that nowadays there are actually quite a lot of useful libraries around.

File: sort.gif (219KB, 899x455px) Image search: [Google]

219KB, 899x455px

>>57504443
You don't want to know how many answers that question has.

If you want to be really efficient just use bogosort, all the cool kids are doing it.

File: 1458637469176.jpg (33KB, 400x400px) Image search: [Google]

33KB, 400x400px

>>57505862
Oh ok, I can't even do that because Vulkan is not supported on my gpu, gotta get a new laptop sometime soon. fuckin lol'd

File: stefanie-joosten-nightie.jpg (40KB, 600x800px) Image search: [Google]

40KB, 600x800px

>>57505741
Well after some more searching I actually found some, here they are for those interested:

https://libregamewiki.org/Category:C_games

They're mostly old and weird(fucking GRUB Invaders what the fuck) stuff though but w/e, it's something.

File: 1479065269535.png (121KB, 300x300px) Image search: [Google]

121KB, 300x300px

>>57500791

>>57506347
But you ARE still comparing elements. Just not comparing all to all.

File: 5a31e57fbf.png (168KB, 378x343px) Image search: [Google]

168KB, 378x343px

>>57498305
>>57498272

>They don't use APL for complex algorithms and theorem proofing

>>57500193
That's what recursion is for. Also, the forM function from Control.Monad is kinda similar to a for-loop.

>>57498020
BASED HAASN

HASKELL MPV WHEN

>>57497533
/thread

>>57504306
Maybe because C++ is shit and has an absolutely horrible type system

>>57506587
No, you don't need a comparison primitive to implement something like radix or counting sort.

>>57497498
it's a meme.
One of the most famous projects I know that use it have actually said they're rewriting everything in c++

File: 3dpd.jpg (50KB, 1280x720px) Image search: [Google]

50KB, 1280x720px

>>57499977
?¿?

import Control.Monad.ST
import Data.Vector.Generic.Mutable
import Data.Vector.Generic
import Data.Foldable (forM_)

-- vector != matrix, yet shows the pattern
invert :: (Vector v a) => v a -> v a
invert v = create stvec
  where
      stvec = do v' <- thaw v
                       forM_ (<lambda here>)
                       <more stuff on v'>
                       return v'

Granted, not easy to know where to look for, but is hardly a mess

>>57500013
I am a mathematician and I like haskell (but I don't work on it)

>>57505101
the

 (->) r 

monad instance is basically the reader monad, ie you have access to the r "environment" on it. Granted no very useful but works to make code generic (lens uses for view)

import Control.Monad.Reader

sum2 :: Reader Int Double
sum2 = -- Look, no explicit arg
  do n <- ask -- here we bind the argument Int
       let new = if n > 10 then n else n + 2
       return $ fromIntegral new

>>57510809
Do you work with any programming language for your math work routinely? Or is it more by hand?

>>57510893
probably just uses mathematica or matlab lmfao

>>57497593
What? Being smart?
Ok.

>>57510893
mostly Gnu R & MatLab are standard here. Python (numpy) is taking the place of the last. When you have one-on-one projects with a teacher you can use whatever you want and there I use haskell. I had a wavelet analysis class where I made good use of Arrows

>>57503955
you mean pointless style? :)
sometimes that turns out longer than pointful code

>>57503955
>How do I get into the hacky haskell code which is super short and uses things like applicative and liftM and that stuff.
Learn more haskell, and look at more code golf

How does Haskell's concurrency model compare to Erlang's? Erlang's actor model is the best I have used but it is notoriously hard to apply static typing to.

>>57498348
>doing it in O(mn) time when it can be done in O(1) time

>>57511819
Haskell has a really great runtime for parallelism and concurrency written by Simon Marlow.
Haskell has a library for doing actor model concurrency but it doesn't support network distribution yet.

>>57511819
Erlang is proven in the real world where Haskell concurrency is good for trivial examples and fails for everything else. It also performs like shit for anything beyond 6 cores.

>>57513280
>It also performs like shit for anything beyond 6 cores.
Why? Is there something I can read about it?

Also, if Haskell really is bad at nontrivial concurrency, is there anything Erlang-tier or close that's statically typed? Don't say Akka because its actors are untyped and typed actors aren't recommended.

>>57513408
What he says is bullshit (except erlang being tried and true).
Haskell has a great run time system for concurrency that scales extremely well beyond 6 cores.

If Haskell sucked at using anything more than 6 cores then Erlang should too as Haskell's threading model is very similar to Erlang's.

>>57497593
>Being smart is bad
whoo boi

Anyone got a pdf of either of the books from
http://haskellbook.com
http://www.cs.nott.ac.uk/~pszgmh/pih.html
and willing to share them? TIA.

>>57514015
libgen.io
find them yourself

>>57513466
Feel free to benchmark it idiot. It not working well beyond 6 cores is a known problem.

>>57514878
The only source for that statement that I can find is 2 reddit comments from 3 years ago. And there's large bodies of evidence such as https://www.fpcomplete.com/static/uploads/2013/05/Bump%20case%20study.pdf that completely contradict your claim

>>57515090
Kys
http://community.haskell.org/~simonmar/papers/multicore-ghc.pdf

>>57515111
>2009
>8 threads, ran well with 7
>"the OS thread running this HEC has been descheduled by the OS, so does not respond for a relatively long period"
So it wasn't even haskell's fault

>>57515153
You can find problems like this in every single Haskell paper that tries to utilize more than 6 cores. Usually the problem is caused by GHC.

File: hitlary.png (3KB, 740x740px) Image search: [Google]

3KB, 740x740px

you don't like the language because it's logo looks like hitlers logo

>>57515299
That paper you linked is literally from when they implemented the run time. Today it's much more performant.

>>57515385
Nah. It still has lots of problems scaling to a large number of cores.

>>57514819
Thanks, I had forgotten the name of that site.

>>57497855
Coq/Agda/Mathematica/MATLAB

Don't get me wrong, I like Haskell, but this isn't really something it's used for.
Although there is a Jupyter Haskell kernel if you determined to do something with it.

Is it just me, or is LYAH actually not that good?

>>57515837
>>57515111
Interesting. Do you run Haskell in production, anon?

>>57515970
I work at an investment bank that ditched Haskell for F#. Funnily enough we're one of the banks that Haskellers always bring up as "Haskell success stories."

>>57515950
The humor is trash, but I think the casual style makes for a decent introduction.

>>57516050
How's F#? Is the CLR good at concurrency? Does it have something like http://www.paralleluniverse.co/quasar/?

>>57516119
CLR just uses OS threads for doing concurrency. That is really heavy.

>>57516119
Doesn't have anything quite like Quasar but it has Orleans and Akka.NET if you want actor style concurrency. Both are pretty solid and are used in massive production systems.

>>57510809
>I am a mathematician
What does that mean? You're a grad student?

This is tail recursive, right?

sum_tr :: [Int] -> Int
sum_tr = loop 0 where
  loop t [] = t
  loop t (x:xs) = loop (t + x) xs

So how come it blows up the stack?

*Main> sum_tr [1..2^24]
*** Exception: stack overflow

>>57516464
Probably the same problem as the one shown with foldl at https://wiki.haskell.org/Foldr_Foldl_Foldl'
Try

foldl' (+) 0 [1..2^24]

>>57516464
>reinventing the well
no, make t strict and it shall be

wtf, you'd think that sum would foldl'

File: 2016-11-14-180946_302x122_scrot.png (4KB, 302x122px) Image search: [Google]

4KB, 302x122px

what is this sorcery

{-# LANGUAGE BangPatterns #-}

sum_tr = loop 0
   where loop !t [] = t
              loop !t (x:xs) = loop (t + x) xs

>>57516352
High school.

>>57516810
So even though it's tail recursive, new frames are still made due to lazy eval.

>>57516841
>>reinventing the well
Sorry I'm just trying to learn.

>>57516970
nevermind, I compiled sum_tr and it gave 0.69s

>>57516464
You're never forcing ‘t’

add a !, like

loop !t [] = t

>>57517238
>>57516970
Is there any meaningful difference between !t and seq t whatever?

>>57516464
if you're running into performance problems or stack overflows, a general first thing to do is to add

{-# LANGUAGE Strict #-}

>>57517248
No. A pattern match with ! literally desugars to ‘seq’

>>57515950
Yeah its bad and hand wavy.
Check out http://haskellbook.com instead.

>>57518039
fuck off shill
nobody is going to read your book

LYAH is the standard and the best around

>>57501083
Aye, do look up clojure.spec in the 1.9 alpha though. Check assets with spec/assert during testing then compile to production without them to keep performance.

>>57518638
not him but LYAH is seriously outdated and a terrible introduction

I recommend brent yorgey's haskell material

>>57520770
LYAH makes more sense and is shorter
no inane shit like "excercises"

try clojure or elixir instead; or scheme. You could just as easily learn how to do FP through another language but without the fanboy-ism over type systems. You'll mostly write in a functional style in any language that lets you without really thinking about it after you learn how

File: 657498393.jpg (63KB, 970x1117px)

63KB, 970x1117px

>>57518039
>paying for a book

>>57521116
It also teaches outdated Haskell and bad mental models that people of #haskell etc. have to work hard to un-teach again

File: Cover2.gif (18KB, 148x188px) Image search: [Google]

18KB, 148x188px

>>57520770
>brent yorgey's
I'd say Simon Tompson is a good read

Haskell
The Craft of Functional Programming
Second Edition

Simon Thompson

Addison-Wesley, ISBN 0-201-34275-8

>>57521331
Immutability ("FP") and type safety are pretty orthogonal concerns.
>scheme
Clojure and Elixir are better recommendations because in Scheme the base data structure's mutable.

>>57512008
>if i don't see how it works inside i can assume O(1)

>>57524285
Nah dude, just reinterpret the array dimensions

happens purely in the type level. It doesn't even have a runtime cost

>>57521847
>bad mental models
Interesting. Can you give some examples of these?

>>57525676
“a monad is just like a box!”

>>57502887
I just remembered this: http://lpaste.net/94914

For a gentle introduction to arrows, look no further