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.
Lecture 1.7 - Tail Recursion
Loading...
Из курса от партнера École Polytechnique Fédérale de Lausanne
Functional Programming Principles in Scala
6265 оценки
École Polytechnique Fédérale de Lausanne
6265 оценки
Курс 1 из 5 — Specialization Functional Programming in Scala
Из урока
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
Познакомьтесь с преподавателями
Martin OderskyProfessor
Computer Science
На прошлой неделе мы изучали функции как основные строительные блоки
программ. На этой неделе мы всё ещё занимаемся
функциями. Мы разберёмся с различными способами
их конструирования и композиции. А под занавес, на следующей неделе, мы взглянем
на данные и объекты. На первой сессии этой недели мы
вернёмся к рассмотрению рекурсии и поймём, что в действительности есть
различные способы выразить рекурсию. Сначала сделаем обзор по применению функций.
Из последней сессии вы знаете, что есть одно простое правило.
Вы вычисляете применение функции f с аргументами e1, ..., en
путём вычисления аргументов - выражений e1, ..., en, при этом, скажем, они дают результаты
v1, ..., vn. А затем заменяете применение
функции на её тело. И в это же время заменяете формальные
параметры функции на действительные аргументы v1, ..., vn.
Правило замены может быть формализовано и заменой самой программы.
Скажем, у вас есть программа с определением функции def f с параметрами x1, ...,
xn и телом B. А где-то ещё есть
вызов функции f с применением значений аргументов v1, ..., vn.
Эта программа может быть переписана на программу, которая содержит то же определение
функции, но применение функции теперь заменено на тело f -
B, и в то же самое время формальные параметры x1, ..., xn заменены
на значения аргументов. А остальная часть программы остаётся
без изменений, на что указывают эти троеточия.
Это области программы, которые мы не трогаем.
В этой нотации v1 для x1, vn для xn называются подстановками /substitutions/.
Это значит, что все вхождения в теле функции параметров x1, ..., xn
заменяются на соответствующие им значения v1, ..., vn.
Вот пример, считаем это GCD, функция, которая вычисляет
наибольший общий делитель для двух чисел.
Реализация GCD известна уже очень давно, со времён древних
греков, и известна под названием алгоритма Эвклида. Чтобы вычислить наибольший общий делитель
двух чисел, a и b, что нужно сделать? Для начала, если b равно нулю, то a является общим
делителем для обоих чисел - a и b, в противном случае нужно вычислить наибольший общий делитель /gcd/
от b - сначала, потом a, делённое по модулю b. Как оператор используется знак процента, как в Java и C,
и он означает, что a делится по модулю b.
Давайте испытаем этот алгоритм в действии. Gcd от 14 и 21.
Как это вычисляется? Мы раскрываем gcd, это
даёт нам: если 21 == 0, то 14, иначе - gcd от 21 и 14, делённое по модулю 21.
И мы упрощаем условие, 21 == 0 является ложью.
Далее мы упрощаем if-then-else, используя ранее разработанное правило.
Так что, если ложь, то 14, иначе gcd от 21 и 14, делённое по модулю
21, как даёт часть "иначе". Как только мы получили эту часть "иначе", мы редуцируем её
аргументы к значениям. Это даёт нам ещё один вызов gcd, который
мы также раскрываем, и процесс продолжается. Здесь я обозначаю с помощью нескольких
стрелок, что это редукции, которые могут потребовать более одного шага.
Мы получаем gcd от 14 и 7, далее - gcd от 7 и 0, и в конце концов мы добираемся до
условия if 0 == 0, то 7, иначе - ещё один вызов gcd.
И наконец, так как условие здесь истинно, мы получаем ответ 7.
Окей. Давайте рассмотрим другой пример с заменами.
Это факториал. Классический алгоритм для факториала
следующий. Скажем, нам нужно взять факториал от
числа n. Мы снова проверяем, равняется ли n нулю - if n == 0, -
тогда факториал равен 1. В противном случае он будет равен n умножить на факториал от
n минус 1. Давайте применим это алгоритм к факториалу от
четырёх. Он будет раскрываться до следующего условного
оператора - if 4 равно 0, то 1, иначе - 4 умножить на
факториал от 4 минус 1. Мы вычисляем if-then-else, которое
требует нескольких шагов, 4 умножить на факториал от 3.
Вторая часть. Проводя дальнейшую редукцию, мы получаем 4 умножить
на 3 умножить на факториал от 2. И так далее, пока, в конце концов, мы не достигнем 4
умножить на 3 умножить на 2 умножить на 1. Это была последняя часть, а сам изначальный
факториал редуцируется до 120 /??? = 24/. Вопрос,
каково же различие между этими двумя последовательностями,
gcd и factorial? Одно важное различие в том, что если
мы мы вернёмся к gcd, то увидим следующее.
Редукционная последовательность колеблется. Она проходит от одного вызова gcd к следующему
вот здесь, к следующему вот здесь, к следующему вот здесь и в конце завершается.
Внутри у нас есть и другие выражения, отличающиеся от простого вызова, подобные
if-then-else, но мы всегда возвращаемся к этому образу вызова
gcd. Если же, напротив, мы посмотрим на факториал,
мы увидим, что на каждой паре шагов мы добавляем ещё один элемент к нашим выражениям.
Наши выражения становятся всё больше и больше, пока мы
не закончим в момент редукции выражения к финальному значению.
Так что это различие в правилах замены на самом деле переносится напрямую на
различие в выполнении, реальном выполнении на компьютере.
Фактически, это означает, что если вы имеете рекурсивную функцию, которая вызывает сама себя, как
это было в последнем примере, вы можете использовать стековый фрейм этой функции.
Это называется хвостовой рекурсией /tail recursion/. И применение этого трюка подразумевает, что
функция с хвостовой рекурсией может выполняться в постоянном стековом пространстве,
а значит - это альтернативная формулировка итеративного процесса.
Можно сказать, что функция с хвостовой рекурсией является функциональной формой цикла, и выполняется
так же эффективно, как и цикл. Если же вернуться к gcd, мы увидим, что в
части else gcd вызывает себя и это её последнее действие.
И это превращает её в последовательность замен, которая изначально имеет постоянный
размер, и при реальном выполнении на компьютере это превращается в
вызов с хвостовой рекурсией, который может выполняться в неизменяемом пространстве.
С другой стороны, если снова взглянуть на factorial, мы заметим, что
после вызова факториала от n минус 1 всё ещё остаётся невыполненная работа, а точнее
мы должны умножить результат этого вызова на число n.
Так что вызов здесь не является вызовом с хвостовой рекурсией, и это становится ясно в
редукционной последовательности, где в самом деле есть наращивание промежуточных
результатов, которые мы вынуждены хранить до момента вычисления окончательного значения.
Так что факториал не является функцией с хвостовой рекурсией.
И factorial, и gcd вызывают только самих себя,
но в общем случае, функция может вызывать и другие функции.
Так что обобщение хвостовой рекурсии состоит в том, что последнее действие
функции состоит в вызове другой функции, может, и самой себя, а может - и другой.
Стековый фрейм повторно используется для обеих
функций. Такие вызовы называются хвостовыми вызовами.
После прохождения упражнения вы можете задать себе вопрос, а все ли
функции обязаны иметь хвостовую рекурсию? На самом деле - не все.
Интерес к хвостовой рекурсии продиктован в основном желанием избежать глубоких рекурсивных цепочек.
Большинство реализаций, и JVM в частности, ограничивают максимальную глубину
рекурсии до нескольких тысяч стековых фреймов.
Так что, если ваши входные данные таковы, что могут возникать глубокие рекурсивные цепочки,
то хорошей идеей будет переформулировать вашу функцию и наделить её свойством хвостовой рекурсии,
чтобы она могла работать с постоянным стековым фреймом, а вы могли избежать исключений переполнения стека.
С другой стороны, если ваши данные не
склонны приводить к глубоким рекурсивным цепочкам, то
то ясность превосходит эффективность, так что можете смело записывать функцию самым ясным для вас
способом. Который зачастую не обладает хвостовой рекурсией.
И не беспокойтесь о потраченных стековых фреймах.
Как сказал Дональд Кнут, преждевременная оптимизация является источником всего зла.
И это именно та модель, которой очень полезно следовать.
Вернёмся к факториалу. Вы могли заметить, что значение факториала
растёт реально очень, очень быстро. Так что даже после очень малого количества
шагов рекурсии оно может превосходить допустимый диапазон значений для целых, или даже
длинных целых чисел. И даже по этой причине хорошо было бы
сделать факториал функцией с хвостовой рекурсией.
Перед этим мы делали это только в качестве упражнения, так что вы уже владеете нужными техниками.
Теперь давайте выполним упражнение на тему хвостовой рекурсии.
У нас была функция factorial, и мы видели, что та версия функции не имела
хвостовой рекурсии. Сейчас же перед нами стоит задача спроектировать версию той же
самой функции, обладающую хвостовой рекурсией. Окей,
самым удобным способом решить это упражнение является использование другого рабочего листа.
Я уже создал новый пакет в нашем проекте proc fun и назвал его week2,
и в этом пакете а нас есть рабочий лист excercise, в котором я уже
записал сигнатуру функции factorial, но реализацию оставил пустой.
Так как же мы можем реализовать это в манере хвостовой рекурсии?
Здесь ясно, что нам нужна другая функция, назовём её loop, которая принимает
два параметра, а не один. Здесь я дам вам её каркас.
Идея состоит в том, что эта функция будет получать параметр acc - аккумулятор.
Он также имеет тип Int, а ещё параметр n - текущее значение, и она будет проверять, если текущее значение
равно нулю, то она не будет возвращать единицу, как это было ранее.
А вместо этого вернёт значение аккумулятора, иначе - вернёт что-то другое.
И мы будем запускать программу с циклом loop от
начальными значениями аккумулятора и n.
Вопрос состоит в том, что нам нужно сделать чтобы заполнить место с вопросительными знаками вот здесь?
Первым делом нужно что-то написать на место начального значения аккумулятора.
Совершенно ясно, что мы говорим так - хорошо, если n равно нулю, то вернётся значение
аккумулятора, это записано в правой части условия n == 0.
И это должна быть единица. Так что сюда мы передаём единицу.
Второй вопрос: что нам делать в том случае, если n не равно нулю?
Идея состоит в том, что нужно снова вызвать loop с аргументами acc умножить на
n и текущего значения n, уменьшенного на единицу.
Но программа всё ещё не компилируется, потому что мы забыли указать тип результата
для функции loop. Как только мы это сделаем, factorial сможет нормально компилироваться.
Мы можем протестировать функцию, так и поступим.
Мы получили 24, как и ожидалось. На этой сессии мы узнали о хвостовой
рекурсии как об особом случае рекурсии, которая соответствует понятию цикла в
императивной программе. На следующей сессии мы собираемся раскрыть
новые способы композиции функций.
Ознакомьтесь с нашим каталогом
Присоединяйтесь бесплатно и получайте персонализированные рекомендации, обновления и предложения.
Coursera делает лучшее в мире образование доступным каждому, предлагая онлайн-курсы от ведущих университетов и организаций.
© Coursera Inc., 2019 Все права защищены.
