Name: James Coglan:實用的函數式編程：選兩個｜JSConf EU 2014 (James Coglan: Practical functional programming: pick two | JSConf EU 2014)
Uploaded: 2021-01-14T06:44:43.000Z
Duration: 26 min 43 s
Description: 【看影片學英語】數萬部 YouTube 影片，搭配英漢字典即點即查，輕鬆掌握單字發音與用法，長久累積看電影不必再看字幕。

Thank you for that wonderful introduction, that once expected.

Yes, hello, I'm James, I'm going to talk to you today about practical functional programming,

to make sure I get through this in plenty of time, and the clock's not ticking down,

so I don't know how much time I've got, that's very confusing.

What do I mean by functional programming? Well, initially I didn't even know, itches

looking for ideas to talk about on Twitter a while ago, and Jan gave this idea, practical

function fallal programming, and I brushed it off with a little juke.

It has first class functions, and we have venttion and call backs and we have all the

array operations like map, filter, reduce and stuff like that.

But, there's a lot more to functional programming than we often acknowledge.

And what I would like to do is sort of demystify that a little bit.

Because one criticism of functional programming, it's not very practical and you need a PhD

What I'd like to do is sort of talk about the ways in which we are already using functional

ideas in mainstream JavaScript and how we can pay better attention to those and get

Also promise the last occurrence of the word Monad in this talk, there's not going to be

What do we mean by functions? Functional programming is about programming without side effects,

if you're in the Parallel JavaScript talk earlier you would have heard that side effects

are one of the biggest barriers to parallelizing a program because you can't reason about changes

to a global state, makes it hard to parial rise things.

What does it look like to program functionally.

You want to calculate the length of a list, length takes a list and returns an Int that's

So, what you could do is set the counter to 0 and increment the counter for every iment

and return the last value of the counter.

How does that run out in practice, want to get the value of the list, set the count to

zero, first element, increment the index, there's a second element, we increment, there's

a third, we increment, there's no fourth element we break the loop and induction is 3.

The values of the index comments ‑‑ those aren't statements that appear anywhere in

the program that state you have to keep in your head while you figure out what the program

dugs, that's what makes imperative programs hard to reason about.

A functional version would look like this, cough free script has three dot syntax that

breaks a list into the first elements and the rest of the elements.

If the first element is undefined the list is empty, right, so it has length 0 otherwise

the length one plus the length of the rest of the list, we're doing a recuresive break

What does that look like in practice, so, there is a first element, so we'll pick a

We're just going to replace the definition, we're using it as a rewrite rule, no implicit

We do that a couple more times then we get length of the empty list, which we pick the

first branch of the conditional, which is 0 and result falls out.

So here rather than writing comments with sate in them, I've written "is" before each

expression, that's because they're identical.

Doesn't mean they have the same value at a particular point in time, they always have

the same value you can replace any of these expression with any of the other and the program

Substituting bitting of source code for each other makes it easy to think about, you don't

have to track state somewhere else in your mind or on paper.

Let's take another function, map, the signature means map takes a function from A to B and

a list of As and returns a list of Bs, the imperative version of that would be to take

an empty list and push ever VEX for every element in the input and return the list.

The functional version would be to say in is no first element, the effect is undefined

then return an empty list otherwise afully F to the first element and then combine that

Same structure as we're doing the went, we're using list instead of numbers, say we want

to square the first three numbers, we go, there is a first element, so we'll take a

second branch, so square of one is one, we pull that out of the front and map over what's

left, map over what's left, square two and then, we have anmentty list, and so, the ‑‑

an empty list and then the result falls out.

These are our functional solutions to the problem, theye they work by not my stating

the state, they work by giving you an expression you're trying to calculatend that you can

You can program by substitution by using these things.

The imperative solutions work by making some state and then like changing that state until

some condition becomes true and then handing that state off to you at the end.

But even though those have internal state and they're not internally functional, they

do exactly the same thing as these versions, because, ‑‑ they don't Mutate ‑‑

you can treat them as if they're the same functions.

That's useful, it means their state is completely ensuelated the sidefects continue leek out

Promises have internal state, they are pending and they can become fulfilled or rejected

But, every time you call then it will yield the same value to you, you never get to see

what's actually going on inside of the promise, Jo us call then and value pops out and it's

always the same value you can treat a promise as an immutable value, which is useful.

A couple weeks ago too much ash ford had this really good essay, vents are bad primitive

for data flow, they require distribution of mutable state around your code and it's not

idiomatic or plea Saint to flow through data through events.

We can use types to answer that question, if we consider the FS.read file, that takes

a path name, an encoding, a call back and it returns nothing, and the call back is itself

a function that takes an error, value and alts returns nothing.

Now function that returns nothing must have side effects because if a function has no

return value and no sidefects what why you calling it? It's not doing anything.

The thing that you think of not having side effects is reading a file we work with these

things using side effects functions, completely.

When we're dealing with all these asynchronous things all the time we have to make sure all

the side effects happen in the right order so the program doesn't get into a bizarre

state, and trying to did that on concurrent programs is very, very difficult, which you

It gets even harder when you try odo a lot of things at same time, if you want to read

a file and request a URL and get something out of a data business at the same time, you

use Async.parallel, and do operation, when they complete you get a cull back and you

get value for those things, what would I do if I wanted to get the value of the file before

the other things are completed and do something with it.

Because this, if any of the things fail, I won't get any of the values, I only work on

字幕列表影片播放

James Coglan:實用的函數式編程：選兩個｜JSConf EU 2014 (James Coglan: Practical functional programming: pick two | JSConf EU 2014)

stuff

expression

structure

split