Explore todo o Coursera

For Enterprise

Join for Free
Log In

Artes e Humanas
Negócios
Ciência da Computação
Ciência de Dados
Tecnologia da informação
da saúdesaúde
Matemática e Lógica
Desenvolvimento Pessoal
Ciência e Engenharia Física
Ciências Sociais
Línguas
Notas
Certificados

Explore todo o Coursera

Navegar
Pesquisar
For Enterprise
Entrar
Inscreva-se gratuitamente

Lecture 1.7 - Tail Recursion

Loading...

Princípios da Programação Funcional em Scala

Escola Politécnica Federal de Lausana

4.8 (6,463 classificações) | 150K alunos inscritos

Curso 1 de 5 no Functional Programming in Scala Programa de cursos integrados

Functional programming is becoming increasingly widespread in industry. This trend is driven by the adoption of Scala as the main programming language for many applications. Scala fuses functional and object-oriented programming in a practical package. It interoperates seamlessly with both Java and Javascript. Scala is the implementation language of many important frameworks, including Apache Spark, Kafka, and Akka. It provides the core infrastructure for sites such as Twitter, Tumblr and also Coursera. In this course you will discover the elements of the functional programming style and learn how to apply them usefully in your daily programming tasks. You will also develop a solid foundation for reasoning about functional programs, by touching upon proofs of invariants and the tracing of execution symbolically. The course is hands on; most units introduce short programs that serve as illustrations of important concepts and invite you to play with them, modifying and improving them. The course is complemented by a series programming projects as homework assignments. Recommended background: You should have at least one year programming experience. Proficiency with Java or C# is ideal, but experience with other languages such as C/C++, Python, Javascript or Ruby is also sufficient. You should have some familiarity using the command line.

Visualizar o programa do curso

Habilidades que você aprenderá

Recursion, Scala Programming, Array Programming, Functional Programming

Avaliações

4.8 (6,463 classificações)

5 stars
5,427 ratings
4 stars
887 ratings
3 stars
98 ratings
2 stars
25 ratings
1 star
26 ratings

II

Jun 10, 2019

The course develops the concepts of functional programming from scratch. With fun and challenging programming assignments, it gives ample opportunity to wrap your head around the alternate paradigm.

GB

Aug 13, 2017

An excellent introduction to the concepts of functional programming that had the "side-effect" of getting me hooked on the language! (Even though the hipster in me really wanted to prefer Clojure.)

Na lição

Getting Started + Functions & Evaluation

Get up and running with Scala on your computer. Complete an example assignment to familiarize yourself with our unique way of submitting assignments. In this week, we'll learn the difference between functional imperative programming. We step through the basics of Scala; covering expressions, evaluation, conditionals, functions, and recursion

Lecture 1.1 - Programming Paradigms14:32

Lecture 1.2 - Elements of Programming14:25

Lecture 1.3 - Evaluation Strategies and Termination4:22

Lecture 1.4 - Conditionals and Value Definitions8:49

Lecture 1.5 - Example: square roots with Newton's method11:25

Lecture 1.6 - Blocks and Lexical Scope8:00

Lecture 1.7 - Tail Recursion12:32

Ministrado por

Martin Odersky
Professor

Transcrição

Last week, you have gotten to know functions as essential building blocks of

programs. This week, we'll still be concerned with

functions. We will get to know several ways to

construct them and to compose them. Finally, next week, we are going to look

at data and objects. In the first session of this week, we are

going to look again at recursion, and we will find out that there are actually

several ways to express recursion. First let's review function application.

You know from the last session that there's one simple rule.

You evaluate a function application F applied to arguments E1 to EN

by evaluating the arguments, expressions E1 to EN they would resulting the values

V1 to VM say. And then replacing the application of the

function by its body. And at the same time replacing the forming

parameters of the function by the actual arguments V1 to VM.

This rewriting rule can be formalized by rewriting the program itself.

Say, you have a program with a function definition def f with parameters x one to

x n and a body b. And then, somewhere else eh, you have a

function call f applied to value argument values v 1 to v n.

That program can be rewritten to a programme that contains the same function

definition but the function application has now being replaced by the body of f,

B, and at the same time the former parameters x 1 to x n have been replaced

by the argument values. And the rest of the programme is assumed

to be unchanged, which is assumed to be these triple dots here.

That's areas of the programs that we do not touch.

This notation, we want for x 1 the end for x n is called a substitution.

What we mean by it, is that all occurrences in b of the values x one to x

n have been replaced by the corresponding values v1 to vn.

Here's an example, consider GCD, the function that computes

the greatest common divisor of two numbers.

We know an implementation for GCD it is since a way long time, since ancient

greek, its known as Euclid's algorithm. To compute the greatest common divisor of

two numbers A and B, what do you do. First if B is zero then A is a common

divisor of both A and B and otherwise you compute the greatest common divisor of.

First b, and then a modular b. Percent sign here is as in Java and C,

means that A modular B, the modulus of A and B.

Let's try this algorithm in action. Gcd, fourteen, 21.

How is that evaluated? Well, you would expand GCD, so that would

give you, if 21 = zero, fourteen else GCD, 21 and fourteen modular 21.

And you simplify the condition, 21 = zero is false.

Next you simplify the if-then-else using the rule we have developed previously.

So if false, fourteen else, GCD of 21 and fourteen modular,

21 would give the else part. Once we have the else part, we reduce its

arguments to values. That gives us an other call to GCD which

we expand, and the process repeats. I have signified that here with a multiple

errors to say these are reductions that take more than one step.

We get GCD fourteen to seven, we get GCD seven, zero, and finally you get the

condition if zero equals zero, seven else some other call to GCD.

And that finally, since the condition is true here, we get seven.

Okay. Let's look at another rewriting example.

Factorial. Classical algorythm for factorial is the

following. You're said to take the factorial of a

number n. You ask again if n equals zero,

then the factorial would be one. Otherwise it would be n times factorial of

n minus one. Let's apply that algorythm to factorial of

four. So that would expand to the following

conditional. If four equal zero, one, that's four times

factorial four minus one. You evaluate the if then else, that gives

you in a couple of steps, four times factorial of three.

The second part. Reducing further gives you four times

three times factorial of two. And so on, until you finally reach four

times three times two times one times one. That was the last, the first case of

factorial and that reduces to 120. Question,

what is the difference between these two sequences?

GCD and factorial? Well, one important difference is that if

we come back to GCD, we see that. The,

reduction sequence essentially oscillates. It goes from one call to GCD to the next

one here, to the next one here, to the next one here and finally it terminates.

In between we have expressions that are different from the simple call like if

then else's but we always come back to this shape to the call of

GCD. If we look at factorial, on the other hand

we see that in each couple of steps we add one more element to our expressions.

Our expressions becomes bigger and bigger until we

end when we finally reduce it to the final value.

So, that difference in the rewriting rules actually translates directly to a

difference in the execution, in the actual, execution on a computer.

In fact, it turns out that if you have a recursive function that calls itself as

its last action, then you can reuse the stack frame of that function.

This is called tail recursion. And by applying that trick, it means that

a tail recursive function can execute in constant stuck space, so it's really just

another formulation of an iterative process.

Could say a tail recursive function is the functional form of a loop, and it executes

just as efficiently as a loop. So if we go back to GCD, we see that in

the else part, GCD calls itself as its last action.

And that translate its, to a rewriting sequence that was essentially constant

size, and that will, in the actual execution on a computer, translate into a

tail recursive call that can execute in constant space.

On the other hand, if you look at factorial again, then you'll see that

after the call to factorial n minus one, there was still work to be done, namely,

we had to multiply the result of that call with the number N.

So that call here is not a tail recursive call, and it becomes evident in the

reduction sequence, where you see that actually there's a buildup of intermediate

results that we all have to keep until we can compute the final value.

So that factorial would not be a tail recursive function.

Both factorial and GCD only call itself

but in general, of course, a function could call other functions.

So the generalization of tail recursion is that, if the last action of a

function consists of calling another function, maybe the same, maybe some other

function. The stack frame could be reused for both

functions. Such calls are called tail calls.

After having gone through the exercise, you might ask yourself, should every

function be tail recursive? Well, not really.

The interest of tail recursion is mostly to avoid very deep recursive chains.

Most implementations of, the JBM, for instance, limit the maximal depth of

recursion to a couple of thousand stack frames.

So if your, the input data is such that these deep recursive chains could happen,

then yes it's a good idea to reformulate your function to be tail recursive, to run

in constant stack frame, so as to avoid stack overflow exceptions.

On the other hand, if your input data are not,

susceptible to deep precausive chains then

clarity trumps efficiency evert time, so write your function the clearest way you

can. Which often is not terricosive.

And don't worry about the steck frames that are spent.

As Donald Knuth has said, premature optimization is the source of all evil.

And that's the model that's very valuable to follow.

Coming back to factorial. You might have observed that factorial

grows really very, very quickly. So, even after very low number of

recursive steps it will already the, exceed the range of integers, or even long

integers. So, in that case definitely it was not

worth making factorial a tail recursive function.

So, we did that only as a, an exercise so that you have the techniques ready when

you need them. So let's do an exercise on tail recursion.

You've seen factorial, and we've seen that, that version of the function was not

tail recursive. So now the task is to design a tail

recursive version of the same function. Okay,

so the most convenient way to solve this exercise is using another worksheet.

I have already created a new package in our proc fun project called week two, and

in that package we have a worksheet excercise in which I have

already written the signature of factorial but I've left out the implementation.

So, how would we implement that in a tail recursive fashion?

Actually, it turns out that we need another function, called loop, that takes

two parameters, not one. I'll give you an outline of loop here.

So, the idea is, it would take an accumulator.

That's also an int, and the current value and it would ask if, the current value is

zero then it wouldn't return one as before.

But the accumulator and otherwise, it would return something

else. And we would start the program with loop

of an initial value of the accumulator and the current value of n.

So the question is, what do we need to do to fill in the question marks here?

The first task is to fill in something for the initial value of the accumulator.

Here it's pretty clear that, we say, well, if n equals zero then the accumulator is

returned so it has to be the right value for n equals zero.

And that would be one. So we pass one here.

The second question is, what do we do in the case where n is not equal to zero.

And the idea there is we would call again into the loop with the accumulator times

and the current value and n reduced by one.

And the thing still doesn't compile because we have forgotten to give a result

type to loop. Once we do that, factorial compiles.

And we can test it so let's do that.

So that would give 24 as expected. In this session we've gotten to know tail

recursion as a special case of recursion that corresponds to a loop in an

imperative program. In the next session, we are going to cover

new ways to compose functions.

Explore nosso catálogo

Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.

O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.

© 2019 Coursera Inc. Todos os direitos reservados.

Baixar na App Store

Baixar no Google Play

Coursera
Sobre
Liderança
Carreiras
Lista de cursos
Certificados
Certificados MasterTrack™
Notas
For Enterprise
For Government

Comunidade
Learners
Partners
Developers
Beta Testers
Translators

Conectar
Blog
Facebook
LinkedIn
Twitter
Instagram
YouTube
Tech Blog

Mais
Termos
Privacidade
Ajuda
Acessibilidade
Imprensa
Contato
Diretório
Afiliados