Curried Functions - Computerphile 

So the truth what is underlying here "functions are exactly take only one argument". When you call a function with two arguments, you are actually calling a function with one "pair".

@@alpergunes6380 In Haskell you could create a multi-argument function, by passing it a list or a tuple. That's what I have done in the "Java" example. In actual Java, you can have multiple parameters. Typically in Haskell, you wouldn't use tuples or pairs though, but currying, which is different. In currying you pass the first argument to a function with one argument, which then returns another function and then you pass the second argument to that new function to get the end result. x = add 4 5 is the same as x = (add(4))(5) t = add(4) -- t is a "4 adder" x = t(5) -- putting 5 in a 4-adder gives 9

It's not `add (x y)`, it's `add (x, y)`. The comma is important. Without it, `add (x y)` means `(add . x) y`. I.e. apply x to y, then apply `add` to the result.

The point of the notation is to make it explicit that a curried function is a function taking a single argument and then returns a function. By including the explicit lambda notation it ismuch more clear that what is returned is actually a function that takes the next argument. The notation is not difficult. foo x = x is the same as foo = \x -> x

There is failyr standard lambda-calculus notation, e.g. f = λx.x But I agree, that Haskell notation doesn’t make any sense to someone who doesn’t know Haskell.

@@lawrencedoliveiro9104 it does make perfect sense for those who know about maths though. It's like arrow functions in JavaScript, the notation make it very clear that the function is something that given an argument x, returns something that depends on x.

I think this is actually the first video with him that wasn't totally pointless and boring for people who don't know Haskell (nor have any interest in learning it)

This makes more sense than the entire video

I know but to think about curried functions I think you need to think in terms of assembly line where you can change what line does by changing a part of it it's not the only way maybe you can use callback but you must consider also that this is a mathematical way of thinking maybe those are wrong reasons or maybe there are other reasons I'm not sure but that's how I think about it

When he was starting to explain the curry with the add function I was really expecting this example. The map example wasn't wrong but much more complicated than it needed to be.

This example would have been the perfect ending to the video, thank you for posting it :)

I think your example is better, than what the video gave, but I still don't see any use for this feature. The normal way is more clear and practically equally long: add(x, y) = x + y addFour(x) = add(x, 4)

This is probably the simplest explanation of currying: Regular functions take all of the inputs at once. Curried functions take one input and return another function that takes the next input (or the result if it's the last input).

This makes javascripting easier

That's why i'm watching this video lol

Exactly. I was hoping for a 1 April joke. Noop

There's no way Haskell can be a real thing.

Yeah this april 1st joke is BOOORING

It does sound like it could be a joke, especially with the thumbnail. Still, it's actually pretty useful to realise currying/partial application is a thing. Wish they'd delayed it a bit because I bet some people skipped the video thinking it's a joke.

that's no generic currency, it's dwarf bucks!

okay I must be missing context here. Care to explain?

@@Twisted_Code that's the symbol used for currency in the video game dwarf fortress, the community calls it dwarf or dorf bucks :)

@@Twisted_Code Of course. The ¤ symbol is used when you're talking about an unspecified currency (not euros or dollars, but a hypothetical unit). I think it'd look neat in a real world situation

I'm still not following how this all relates to the video? Are you referring to the cash machine part of the video?

I've used this with spline interpolation once. Interpolation involves solving a system of linear equations, a fairly expensive process, but once it's done you can use the results to compute the interpolated value in any number of points. So using currying felt like an obvious choice. I've done the same assignment also in C, and it sure felt nice to be able to say at the end of the process: now I have a function from reals to reals, don't worry about the details.

You mean partial evaluation?

It can be seen as a memoization of its partially applied arguments. In the case of Haskell, it really doesn't matter, because it's a pure functional language so values get memoized automagically (e.g. when `factorial 100` is called first time, it gets computed, but if `factorial 100` is needed again, anywhere, result is just loaded from memory and it won't be computed again).

When I heard of it the first time, the problem to solve was: how to have multiple parameters functions in a language that just allow single parameter functions (aka lambda calculus). That is pretty big.

It is called partial application function

did this, am currently having my stomach pumped

Well given he is talking about a functional programming concept, I hope you don't get alcohol poisoning from that. Edit: welp, too late.

chjAlleNge aCCcepted

1 shot, 2 shots, 3 shots, floor.

those functional programmers and their functions...

No, but it does do inlining when possible, which is even more efficient than memoizing.

Function composition and higher order functions

@@sdsdfdu4437 Thanks! I think that's what I mean by brevity and speed but in reverse order. I'm assuming higher order is slower.

@@Bestape speed depends on the implementation, not the concept. The ghc (glaskow haskell compiler) is very efficient and can produce very fast and optimized programs.

That's because Haskell's error messages are dreadful! Elm (a language based on Haskell) does a *much* better job, but only transpiles to JS, so its area of usage is different.

one of the cool things about functional programming is that it's easier to capture in a flowchart than imperative programming

@@xybersurfer I guess, but I could always keep track of what I was doing without one. I suppose if my higher-ups wanted one I could make one.

Yea it's a ibt weird they chose this. Maybe they did it because Haskell is a functional language?

@Sydney Bean JavaScript perhaps? const f = x => y => x + y ?

@Sydney Bean From ruby-doc.org: def foo(a,b,c) [a, b, c] end proc = self.method(:foo).curry proc2 = proc.call(1, 2) #=> # proc2.call(3) #=> [1,2,3]

I think Swift’s syntax makes most sense. You can see clearly what types are expected in the definition: func plus(_ a: Int) -> (_ b: Int) -> Int { return { b in return a + b } } let plus5 = plus(5) // (Int) -> Int plus(5)(4) // 9 plus5(4) // 9

@@evergreen- If you put the type definition with the function in Haskell, it's even easier to see what's happening IMHO plus :: Int -> Int -> Int plus a b = a + b -- or plus = \a -> \b -> a + b Putting the type definition above top-level functions is common practice in Haskell, he just didn't do it because it was in a REPL and explaining types wasn't in the scope of the video.

Robert Hunter HP calculators often throw reverse polish notation into the mix as well...

@Mike Yeah that makes sense. I was thinking that the state was changing, but in the case of add, it only changes once and in an entirely predictable way.

They can be really useful when you need to "carry around" a value that you want to use with some additional function later, perhaps long after the original value has gone out of scope. They can also be really confusing :-)

Exactly what I was thinking. He explained what they are clearly enough, but I can never see where I'd care.

Also: monads.

You write three functions and run them one after the other. Currying is more of a syntax shorthand than a mathematical truth of the universe.

In C you use function pointers. The syntax is pretty horrible, but it can be done. But more to the point, you just don't do this in C, or any of those other languages you mentioned, because it's not idiomatic. Haskell programmers expect you to use currying because that's part of how you program Haskell, just like Scheme programmers expect you to use closures to accomplish more-or-less the same thing (more verbose syntax, but more flexible). Try currying in most C-family languages and all you cause is confusion, because if you're using currying in those languages then you're doing it wrong. The languages weren't intended for that paradigm, and other programmers will struggle to follow your logic.

I don’t like pure functional-programming languages, but I like using functional constructs in procedural languages like Python which make them very handy.

why?

You sound like a Java programmer.

To be a computer scientists requires, more or less, one human unit of brain power/memory/time If the job requires less, it's vocabulary will be expanded until it does.

Because it's mentally easier to follow Map (add 5) [1..10] Over Map f [1..10] Where f n = n + 5 It does the same thing, but once you're used to the style, the first version will be preferred :)

In other words: to create more functionality with as little as code needed.

Not really. 'el' and 'al' are different

Depends on the dialect. As a native Oklahoman, I say Haskell like "has skull" and Pascal with the same a sound as Haskell but the "al" sounds like "owl." I also put inflection on the "Has" in Haskell and the "al" in Pascal.

@MichaelKingsfordGray I was thinking more of the Sunday am thunderbox visit after the Saturday night down the local star of Bengal. 😉😉

Higher-order function is fun.

@@analogueavenue Yes, well, that is why I'm asking if it's a school requirement. Was it the app, or user error? People don't tend to understand security settings.

@K.D.P. Ross I am sorry if the question offends you, but these guys are known in the US for their top notch cybersecurity. The only way to get a question through to them is through RU-vid. It is relevant since zoom went from 3 million users to 200 million. This channel keeps up with current events as well as coding. They are the best.

Basically, each vertex of the grid gets assigned a number from 0 to 8, zero being in the top left corner, 8 being in the bottom right. A pattern, then, is just a sequence of vertices in the order you need to hit them in. For example, when you swipe across the entire top row and then down the entire right column, creating a right angle shape, the pattern is 0-1-2-5-8. That is then turned into a byte array and stored as an unsalted SHA-1 hash and compared to whatever you put in. Essentially, it works the very much like a passcode.

@@isaactfa thanks I desperately wanted that answer. 😊 you just gained another subscriber.

I thought he said Schoenberg was a "mathematician and magician".

Hrm, I just checked and apparently Pascal does have function pointers. So you could most likely do currying in Pascal. Not sure why you'd want to, but that's never stopped anyone before.