https://www.haskell.org/
http://www.schemers.org/Documents/#intro-texts
http://www.scala-lang.org/
http://elm-lang.org/
http://miranda.org.uk/
https://www.functionalgeekery.com/
https://jobs.functionalworks.com/#/job-board
http://www.logicmatters.net/resources/pdfs/GentleIntro.pdf
>>54407442
Miranda. Heard of it. Wonder if people use languages like that and ML still
>>54407442
Who is this qt?
>>54408594
credited to >>54400354
>Functional Programming & Math: General
https://www.gov.uk/jobseekers-allowance
http://www.edd.ca.gov/Unemployment/Ways_to_File.htm
https://www.medicaid.gov/medicaid-chip-program-information/by-population/autism-services.html
I approve of these threads
I'm starting to get back into Haskell. There are two underrated books on the subject
>Functional programming using a computer
>The Haskell road to math logic and programming
Though I can understand why they are not that used among programmers, since they are not books for learning haskell per se, but for learning math. Still good for the mathy types like me. They talk about math, not CS. No continuations, no evaluation; logic and proof.
>>54408860
my sides
Why isn't there a a larger presence of functional programmers on /g/?
>>54407442
Semen demon
>>54407442
Are tuples the equivalent to an object in Haskell?
>>54408300
>languages like that
Haskell is heavily based on Miranda.
>>54409277
Functional programmers are more intelligent and thus rarer. People can argue back and forth all they want, those who take their time to learn languages with low market penetration that are based on complex mathematical concepts are plain more intelligent than the average Java/C/Python monkeys.
GHC is seriously an engineering feat on the order of Linux, GCC etc. Without it, typed functional programming would be orders of magnitude less advanced. If Simon Peyton-Jones ever needs an organ transplant, I am willing to sacrifice myself.
Why should I care about functional programming when literally every problem can be solved more intuitively and more efficiently by imperative programming languages? I don't see any mathematical beauty in the convoluted and tedious construction of Haskell code.
>>54409807
You're either baiting or a fucking moron.
>>54409629
>those who take their time to learn languages with low market penetration
By taking the time to learn languages with low market penetration, I realized that functional programming isn't all that great. A lot of things that they say come from functional languages actually didn't. Compared to Java or JavaScript, it seems good for some kinds of programs, but it's really a mistake that these people wasted 20+ years on but don't want to admit that. OOP caught on after the FP hype died down because FP was a failure the first time around. Pattern matching is good, but that didn't come from functional languages.
>that are based on complex mathematical concepts
There's nothing more or less mathematical about Haskell than there is about Java or any other programming language. Take the time to learn about the mathematical principles behind OOP and imperative programming. Some universities actually stopped teaching that because they were pushing functional programming so hard.
https://news.ycombinator.com/item?id=7957764
Here's an example of that. This guy's university lied to him and he doesn't even know it. It's a shame to pay for an education and not get it.
>>54410203
>OOP caught on after the FP hype died down because FP was a failure the first time around
[citation needed]
>>54410203
FP and imperative languages are considered "turing-complete" (ignoring memory requirements) and thus can theoretically do the same set of computable task.
I ask this as a newbie and this question isn't meant to be rhetorical as I honestly don't know the answer to it...but from my understanding languages like Haskell are pure FP languages based on Lambda Calculus and hence produce no side effects due to referential transparency... from my understand Java does produce side effects... due to this structural difference Haskell seems to require to use mathematical concepts not required in Java... e.g. applications from category theory and algebraic structures. Where in Java is this required on a "normal" basis?
I think one reason Haskell has a higher ceiling is due to the mathematical machinery required due to it's FP programmatic nature and no side effect built-in restrictions. When you write in programming languages that bypass these issues you aren't using such heavy math to do something that would be "simple" within the language.
In other words... I think Haskell requires more mathematical thinking and thinking is something some people would rather not do.
>>54407442
what are some good functional data structures other that lists?
>>54410143
He's baiting. Anything you see 'the ape' associated to a reply don't bother reading it.
>>54410549
>applications from category theory and algebraic structures. Where in Java is this required on a "normal" basis?
; and . are composition operators.
All objects are algebraic structures.
theres a reason no one uses or encourages these languages anymore
>>54410968
why? generally curious
>>54410968
Java 8 is a functional language and is being heavily used in production
https://plumbr.eu/blog/java/java-version-and-vendor-data-analyzed-2016-edition
>>54411627
Java 1 already included the entire lambda calculus (one-method objects), as did Simula 67 and Smalltalk.
FP died out in the 90s because OOP is more powerful.
>>54408874
if you're into logic and proofs, I'd really recommend checking out Idris. it's basically a cleaned up Haskell with dependent typing, so a lot of the code you write is theorem proving code to verify the program's safety. or if you're looking for a good proof assistant, Agda is awesome for that and uses a syntax very similar to Haskell.
>>54409502
records and type classes as the interface would get you closer. tuples are meant to be used for small values (or types that don't deserve a name)
>>54409807
efficiently in terms of performance, sure. but FP solutions are generally more intuitive to design and are much more efficient on the programmer's time (less work to write, easy to debug)
>>54411668
and Common Lisp included all of OOP much before the creation of Java... objects and closures are equivalent on a theoretic level
Dependent types have sealed the fate of FP as the one true programming methodology.
OOP nerds in shambles.
>>54411758
>FP solutions are generally more intuitive to design
There is nothing intuivie about weird shit with monads when you only want something as simple as a user input.
>>54411758
>objects and closures are equivalent on a theoretic level
Objects and stateful (i.e. procedural) closures are equivalent. If the closures don't have state, objects are more powerful.
These stateful closures were sometimes called "procedural data structures" and the concept was inspired by Simula objects.
>>54411799
Objects can be dependently typed.
>>54411799
>OOP nerds in shambles.
oh no
>>54410549
>Haskell seems to require to use mathematical concepts not required in Java
Java actually requires the same concepts to do the same things. The docs are just less formalized and more explicit about what you're doing.
Here's Java Comparable vs Haskell Ord[ering]:
Java:
>Compares this object with the specified object for order
>The implementor must ensure sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) for all x and y
>The implementor must also ensure that the relation is transitive
>It is strongly recommended, but not strictly required that (x.compareTo(y)==0) == (x.equals(y)).
Haskell:
>The Ord class is used for totally ordered datatypes.
Both languages require basically the same things of the implementor, but Haskell assumes you're familiar with or willing to look up "total ordering".
Here's Java Stream.reduce vs Haskell mconcat:
Java:
>Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
>The identity value must be an identity for the accumulator function.
>The accumulator function must be an associative function.
>This is a terminal operation.
Haskell:
>Fold a list using the monoid.
Both languages require the same things of the implementor, but Haskell assumes you're familiar with or willing to look up "monoid".
I actually love Java's lambdas and Streams API, make a ton of shit much easier and faster
I'm still waiting for a language with subtypes (or refinement types or whatever they are called). I want to easily be able to say something like:
type posint = {x : int | x > 0}
I know Liquid Haskell has this, but that is still experimental. Idris can probably do this, but I don't know how.
>>54412056
That was in some imperative languages from the 1970s.
>>54411877
The point is that you won't be making any money with OOP in 15 years, you fucking idiot.
>>54412189
You probably mean Ada:
subtype Positive is Integer range 1 .. Integer'Last;
That's a start, but I really want to be able to use any constraint that evaluates to a boolean in the language. With Ada, I don't think I can do something like:
type url = {x : string | is_url(x)}
>>54412280
oh no, in 15 years when i'll be so wealthy that i'm gonna NEET off the rest of my life
>>54412314
In a type theory with dependent sums, the url type you gave is a dependet sum:
∑x : string . is_url(x)
>>54407442
FOUND HER
https://www.warbyparker.com/eyeglasses/women/dorset/coastal-blue-fade
>>54407442
Compare functional programming to asm.
>>54409807
FP is nothing but a meme, only academia math fags jerk to this piece of useless garbage.
>>54411818
theres a lot of functional languages that embrace side effects (swift, common lisp, etc)
>tfw you will never go to MIT in the 70s
how do I into equational reasoning?
>>54407442
>mfw people say 'math'
The word is MATHS
>>54417310
britfag detected
>>54417310
Do you also take ECONS and CHEMS class?
Is this the greatest meme of our time?
>>54418829
>Do you also take ECONS and CHEMS class?
MathematicS.
Chemistry.
Do you notice a difference?
>>54418829
I say ecos
>>54417310
No it's NOTS
>>54419241
I wonder why you didn't do ECONOMICS...
>>54416056
KEK
>>54419241
Your glaring omission was just as planned.
Economics Mathematics ...
ECON MATHS
Do you notice a difference?
>>54419241
>>54417310
What other abbreviations randomly tack the end of the word on?
>>54419193
What
>>54412314
>that's a start, but I really want to be able to use any constraint that evaluates to a boolean in the language
Might I introduce you to Ada 2012? It can do that. Subtype predicates is what you're after. Your example would look something like the following:subtype URL is String
with Dynamic_Predicate => Is_Valid(URL);
>>54410553
Almost all data structures have a functional / persistent equivalent (you can read Okasaki's work) — Trees, Heaps, Streams etc
That said, Zippers are really interesting
>>54412056
F* can do this — you can't run F* directly but it can generate OCaml / F# code.
>>54407442
>Haskell presenting itself as the "purest" functional langauge
>to get anything practical done, you need the I/O monad, which leads to side effect
My sides..
When will people accept that Haskell is only useful for very specific and scientific tasks?
Do yourself a favour: learn Scala.
In two years you'll thank me.
>>54423281
I have been curious about scala for a few months, becouse I want to try a functional language and scala keeps popping up everywhere in terms of actual usability
Could you tell me your reasoning why you like scala? What kinds of projects is it best suited vs other languages
In short: tell me about scala! Why does it wear the mask (of the JVM)
>>54423502
Oh well..
First of all Scala gives you the choice to use it in a functional way or like Java. Some purists will frown upon that, but fact of the matter you will sooner or later run into tasks that are very difficult in functional programming and easy in non functional programming. So you have the superpowers of a functional language and a way to cheat for specific tasks, where it is appropriate (in reality there are stuff like minor tasks and deadlines..) and it's nice to have a "backup plan".
Also Scala is very beautiful. It's so beautiful that many Java devs try out Scala and when they come back to Java after some weeks they feel like "oh, where are my nice Scala features?" Of course you might argue that Haskell is even more beautiful, but Scala gives you the possibility to leverage the JVM (with portability, acceptance in industry, the libraries, core dumping, ..) .
>tl;rd Scala is the best of both worlds, Java and Functional programming
>>54423858
but Java 8 is functional, which according to your logic makes Scala obsolete
>>54423858
Thanks, that explained the utikity of scala beautifully, and im sold
>>54424133
Is it really? Is java 8 = scala + more?
>>54423858
>Scala is very beautifulimplicit val option = new Traverse[Option] with MonadPlus[Option] {
def point[A](a: => A) = Some(a)
def bind[A, B](fa: Option[A])(f: A => Option[B]): Option[B] = fa flatMap f
override def map[A, B](fa: Option[A])(f: A => B): Option[B] = fa map f
def traverseImpl[F[_], A, B](fa: Option[A])(f: A => F[B])(implicit F: Applicative[F]) =
fa map (a => F.map(f(a))(Some(_): Option[B])) getOrElse F.point(None)
def empty[A]: Option[A] = None
def plus[A](a: Option[A], b: => Option[A]) = a orElse b
def foldR[A, B](fa: Option[A], z: B)(f: (A) => (=> B) => B): B = fa match {
case Some(a) => f(a)(z)
case None => z
}
}
>>54424133
>but Java 8 is functional
Java is NOT functional.
Just because Java finally decided to include some basic lambdas/streams (like every programming language of the last decade) doesn't make Java functional. It's basically syntactic sugar.
Of course you can write "functional style" in Java, just like you can write "OOP style" in C. But the language is not specifically designed for that.
>>54424287
OK, now rebuild it in Haskell and then do your comparison..
I doubt that the Haskell version will be more readable.
>>54409607
yeah, that's where Haskell's bad parts come from
it would have been better if David Turner would not have contributed to Haskell
>>54424791
>Java is NOT functional.
it's functional enough to not be a pain in the ass anymore, and yet doesn't go overboard with it
>>54423281
As a profressional Scala programmer, I can safely say you are completely wrong. Haskell is far superior for general purpose programming tasks. Scala's only benefit is being on the JVM, which is necessary in certain business situations.
Haskell code doesn't need to live in IO. I largely use the classy optics technique in my production Haskell code.
>>54423858
>tasks that are very difficult in functional programming and easy in non functional programming
Name one. Functional programming is not a trade-off. Referential transparency costs nothing, and gives rise to equation reasoning, which provides strictly more power for abstraction.
>>54424133
Java's Option type's treatment of null robs it of referential transparency.
>>54424880
Java is all about OOP.
OOP is about objects.
Functional programming is about functions.
In OOP you make a lot of objects who talk to each other, data goes here and there whereever it's needed. But try to add new functions to an object in Java: it's a huge pain in the ass. You can use "desing patterns" as workaround (i.e. adapter pattern), but's a pain in the ass.
In functional languages you take a different road. It's more you have the solution and try to "re-engineer" it by definitions of data manipulations via functions..
OOP:while (counter > 0) {
result = f(result);
counter--;
}
return result;
Functional:result = f(f(f(f(input))))
I can't describe it very well, but in Java you usually "chain" your commands at something and advise objects to do certain things. You design "minion programs" that do certain tasks.
In functional programming you have no real objects, rather you make the data behave like you want by piping them around until you get what you want.
Functional > OOP
prove me wrong
>protip you cant
>>54424880
When I describe a language as "functional", I mean that all expressions in that language are referentially transparent, and therefore subject to equation reasoning.
Almost no expressions in Java are referentially transparent. We must restrict ourselves to a tiny subset of Java to take advantage of this property.
http://www.functionaljava.org/
If any body wants any functional programming mentoring or wants any questions answered, please hit me up. I would be happy to field most questions.
>>54424970
Whenever state is important or uncertainty is added..
For example a singleton object which is the gate to data outside if the system.. It's far more convenient to just ask it "hey, what's your state?" and act according to the reply.
Also functional programming is sometimes overly complex:
IF you can write it, it's 99% correct, but it takes much more time to get it done.
At least that's my impression.
>>54425175
>For example a singleton object which is the gate to data outside if the system
In such a situation we encode the structure of the external world into our type system using abstractions such as monoids, mtl, or the free monad. Each of these options provides more capacity for testing than its OO counterpart.
Asking "hey, what's your state?" is the essence of the MonadState typeclass, which forms a composable part of mtl.
>IF you can write it, it's 99% correct, but it takes much more time to get it done
The stronger types Haskell provides help toward the goal of correctness, but tests are still important. Property-based tests tend to instill the most confidence in myself and colleagues, as the randomness inherently includes cases a human would never consider.
As for more time, that's a more complex question. This paper:
haskell.cs.yale.edu/wp-content/uploads/2011/03/HaskellVsAda-NSWC.pdf
seems to suggest that a programmer armed with Haskell produces correct, working programs faster than programmers armed with other languages provide incorrect, incomplete definitions. That being said, the linked paper is quite old. If you can provide a more recent empirical study, I would be very interested to read it.
functional will never be used in production because it's unreadable and untestable;
>>54425341
Thanks for your answer.
Maybe if I was as good in Haskell as in Java would see things slightly different, who knows?
>>54425369
And what is "WhatsApp" build in?
A functional langauge.
>>54425369
It is used in production today. Facebook uses Haskell for its spam-detection engine. Jane Street uses it for their trading.
Stronger types make a codebase require fewer tests. Many tests in untypes languages simply enforce what typed langages would not have permitted in the first place.
>>54407442
Why is this missing from the whole thread?
http://clojure.org/
>>54425458
Because closure's only addition over Scala is tpye errors at runtime - a most undesirable feature indeed.
>>54425369
Soon dependent types will be mainstream, making testing totally irrelevant and futile.
>>54425966
ah yes because dependent types are the only cause of bugs
I can tell you've a NEET bedroom skiddie who will never have a job
>>54425174
What functional language is best to get a grasp of how FP works, what language is most likely to gain serious traction in the industry and are there any books I should skim over or should I just start coding? Also whats your favorite FP language (if you use more than one)
For reference, im a bit familiar with scheme
Plebs not doing functional programming on quantum computers. Get with the times, geeze
http://sneezy.cs.nott.ac.uk/QML/
>>54426042
I'm absolutely convinced this is the best Haskell book that has yet to be written
http://haskellbook.com
stateless functional programming hasn't caught on that much because it makes the assumption that state is the single major cause for things being difficult to understand and maintain
while state definetly makes things harder, lack of state may introduce complexity in other areas, for instance an unusual amount of abstraction being required for some tasks (and lots of abstraction is never good).
>>54425601
You best be joking.
>>54409629
Lambda calculus is pretty easy
t. Finnish man
https://www.youtube.com/watch?v=v1IlyzxP6Sg
>>54424287
I agree. Scala is the ugliest fag language I've ever had to use.
>>54425080
>OOP:
That's structured imperative programming, except you usually wouldn't use a while loop for that if other kinds of loops are available.
OOP is focused on objects with methods.
>Functional:
By that definition, almost every language made in the last 60 years is functional.
>>54426094
>an unusual amount of abstraction being required
[CODE]
main = putStr ""
[/CODE]
I can totally see that
>>54426641main = putStr ""
>>54426094
http://shaffner.us/cs/papers/tarpit.pdf
Too much abstraction is what you're tempted to do constantly in OOP.
>>54426873
ive read that paper before and i mostly agree with it, but in my opinion it misses an important point.
"Power corrupts
What we mean by this is that, in the absence of language-enforced guarantees (i.e. restrictions on the
power of the language) mistakes (and abuses) will happen. This is the reason that garbage collection is good — the power of manual memory management is removed. Exactly the same principle applies to state — another kind of power. In this case it means that we need to be very wary of any language that even permits state, regardless of how much it discourages its use (obvious examples are ML and Scheme). The bottom line is that the more powerful a language (i.e. the more that is possible within the language), the harder it is to understand systems constructed in it."
it completly misses to name power to abstract as a cause of complexity.
at the top it mentions that too much abstraction is harmful, but in the paragraph where it actually matters the important point isn't mentioned.
i think that many pure functional languages get this wrong.
lack of state allows for way greater abstraction, but that power corrupts just like being able to work with state.
i like stateless functional programming, i really do, but most code i work with is so utterly over-abstracted that it's incredibly painful to work with.
golang is a great counter example for this matter. in theory the language is utter shit, but in practice most libraries are a lot more enjoyable to use than in say haskell because you don't have to understand the designers own world just to work with his library.
these are just observations from my own experience and other people might've made different observations, so don't take that statement as an absolute fact as what we're arguing about is fairly vague.
>>54425174
best 2D game engine/game library to write simple games? what about physics library support like chipmunk and box2d?
also is functional programming is any good to quickly prototype games?
>>54427445
>This is the reason that garbage collection is good — the power of manual memory management is removed.
That's a false dilemma. You can have no garbage collection and no manual memory management.
>Exactly the same principle applies to state — another kind of power.
There's still state in Haskell. It's just implemented in a more complex way.
>>54428449
>that's why it's called a monad... because it's a triple
https://storify.com/realtalktech
https://twitter.com/realtalkintech
>>54426042
Haskell will introduce you to the most concepts in modern functional programming, but the most likely to take off in the next few years is probably F#. if that does take off it'll open the flood gates to all kinds of other languages though
my favorite language is Idris but I don't use it all that much because the compiler is still buggy and the generated code is pretty slow. the library support is a joke, but I'd probably write a few libraries if it was a bit more complete (since it's a ways away from 1.0, there's no concern over breaking compatibility). my second favorite/the one I tend to use is OCaml
>>54429295
Thanks for the reply! Ill check out haskell and f#
>>54429295
Kinda sad because F# is so crippled. It's a toy functional language at best
>>54411758
Idris loses a lot too.
Dependent types are nice, but I think Idris sacrifices too much.
>>54429421
yes i agree. it sacrifices all type safety for runtime niceties that let it work with .NET better (the reflection and downcasts in particular). the type system is weird as fuck with shit like (+) being overloaded
>>54429503
anything specific? i like it more than Haskell in general. idiom brackets, generalized comprehensions, DSL support/syntax definitions, ! inside of do, etc. make it feel like a more elegant version of Haskell in a lot of ways
i honestly haven't used it enough to say for sure what it's problems are, but it doesnt seem like there's anything huge missing/wrong with it
>>54429634
Laziness. Typeclass coherence (admittedly I don't think GHC enforces it).
I also don't like the Eff fetishization. (Yes, Eff is useful. No, it doesn't replace mtl.)
>>54424970
>Name one
even the simplest games
http://prog21.dadgum.com/23.html
Now imagine developing a AAA game this way. I doubt any company could finish it in less than a century
>>54432498
there's a purely functional Pacman https://github.com/kghandhi/pacman
i dont know how that compares to C or some other language, but it's not like it's impossible
>>54432573
yeah, Pacman, but imagine a purely functional GTAV done in a reasonable time frame. the link I posted is about implementing a purely functional Pacman too and shows how much unnecessary complexity it incurs.
>>54432668
yeah, pure FP doesnt seem to fit very well into game design as of right now. i dont think FRP is compelling for anything very large scale, but i really havent written any FRP code beyond like 100 lines. but just giving up all FP notions for a game is also dumb, and it's why so many games are so buggy. if 95% of the game and game engine was made up of pure functions or at least functions that only used local state games would be a lot better made i think
