Dear Functional Bros | Prime Reacts 

Transistors are functional though.

Well not after I set my cpu voltage to 2v

the transistor is a function the leads are inputs

​@@matt.loupe. deluded. like actually never understood how transistors are all different depending on manufacturing and environment.

There is only one solution. If there is ambiguity then that means you have not researched the problem correctly or completely.

A database is a persistent data structure, aka immutable with history

@@user-tx4wj7qk4t datomic is, most databases are not.

Is this like an argument to something? I don’t see how this is relevant.

@@fullfungo because prime and that guy in that video, both who have very little knowledge of fp or engineering in general, say extremely ridiculous things like "fp has no global state". Or even better you'll hear people say things like "fp has no side effects or state and you can't do anything". As op pointed out, you always can have a global state, the point is it's not mutable.

functional databases I guess can work lol, always making copies

isnt that anarchy tho? Marxism loves bug government

😂😂😂

Cant forget the classics like "The conquest of Functions"

More like the subhuman Chomsky.

It would not be Marx, more like an actual anarchist like Spooner.

Yeah, I would say the use of .bind is partial application as it allows for passing multiple initial arguments and returns a new function which wants the remainder arguments.

yep, thats why haskell type signatures look like: foo :: a -> b -> a and not something like foo :: a, b -> a

​@Satook why is this good though?

@@Tigregalis Currying (one argument at a time) allows you to partially apply a function, which makes things a little bit easier (especially when the language supports them). For example, the function "userIdEquals" from the video, if curried, it'd be called as "userIdEquals(userId)(receipt)". This means we can then use this function partially applied as: "receipts.filter(userIdEquals(userId))", which saves as the trouble of creating an intermediate function: "receipts.filter((r)=>userIdEquals(userId,r))". In languages like JS, curried functions can be cumbersome, because each arguments has to be wrapped in parentheses. But languages like Haskell don't have this trouble: you can call the function with as many arguments as you want -- give them all and you'll get the result; provide the first few, and you'll get a partially applied function that's waiting for the rest. Hope this helps!

@@DavidAguileraMoncusi that actually does help. first time in my life i've understood the benefit, specifically using it to avoid an intermediate function

linq is poggers

You know Erik Meijer distanced himself from functional programming including LINQ recently?

@portal_narlish3710 so what? Cat Stevens distanced himself from his old songs too, yet they're still amazing

Which is incredibly helpful if you're in academia and need to prove things, because your proofs become easier since it's all just unary functions.

@@anon_y_mousse Just memoize the results and you can reuse them! :p

@@anon_y_mousse in the real world you must prove correctness too. But of course CRUD coders won't ever get anywhere close to applications that need this kind of rigour.

@@anon_y_mousse and reducing the implementation to pure lambda (or, even better, combinatory logic) is one of the easiest ways to prove things. Luckily, nothing stops you from doing it with even a pretty heavily imperative code. But as an intermediate representation, a curried CPS is one of the most powerful and easy to reason about forms. Your source language does not really have to support currying, it's all down to intermediate representations.

@@anon_y_mousse I mean, it becomes a stylistic choice at the end of the day. You give up varargs for seamless partial application. Otherwise the curried languages, Ocaml and Haskell being maybe the most famous, have both pretty decent performance and are pretty quick to develop in.

Tail call recursion optimization was one of the features that was promised in ES6 in JavaScript. But sadly only Safari implemented it... Which is surprising to say the least. Chrome, Firefox and others never really implemented it.

Kotlin has a tailrec keyword that enforces a function is tail recursive and performs this optimization

@@awesomedavid2012 cool! Didn't know that. Maybe Java will get it in a dozen years too then 🤣

Many compiled languages already do this optimisation, though it usually isn't 100% guaranteed (as with a lot of other optimsation techniques)

F yes, tail call best call :)

@@samuraijosh1595 That's not true. It's possible to partially apply arguments to a function without currying the function prior.

a shorthand for currying identification could be if you can do foo()()

also currying is a stricter subset than partial application. as currying is typically understood for use w/LC or rather single arguments in general rather than splitting the input domain N times, which currying does for N arguments

@@shampoablewell thass wild, i do that in JS all the time juss cause it’s more intuitive to write if returning a function is what i’m doing. neat.

Eu nunca vi um restaurante cobrar gorjeta aqui kkkkk

É o 10% burrão ​@@henriqueprado9205

that's what tail call optimisation is for

​@@ultru3525 that's a lot of bs to simply use a branch instruction

@@mitchhudson3972 yes every single assembly-level instruction is simple by itself, but once you start combining them to actually do something noteworthy, there is a point where the simple instructions start becoming exponentially more difficult to understand than the bs, or abstractions as they're more commonly called.

@ultru3525 in no universe will a for loop be more complex or difficult to understand than a bunch of recursion. With performance at best it just ends up being the same thing and at worst blows up your stack

@@mitchhudson3972 Sure, if you ignore the entire history of formal mathematics. Why do you think ancient mathematicians defined the Fibonacci sequence using recursion instead of a for-loop? Because recursion is the mathematical approach which is modelled by human reasoning. For-loops OTOH only came into existence when we needed to translate our reasoning into something a smarter-than-average rock can work with.

And the worst part in case of errors the call stack is completely useless without first (which started the whole chain and holds initial value) and the last (the reason for the error) calls.

And a loop can run out if memory if there is no garbage collection. How is this any different?

@@fullfungo Just clean up when needed, which is easier to handle than a recursive control flow.

​​@@fullfungo it's infinitely easier to debug and you can easily Tell when you run out of memory in a loop. because you get a Seg Fault or malloc can't get any new memory instead of Stack Overflow with the stack trace pointing to one function. Using the program stack like this is just not a good idea.

@@fullfungo And this is one reason why I love RAII, though, as the_mandrill suggested, it should probably just be called Scope-Bound Resource Management (SBRM)

I always wondering how this kind of approach (the currying, multi-step-loop functions) would affect performance. Thanks for addressing this concern.

fwiw re: B) - you can easily build transducers in JS (or use a library), which allows you to write declarative transformations but avoid a bunch of additional loops/instances. To me one of thing I hate about FP with JS is that there isn't currying by default (again, you can supplement with libs), which makes the whole thing feel super un-ergonomic. It makes composition harder and less intuitive, which makes small, pure functions feel less valuable. FP techniques synergize in a really satisfying way, so when you have to do all this extra leg work to enact them, of course it feels like going all in on FP is a pain.

The other issue is when you work in embedded and you have to modify state in place because of cpu and memory constraints.

JS(ES6) does have TCO its just that V8/Firefox doesn't support it.

@@mixed_nuts then it doesn't. A standard without an implementation is like saying I have a PhD from MIT because I can see their outline of their PhD program online.

Yep! Database queries are one of my favourite examples of functional programming. I'd argue you need to be a bit careful, as they can be hard to test/verify and SQL is honestly not that great and has pretty poor IDE support, but you can get a lot done before you ever send the data out over the network.

SQL is a declarative language

You mean like Forth or Joy?

JS has a proposal to add those and many more to iterators.

No. Pure functional programming languages like "clean programming language" for example model the whole universe with no state changes (including the computer memory) - then how you run interactive programs is that both your functional program can create a new universe - then the user as a function also can create a new universe from that - then functions run over it again. You need no state this is just recursion with a completely new universe being born all the times haha. Then haskell has the other approach with monads - but I find the "Clean" approach to be theoretically cleaner indeed. Fun-fact: Clean and Haskell are nearly fully compatibly even to the syntax level and you could not tell which code is from which - despite the therory and inner workings being so different...

​@@u9vata What you are describing is the theoretical underpinnings of FP, the real implementations dont abide by that.

@@arkeynserhayn8370 What I describe is the SEMANTICS of said languages so real implementations DO totally abide that in both circumstances. Just of course - as every sensible compiler - they optimize whatever they can and whenever possible given the given circumstances when the compiler is good. Still this is the programming model that you see when you are coding. There are "not purely" functional languages, where the semantics enable more, but in case of Clean and Haskell the semantics are purely functional.

Arity being the number of arguments a function takes for my Dysfunctional bros.

And here I thought he just misspelled parity... I think at the end of the day most people would rather just learn a programming language than relearn English to learn a programming style then learn a programming language to implement it in. That's probably why this stuff hasn't gained more traction.

@@D4ngeresque I can appreciate hyperbole but I think comparing learning a couple new words (which are long standing English words) to relearning English is a bit too hyperbolic for me. I thought the same thing when I first saw "arity" but I took two seconds to google it and I now I can understand any text that uses the term. 2 seconds of investment; lifetime of value. I'd also add that you will need new language for all new things you learn so this really isn't an inherent issue to FP. I'm not saying you need to learn it either just don't avoid it for arbitrary reasons like being novel to you.

came here to say this, glad someone is also on board

Yes! Are you also one of the 5 F# programmers?

@@mciejgda88 not yet unfortunately, but i have almost read all of the articles from Scott's blog. I want to do as an experiment the domain modelling with F# thing in a real context with domain experts

I also got owned by reverse last week. Totally forgot it mutates arrays

f(str) return str + " " + f(str) f("One of us.")

@@NeilHaskins yeah I wish I knew what that meant 😂❤️

No you are not writing useful code yet.

@@nnnik3595 oh I’m very aware that I am still at the base of mount stupid 😂

Bro discovered callback hell

On the other hand, the programming language Moses probably would be way more popular. To their chagrin!

Prime is the best example of somebody who has no idea what he's talking about but read some very surface level things on the topic and now talks about it with authority. That's not FP's problem, it's the problem of soydevs thinking they know everything without actually studying.

Seems to me like it's more about reducing the use of state and trying to make sure its impacts are known when it does get used. I'm just starting to look into it but those are the benefits I'm seeing right out of the gate.

@@ragnarok7976 sortve but really the idea is to avoid shared mutable state so that you can achieve pure functions, which are functions that are: Total Deterministic Side-effect free This allows those functions to be referentially transparent so they can be optimized and memoized even by the compiler. This also let's to do property based tests instead of unit tests which test what these functions actually "are" instead of testing some example observations. And it essentially makes 90% of your code nearly error free so you can go focus on only the things that can cause issues instead of running up and down your code with a debugger

Yes of course there is state..it is just immutable. So once you alter it, you just get a new copy. The copy is smart though, nothing like Rust's "Clone"

@@user-tx4wj7qk4tAnd they are a whole lot easier to test

Same 😅

Damn, I can't imagine raw dogging Haskell as a first programing language. Did you major in math?

@@azmah1999 Yes and it wasn't technically my first language. That was Java but I could barely write hello world at that point.

It was my 2nd but it was also the one that got me really into programming

No he doesn't. 22:50

QuickCheck for Haskell is amazing for this, but there aren’t as many good analogs in other language ecosystems…

unless it's javascript or some other mutation first language cosplaying as a functional language. Then good luck with that!

@@tuchapoltr you can just use the repl. It's pretty easy to use in both haskell and JS

Indeed! Step-by-step debugging doesn't make sense anywhere except in code executed step-by-step. For simple, pure functions you only want to see what various parts of the call tree evaluate to. More complex types would maybe warrant specialized debuggers tho.

@@ryanleemartin7758 I do this in JS all the time lol

Do you really need to know the names of them in order to use them though? I think the video was mostly about scaring new people off.

@@georgehelyar Using is second to *reasoning* about the concepts. Without the language and definitions of concepts, how do you convey the meaning and semantics?

@@georgehelyar it’s a programming pattern and it’s good to have a consistent name for the pattern 🤷‍♀️

People use these things all the time without knowing what they are called though. It's just that the names are scary to people who have not heard them before, and that makes people think FP isn't for them.

It never is, which I hate. I always have to google source videos and articles... :

Good because it's a terrible videofull of misinformation

The video link is gay tho?

Can you explain a bit?

It's complete nonsense too since that's not how things work and the original video is mistaken on at least half of what they're saying. This is why FP gatekeeping hard is good, it keeps these soydevs out

The parallelism wouldn't matter because the threads would need to wait to write their results into the map. Really you would store the results from each thread in separate lists and then concatenate those lists at the end when the whole thing was done

It might be a better exercise to first implement as non blocking pool threads to discover if the problem is congruent to coroutines. I find it’s easier to move to coroutines from that.

just rewrite it in Go

A higher-order function is simply a function that takes another function as input. The map function is a good example of this type. Say for example, you have a function that takes a number and doubles it, and you have a list of numbers you want to run through the function. Map takes both that function and the list and returns you a new list of the doubled values. Currying is taking a function with two or more parameters, and converting it to a nested collection of single parameter functions. This , in that you can provide each parameter one at a time. In JavaScript it would look like this: const calcTax = (taxRate, quantity, price) => (price * quantity) * (taxRate / 100); const r = calcTax(7.5, 5, 3); // forced to call it with all three values const curriedCalcTax = (taxRate) => (quantity) => (price) => (price * quantity) * (taxRate / 100); const r2 = curriedCalcTax(7.5)(5)(3); // forced to call three functions each with a single value const salesTax7point5 = curriedCalcTax(7.5); // partially apply the 7.5 percent sales tax to create a new function with the value baked in const r3 = salesTax7point5(5)(3); const salesTax7point5quantity5 = salesTax7point5(5); // partially apply the quantity const r4 = salesTax7point5quantity5(3); // left with a single parameter function Functional languages do this currying for you automatically, and it is useful to bake in values like connection strings, or adapting the shape of your function to match a higher-order function's requirement. Loops themselves are not necessarily bad or "non-functional" in my opinion. It's about controlling side effects. You can have a loop with a mutable counter inside the boundaries of a function, and that function still be "pure" because it only relies on the inputs and any mutable state is kept within the boundaries of that function call. There is no pure side effect free program. It can't exist. Everything needs a way of getting input, providing output, storing and retrieving data, etc. But FP prefers to limit the places that these "impure" actions take place to the start and end points of a calculation. Mark Seemann calls this the "impureim sandwich".

@@benniecopeland7388 4 months later and I finally got this, I appreciate your example so much.

This is the point though. Hearing "catamorphic operation" scares people off, and you don't really need to know the name of it in order to use it.

The problem with category theory is that it's so abstract and general that there's some construct in category theory that will describe what you're doing. Except, naming things for the sake of naming them gives you nothing useful.

@@isodoubIet Knowing the basics of CT can lead you to seeing your programming problems differently. I recently wanted an embedded DSL for Logic Programming (with cut!) in Python, and I implemented it in Python with a triple-barrelled continuation monad. I'm very pleased with the simplicity of the code. I ported it to C# in one evening without much prior knowledge in that language. The structure of the code made it also very easy to add tail call elimination via thunks and a trampoline.

@@pillmuncher67 yeah parsing is one of those things for which functional patterns in general are very well suited

Recursion isn’t a fancier form of iteration but can be expressed with iteration and a stack.

I look forward to your youtube video expanding on these concepts

@@ericb7937 I've honestly been toying with the idea of making some tech videos on youtube. Perhaps sooner than later.

Cool story functional bro

Could you care to elaborate? I understood nothing from this sentence, and this is from someone who tried to learn FP (I quit at monads) (Edit: Semi jokes aside I think it might have also been Traversables or something)

You just gotta learn Clojure to get it

correct bind is using a closure, but its as close to "partial" application as i can get in javascript

@@ThePrimeTimeagen It IS partial application! :) (I go into more detail above)

I thought Prime kept missing and skipping Scala in videos. Unless he has s Scala 3 one I missed It's a very nice route into FP, much better tooling than say OCaml

Well, there is "LIVE AND READ CHAT ONLY ON TWITCH" in the description of his live streams.

@Drazzz27 oh my bad didn't see that

To be fair, I see him respond to RU-vid comments all the time (including myself.) Just not while live lol

Could it also be the content he throws at RU-vid nowadays? Reaction video after reaction video, zero original content, just him hitting space on RU-vid videos every second. Like idk, dude’s free to do whatever he wants and he obviously prefers Twitch but it feels pointless to sub to him now. Such a stark contrast to the channel he’s reacting to…

The peak of Prime's RU-vid content was when he was on paternity leave. Dude is a Netflix Engineer™️ and has a few children iirc. He's just busy

switch is probably the most inherently functional aspect of most programming languages (aside from functions) and that uses break.

@@valseedianyeah considering it’s pretty close to pattern matching (see Java switch expressions)

@@valseedian I mean, they can't break in the same way normal for loops work in a forEach function, only continue by doing return.

"All partial application is currying" is false by definition. Also currying is never partial application. The only thing you wrote that is correct is saying that they are related.

@@thomassynths Currying is a function that returns a function. Partial application is a function that returns a function with some of the arguments fixed. I stand by what i wrote.

@@khatdubell Currying is a function that takes in a function with tuple arguments and turns a new function that takes unary arguments and returns successive functions. Partial application merely returns a new function with some argument values already provided. These are different things. `curry(f)` returns a function that has nothing partially applied it it. Currying is one mechanism to facilitate partial application, but it is not the only one. Mathematically, currying `(a, b)->c` is `a->(b->c)`. Notice that no partial application has yet been performed, yet the currying operation is completed once the `a->(b->c)` value is returned. Mathematically, partially applying `a` to `(a,b)->c` yields `b->c`. Notice that `patial_apply(f,a)` takes more than just the function as an input, unlike `curry`

@@thomassynths You're right of course but I'm curious why this is the topic you seem to be concerned with when nearly half of this video is incorrect information. Prime has absolutely no idea what he's talking about and the guy he's reacting to is even worse

​​@@user-tx4wj7qk4the and other soydevs always love sh*tting on functional programming and when asked why? They don't know sh*t on how to elaborate on functional programming

I would also recommend ignoring that explanation. Local mutations and state are possible in functional languages, but you don't need them for a for loop. e.g. a local Ref can be used to achieve this in Scala, OCaml, and even Haskell Using map, filter, flatmap are preferred as you do not need to write the looping implementation where mistakes could be made, it's easier to reason about (likewise using recursion), and can take advantage of any optimisations Last time I looked map in Scala was just a classic loop in Java under the hood 😅 Trust me, 90% of the stuff I read about FP (like in JS) is not really FP. It's procedural code using FP concepts -- and there's nothing wrong with that at all

There are pretty much purely functional programming languages (like Flix) that allow local mutation as long as it doesn't escape the scope.