Name a more difficult to learn language

Attached: haskell-logo.png (397x131, 7K)

Other urls found in this thread:

stackoverflow.com/questions/39541312/function-returning-a-closure-not-working-inside-my-filter
hackage.haskell.org/package/uni-htk
twitter.com/NSFWRedditVideo

C++

Assembly language

FORTH
but it is so worth it

Attached: Oscar_Wilde.jpg (400x600, 38K)

It's not difficult at all

Boom
/thread

But seriously, C++ is actually very easy if you approach it the right way and concentrate on the higher-level aspects. But when you're ready to go deep and get down to nitty gritty details C++ is waiting there patiently ready to fill all your needs.

Haskell... is like a castle. It's brutal to climb straight up to the top of its wall while an army of orcs rains arrows on you. But when you do finally get it... it's like a virgin princess that would make your family proud and everyone else jealous but ready to give blumpkins and rimjobs in bed if that's what you want.

Please. Haskell's not even that hard
-- Haskell
four = 2 + 2

NB. The J language
]four=.+/2 2

99% of the "difficulty" of Haskell is from people abusing the type system to abstract stuff into libraries and then not documenting the libraries very well (monads are an example of this) but the language isn't inherently arcane and you can teach yourself even the goofiest abstractions by having a good grasp of the individual language features and just reading the code

Whereas there's just a critical mass of fuckery you need to have mastered before you can read a single line of J code

Vanilla JS.

This. What the hell is OP on about?

visual basic

Ok. Explain Monad Transformers and Lens to me.

Quasi-quotes

{-# LANGUAGE QuasiQuotes #-}

fNeedle :: (Int, Int, Int) -> (Int, Int, Int, Int)
fNeedle = [nd|
}=={(+1)}=\==========================>
\
}===\ \ /============>
\ \ /
}=) \ (==={uncurry div}=/={negate}===>
\
\=={(*2)}========================>
|]

Type wrappers for convenience.

Data traversal utility

depends, moron
some can be very comfy (mips) and some just are terrible (x86)

1) fpbp
2) checked
3) /thread

C++ is easy compared to Haskell. I challenge anyone in this thread to ask me anything about C++.

C++ is complex in it's breath. Haskell is complex in it's depth. It's the latter that makes a language difficult to learn. C++ just takes long to learn.

Scala, also the best language in existence

Scala is okay but has serious flaws. I saw this as a professional scala developer... Haskell is better.

Agda

Wow that was hard desu.

>look at me, I can spout complicated sounding jargon and buzz words

Attached: file.jpg (800x450, 45K)

Let's see faggot.

What are the differences between type inference with auto keyword and template argument deduction?

brainfuck. But that's because I can't into programming, just scripting. Until I can find some medication that helps me focus and not get distracted every ten seconds, I'll never be a programmer. Adult ADHD is a fucking cunt.

The only novel parts of haskell are in the rich type system. Disregard monads and functors and all the abstraction and haskell is just as simple as any other language. You really only need to understand how they work if you want extremely expressive code.

Take Elm for example. It's literally just haskell with a gimped type system. You can learn the entire language and be productive with it in a weekend.

golang

trying to read the examples is just like reading moonrunes man

Dexedrine or Adderall, they work really well too. I don't take it anymore because it basically turns you into a robot zombie with no personality, but holy fuck does it ever work to help you focus and get shit done. There's a good reason why college/uni students take it to study/focus on work.

Not who you responded to, but this was such great bait.

According to Effective Modern C++, before N3922, deducing the type of a bracketed initializer gives an std::initializer_list (patricians: this is kind of like a fucked up product type because C++ has no introduction forms) for auto declarations even when there's a single entry. Not so for template type deduction. As of C++14, the behavior is identical.

I've had to learn C++ thoroughly. There's not as much there as you seem to think.

> B-b-but muh language lawyering of C++ proves I'm jus as smart as those kids studying category th-theory!
C++ pseuds are precious.

Attached: grothendieck_with_little_baby.jpg (2048x1536, 721K)

Is there a single actual good reason to learn this?

Attached: 1500261898309.jpg (935x799, 198K)

>Learn how sums and products are supposed to work.
>Learn list comprehensions, pattern matching, currying, typeclasses, modules, and all the other shit normie-tier languages are now copying incorrectly because they eliminate problems with large codebases.
>Learn to separate functions from effects.
>Completely sidestep null reference errors because of type safety.
Only if you don't like being a pleb.

Are you sure?

Attached: 03577ce7ebf0917.jpg (200x262, 40K)

If you say "gullible" really fast, it sounds like "lemonade."

>any answer except malbolge
normies

You got it backwards.
x86 is pretty straight forward.

studies show that pure functional languages are more intuitive and easier to teach
its not my fault that you're a brainlet

Attached: yande.re 439162 astolfo_(fate) fate_apocrypha fate_grand_order fate_stay_night kusumoto_touka pantyh (1955x4095, 387K)

No one fucking said anything about that. The writer of "First principles in Haskell" said he needed 5 years to get Haskell.

The author of Lens said he tried 9 times to get category theory before he finally pushed through.

Fuck off. It takes months to write anything in Haskell, other languages are nowhere near.

your retarded

Attached: .jpg (2000x3820, 472K)

Yeah, dude. Just take out everything that makes a language what it is - aka good. What the fuck is that kind of logic? Just take pointers out of C man, see, it's sooo easy.

cool argument, gook fag.

reddit spacing

**yore

Attached: 1515216581123.jpg (496x672, 98K)

Which studies?
In our functional programming course, where we were taught Haskell, nearly nobody understood much at all.
Even making a tree data-structure was too difficult for most.

No. Not unless you like using something esoteric just for the sake of not being part of the norm.

That is C

That's true actually.

Nasa restricts the use of pointers in their C style guide, it's completely possible to use C for complex systems without them. Just like it's completely possible to use haskell without understanding monads.

Rust. The Borrow Checker is like an asshole genie that floods you with error messages if you don't word your wish exactly right.

Attached: rage.png (291x300, 16K)

unlambda

I'd rather say name a more useless language.

Yes one can undoubtedly learn Haskell, it is not that hard like some brainless people say, but I literally see no point in using it

>Strange concepts which don't find their place IRL
>Fucked up syntax
>A tradition of giving functions/arguments nonsense one-letter names
>Not production-ready
>Fat runtime w/costly abstractions; big bin size (not critical today)
>Less libs than any big dog
>Used by less than few companies in the world and has very few open-source projects (compared to top 5 langs)
High entry barrier

How about you ditch your visual basic programming style rather than posting red faces and complaining?

how about

>it's really fun
>allows you to write "safer"
>entry into cooler concepts about types and formal verification
>generally the haskell community has a love for abstractions that allows it to write less govnokod

I'll take Monads over Templates every day..

>OMG it has MATH in it, it has to be difficult

>C
>not being part of the norm

This triggers the shit out of me.

Guess what your OS, Server, databases and so on are written in?

This.
But even then I'd rather learn Lisp than Hasklel.

Malbolge

Agda
ATS
Coq
F*
Fucking Scala
Idris
Mercury
Shen

Enlightenment.

From the top of my head, template argument deduction perserves cv qualifiers and whether the type is a reference. So does decltype(auto).

auto removes those things.

These are actual things in Haskell though.

I haven't used it in real life. Do you run into issues with the laziness?

The learning curve only feels steep because you basically have to learn programming all over again, since it's such a different style. If you put as many hours into learning Haskell as you put into learning "normal" languages you would be just as productive in either.

Our university teaches programming in one high school. I discussed it some time with a professor and he said they tried to teach programming with functional and failed. At some point they hit the underlying structures anyway (like call stack).

Same here, although I personally think that FP is very intuitive. I think the difficulty in Haskell starts at monad transformers, that's where it becomes tiring and I don't understand why people struggle with folds on lists and simple data structures when it's the comfy part of Haskell.

Not really, I think. If you know an ML it's not that different.

nobody said they weren't user, just that such terms are made to sound more complicated than they really are by laypeople who don't know what they mean. Just look at all the bullshit surrounding Monads/Functors/Applicatives/etc, which are actually pretty straightforward concepts.

>start learning Haskell through books and online Russian scientists
>start seeing Haskell appreciation threads
Comf

Attached: 1513554017166.jpg (480x473, 18K)

I've been learning Haskell too and having a blast!

this, especially if you plan on writing your own decompiler
x86_64 is a clusterfuck

You think the BORROW checker is difficult? Nigga, you're like two weeks in.

Please explain the answer to my stackoverflow question.

stackoverflow.com/questions/39541312/function-returning-a-closure-not-working-inside-my-filter

I have no idea what the guy wrote, but he fixed my code

+ Great language to learn functional concepts
+ Probably the best language for writing parsers and lexers
+ Great for writing programs heavy on math
+ Can be made to run in parallel trivially and deterministically
+ No side effects
+ Abstraction levels close to Lisp

- Difficult to learn
- Very memory heavy
- Relatively small library
- Difficult to make GUIs
- Monad Transformers are ugly
- Very slow for some tasks unless you give up purity

I could list some more.

my uni has haskell as the first language we learn and for me I never found it difficult. a few years later it is still my "main" language. maybe its difficult if you are already entrenched in other paradigms?

erlang

what's the connection between fun langs and parsers and lexers? i see it alot

Japanese

I'd say it's because languages that are fun to use are expressive and build upon themselves, it just so happens that that's useful for building parsers.

explain to a brainlet how
1 || 1
is incorrect syntax
why does False || True
return True
But 1 || 2
gives an error ?

kek, u wot m8

you'll be enlightened by your own intelligence

Rust
APL
ADA

if you have to ask, don't bother. Haskell is a language for people that actually want to understand programming and be good programmers. Consider pic related instead.

Attached: file.jpg (600x788, 63K)

Pass my class.

Nix, It is what you would get if haskell and json had a fugly child.

Because they're numbers not bools you fuckstick

JavaScript, unironically.

c++
why would anyone use c when c++ exists lol

Itanium assembly.

hello

but 1 and 2 are not the same
so i thought it would return false

If one of the things on the sides of || evaluates to true (or is just simply true) it will return true.
Numbers are just the wrong type (unless maybe some language can consider 0 and 1 to be bools

Not knowing that it's good for understanding programming and becoming good at it doesn't mean he thinks it's useless to understand programming and become good at it.

are you retarded?? what the actual fuck

>hurr durr category theory is buzzwords
Haskell isn't machine learning (chain rule? sounds old and easy, let's call it backpropagation!).

Attached: 1515283855286.jpg (645x729, 49K)

fucking this, I am fluent in Haskell but I have been spending the last three days ripping my hair out trying to figure out how to modify a simple nix expression

How do you say "my hovercraft is full of eels" in Haskell?
Nix is great, wish i had the need to write nontrivial nix expressions. All i need is a simple per-project nix-shell.

> maybe its difficult if you are already entrenched in other paradigms?
When I started learning haskell I had some imperative background and that was somewhat blocking me being comfortable with the language. After all "why can't I put a variable here and be happy?". But after thinking a while I am sure that if you haven't seen imperative (aka evil) code a pure-functional language is actually more easy to grasp

It's called "a damn good type system" niggers

You're right.
When I was in University, Haskell was the first language. It was pretty good at getting us to think about programming in the right way.
For example I know some struggle with OO but if you're used to thinking functionally it seems simple from the start. I've also heard people struggle with recursion which just seemed easy to me.

>- Difficult to make GUIs
hackage.haskell.org/package/uni-htk
Tk has typed Haskell bindings, and it is literally the easiest way to GUIs.

Academics are into both.

Malbolge

>it doesn't mean he thinks it's useless to understand programming and become good at it.
people who actually think it's useful to understand programming and become good at it, tend to do their own research and not ask retarded b8 questions on anime image boards of the
>this is shit, prove me wrong lmao
variety.

Never give undue credit and underestimate how many lazy pajeets inhabit the earth user.

Attached: file.png (1230x287, 32K)

see brainlet

mercury

Coq.

>terms are made to sound more complicated
You're the brainlet here. Try to convey exactly the meaning of applicative functor without relying on its definition. Takes a few good paragraphs to avoid confusion, even though the "concept" is simple.

huh?
If you want an expression that returns false because 1 and 2 are different, how about:
1 == 2