Functional Programming Concepts

12 Key excerpts on "Functional Programming Concepts"

• 

  No longer available |Learn more

  Scala and Spark for Big Data Analytics

  • Md. Rezaul Karim, Sridhar Alla(Authors)
  • 2017(Publication Date)
  • Packt Publishing

    (Publisher)

  This is not a new concept but the Lambda Calculus, which provides the basis of FP, was first introduced in the 1930s. However, in the realm of programming language, the term functional programming refers to a new style of declarative programming paradigm that means programming can be done with the help of control, declarations, or expressions instead of classical statements commonly used in an old programming language, such as C.

  Passage contains an image

  Advantages of functional programming

  There are some exciting and cool features in FP paradigms such as composition, pipelining, and higher order functions that help to avoid writing unfunctional code. Alternatively, at least later on, this helps translate a unfunctional program into a functional style towards an imperative one. Finally, now let's see how we can define the term functional programming from the computer science perspective. Functional programming is a common computer science concept in which computations and the building structure of the program are treated as if you are evaluating mathematical functions that support immutable data and avoid state change. In functional programming, each function has the same mapping or output for the same input argument values.

  With the need for a complex software comes the need for good structured programs and software that are not difficult to write and are debuggable. We also need to write extendable code that will save us programming costs in the future and can contribute to easy writing and debugging of the code; even more modular software that is easy to extend and requires less programming efforts. Due to the latter contribution of functional programming, modularity, functional programming is considered as a great advantage for software development.

  In functional programming, there is a basic building block in its structure called functions without side effects (or at least very few) in most of your code. Without side effects, the order of evaluation really doesn't matter. When it comes to programming languages views, there are methods to force a particular order. In some FP languages (for example, eager languages such as Scheme), which have no evaluation order on arguments, you could nest these expressions in their own lambda forms as follows:

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  Introduction to Programming Languages

  • Arvind Kumar Bansal(Author)
  • 2013(Publication Date)
  • Chapman and Hall/CRC

    (Publisher)

  325 C H A P T E R 9 Functional Programming Paradigm BACKGROUND CONCEPTS Abstract computation and information exchange (Chapter 4); Abstract concepts in com-putation (Section 2.4); Abstract implementation (Chapter 5); Concurrent programming (Chapter 8); Data structure concepts (Section 2.3), Discrete structure concepts (Section 2.2), von Neumann machine (Section 2.1 ). Declarative programming hides the control from the programmer. The resulting program is reflective of the underlying logic and is easier to maintain than imperative programs except for the unfamiliar syntax of some declarative languages. There are two major declarative programming paradigms: functional programming and logic programming. Mathematical functions are the basis of functional programming, and predicate calculus is the basis of the logic programming. Both mathematical models have been studied for decades and are sound. In this chapter, we will study functional programming. Functional programming is important from many aspects: (1) declarative style hides the control from a programmer; program is only logic + abstraction; (2) functional programs are more concise than imperative programs; (3) functional programming is becoming a key paradigm that is being integrated in recent popular languages including many script-ing languages such as Clojure, Ruby, Scala, and Python ; and (4) functions are an important part of almost all programming languages. The work on functional programming started as early as 1960s with the development of the language Lisp. Although many scientists disagree with the purity of functional pro-gramming in Lisp, its contribution to functional programming is undeniable. Lisp con-tributed many abstractions such as high-level representation of lists, meta-programming, higher-order functions, and recursive style of programming. Variables in a pure functional program are immutable assign-once value holders.

  Sign up to read

  Learn more about book
• 

  No longer available |Learn more

  The JavaScript Workshop

  A New, Interactive Approach to Learning JavaScript

  • Joseph Labrecque, Jahred Love, Daniel Rosenbaum, Nick Turner, Gaurav Mehla, Alonzo L. Hosford, Florian Sloot, Philip Kirkbride(Authors)
  • 2019(Publication Date)
  • Packt Publishing

    (Publisher)

  14. Understanding Functional Programming

  Overview

  By the end of this chapter, you will be able to use Functional Programming Concepts such as pure functions, immutability, composition, and currying; use higher-order functions such as filter, map, and reduce; apply techniques such as cloning objects to reduce side effects in your code; and demonstrate strategies for reducing imperative logic and for loops in your code.

  Introduction

  In the previous chapter, we talked about how JavaScript is a multi-paradigm programming language. It's possible to write code with procedural, object-oriented, and functional design patterns. In this chapter, we'll look closely at the functional programming design pattern.

  Functional programming is a programming paradigm that has become popular in the last few years, though most JavaScript developers were unfamiliar with it before then.

  JavaScript is not a purely functional language like some others, such as Haskell, Scheme, and Clojure. However, JavaScript has support for functional structures and techniques if you choose to use them. It is worthwhile becoming familiar with its concepts and gaining a working knowledge of how to use them.

  Functional programming has a set of features. Among others, here are some of the important ones:

  • Pure functions
  • Immutability and avoiding shared state, mutable data, and side effects
  • Declarative rather than imperative
  • Higher-order functions
  • Function composition and piping
  • Currying functions
  • Reduces the use of traditional flow control structures such as for , while , and even if

  These concepts will be covered over the course of this chapter. If implemented correctly, functional programming can result in code that is more predictable, less error-prone, and easier to test compared to other programming methods.

  Pure Functions

  Pure functions are one of the pillars of functional programming. A function is pure if it always returns the same result when it's given the same parameters. It also cannot depend on or modify variables or state outside of the function's scope.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Functional Programming in C++

  • Ivan Cukic(Author)
  • 2018(Publication Date)
  • Manning

    (Publisher)

  feel like you’re using a new language. With this new style of programming, you can write more-concise programs and write code that’s safer, easier to read and reason about, and, dare I say, more beautiful than the code usually written in C++.

  1.1What is functional programming?

  Functional programming is an old programming paradigm that was born in academia during the 1950s; it stayed tied to that environment for a long time. Although it was always a hot topic for scientific researchers, it was never popular in the “real world.” Instead, imperative languages (first procedural, later object-oriented) became ubiquitous.

  It has often been predicted that one day functional programming languages will rule the world, but it hasn’t happened yet. Famous functional languages such as Haskell and Lisp still aren’t on the top-10 lists of the most popular programming languages. Those lists are reserved for traditionally imperative languages including C, Java, and C++. Like most predictions, this one needs to be open to interpretation to be considered fulfilled. Instead of functional programming languages becoming the most popular, something else is happening: the most popular programming languages have started introducing features inspired by functional programming languages.

  What is functional programming (FP)? This question is difficult to answer because no widely accepted definition exists. There’s a saying that if you ask two functional programmers what FP is, you’ll get (at least) three different answers. People tend to define FP through related concepts including pure functions, lazy evaluation, pattern matching, and such. And usually, they list the features of their favorite language.

  In order not to alienate anyone, we’ll start with an overly mathematical definition from the functional programming Usenet group:

  Functional programming is a style of programming that emphasizes the evaluation of expressions, rather than execution of commands. The expressions in these languages are formed by using functions to combine basic values. A functional language is a language that supports and encourages programming in a functional style.

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  C++ All-in-One For Dummies

  • John Paul Mueller(Author)
  • 2020(Publication Date)
  • For Dummies

    (Publisher)

  Modifying functional code is faster and less error prone than other programming paradigms because the person implement-ing the change must understand only the math and doesn’t need to know how the underlying code works. In addition, learning how to create functional code can be faster as long as the person understands the math model and its relationship to the real world. Functional programming also embraces a number of unique coding approaches, such as the capability to pass a function to another function as input. This capa-bility enables you to change application behavior in a predictable manner that isn’t possible using other programming paradigms. 372 BOOK 3 Understanding Functional Programming CONSIDERING OTHER PROGRAMMING PARADIGMS You might think that only a few programming paradigms exist besides the functional programming paradigm explored in this minibook, but the world of development is lit-erally packed with them. That’s because no two people truly think completely alike. The reason for so many paradigms is that each one represents a different approach to the puzzle of conveying a solution to problems by using a particular methodology, all while making assumptions about things like developer expertise and execution envi-ronment. In fact, you can find entire sites that discuss the issue, such as the one at https://cs.lmu.edu/~ray/notes/paradigms/ . Oddly enough, some languages (such as C ++ ) mix and match compatible paradigms to create an entirely new way to perform tasks based on what has happened in the past. Here are just four of these other paradigms. Many languages in the world today use just these four paradigms, so your chances of encountering them are quite high. • Imperative: Imperative programming takes a step-by-step approach to performing a task. The developer provides commands that describe precisely how to perform the task from beginning to end.

  Sign up to read

  Learn more about book
• 

  No longer available |Learn more

  Programming Languages

  Principles and Practices

  • Kenneth Louden, Kenneth Lambert(Authors)
  • 2020(Publication Date)
  • Cengage Learning EMEA

    (Publisher)

  Functional methods, such as recursion, functional abstraction, and higher-order functions, have influenced and become part of many programming lan-guages. They should be part of your arsenal of programming techniques. In this chapter, we review the concept of a function, focusing on how functions can be used to structure programs. We give a brief introduction to the basic principles of functional programming. We then survey three modern functional languages—Scheme, ML, and Haskell—and discuss some of their properties. We conclude with a short introduction to lambda calculus, the underlying mathematical model for functional languages. 3.1 Programs as Functions A program is a description of a specific computation. If we ignore the details of the computation—the “how” of the computation—and focus on the result being computed—the “what” of the computation— then a program becomes a virtual black box that transforms input into output. From this point of view, a program is essentially equivalent to a mathematical function. D E F I N I T I O N : A function is a rule that associates to each x from some set X of values a unique y from a set Y of values. In mathematical terminology, if f is the name of the function, we write: y = f ( x ) or f: X → Y The set X is called the domain of f , while the set Y is called the range of f . The x in f ( x ), which repre-sents any value from X , is called the independent variable , while the y from the set Y , defined by the equation y = f ( x ), is called the dependent variable. Sometimes f is not defined for all x in X , in which case it is called a partial function (and a function that is defined for all x in X is called total ). Programs, procedures, and functions in a programming language can all be represented by the mathematical concept of a function. In the case of a program, x represents the input and y represents the output. In the case of a procedure or function, x represents the parameters and y represents the returned values.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Functional Programming in JavaScript

  How to improve your JavaScript programs using functional techniques

  • Luis Atencio(Author)
  • 2016(Publication Date)
  • Manning

    (Publisher)

  reactive programming in recent years. This programming paradigm facilitates working with data flows and propagation of change. In JavaScript, this is extremely important when dealing with asynchronous or event-based code. Overall, what we need is a programming paradigm that encourages us to think carefully about our data and the functions that interact with it. When thinking about an application’s design, ask yourself the following questions in terms of these design principles:

  • Extensibility— Do I constantly refactor my code to support additional functionality?
  • Easy to modularize— If I change one file, is another file affected?
  • Reusability— Is there a lot of duplication?
  • Testability— Do I struggle to unit test my functions?
  • Easy to reason about— Is my code unstructured and hard to follow?

  If you answer “Yes” or “I don’t know” to any of these questions, then you’ve picked up the right book as a guide on the path to productivity. Functional programming (FP) is the programming paradigm you need. Although it’s based on simple concepts, FP requires a shift in the way you think about problems. FP isn’t a new tool or an API, but a different approach to problem solving that will become intuitive once you understand the basic principles.

  In this chapter, I define what functional programming is and tell you how and why it’s useful and important. I introduce the core principles of immutability and pure functions and talk about FP techniques and how those techniques affect your approach to designing programs. These techniques allow you to easily pick up reactive programming and use it to solve complex JavaScript tasks. But before we can get into all this, you need to learn why thinking functionally is important and how it can help you tackle the complexities of JavaScript programs.

  1.1. Can functional programming help?

  Learning functional programming has never been as important as it is today. The development community and major software companies are starting to realize the benefits of using FP techniques to power their business applications. Nowadays, most major programming languages (Scala, Java 8, F#, Python, JavaScript, and many more) provide either native or API-based functional support. Hence, FP skills are in high demand now and will continue to be in the years to come.

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  Functional Programming in C#

  Classic Programming Techniques for Modern Projects

  • Oliver Sturm(Author)
  • 2011(Publication Date)
  • Wiley

    (Publisher)

  PART I Introduction to Functional Programming CHAPTER 1: A Look at Functional Programming History CHAPTER 2: Putting Functional Programming into a Modern Context A Look at Functional Programming History WHAT’S IN THIS CHAPTER? An explanation functional programming A look at some functional languages The relationship to object oriented programming Functional programming has been around for a very long time. Many regard the advent of the language LISP, in 1958, as the starting point of functional programming. On the other hand, LISP was based on existing concepts, perhaps most importantly those defined by Alonzo Church in his lambda calculus during the 1930s and 1940s. That sounds highly mathematical, and it was — the ideas of mathematics were easy to model in LISP, which made it the obvious language of choice in the academic sector. LISP introduced many other concepts that are still important to programming languages today. WHAT IS FUNCTIONAL PROGRAMMING? In spite of the close coupling to LISP in its early days, functional programming is generally regarded a paradigm of programming that can be applied in many languages — even those that were not originally intended to be used with that paradigm. Like the name implies, it focuses on the application of functions. Functional programmers use functions as building blocks to create new functions — that’s not to say that there are no other language elements available to them, but the function is the main construct that architecture is built from. Referential transparency is an important idea in the realm of functional programming. A function that is referentially transparent returns values that depend only on the input parameters that are passed. This is in contrast to the basic ideas of imperative programming, ➤ ➤ ➤ 1 4 ❘ CHAPTER 1 A LOOK AT FUNCTIONAL PROGRAMMING HISTORY where program state often influences return values of functions.

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  Python for Linguists

  • Michael Hammond(Author)
  • 2020(Publication Date)
  • Cambridge University Press

    (Publisher)

  11 Functional Programming In this chapter, we introduce functional programming, a style of programming that grows out of the lambda calculus. Some aspects of functional program- ming are commonly used in Python, and so it’s useful to understand the general principles, if only to make sense of code written by others. This style of pro- gramming also lends itself easily to parallel programming and the resulting efficiencies, so this is an additional benefit. This chapter focuses on advanced material, so if you’re new to programming or feel unsure of your foundations at this stage, proceed carefully! 11.1 Functional Programming Generally Functional programming is an ideal and in practice exists at various approx- imations to this ideal. The ideal is lambda calculus: everything is a function. What this means is two things. First, everything else goes: variables, state- ments, numbers, strings, etc. Second, functions are really functions; some set of values is mapped to some other value, with no side effects, no variability in what the function maps to. Python is not the perfect vehicle for functional programming, so the ideal is not completely reached with it, or at least not easily. In practice, what this means is the following: ● We avoid global variables. ● Variables are not used mutably. ● Functions are freely used as arguments to other functions and can be returned from functions. ● Functions can be created anonymously with lambda when needed. ● Recursion, overt or covert, is used widely. ● Control structures are avoided or not used at all. Their work is done by functions and comprehensions. We’ve covered some of these topics to varying degrees already, but let’s go through each of them now in the context of functional programming generally. 261 262 Functional Programming 11.2 Variables, State, and Mutability State refers to the value of variables at any particular point in the execution of a program.

  Sign up to read

  Learn more about book
• 

  No longer available |Learn more

  Functional Programming For Dummies

  • John Paul Mueller(Author)
  • 2019(Publication Date)
  • For Dummies

    (Publisher)

  (The next section, “Discovering Languages that Support Functional Programming,” describes the available languages in more detail.) In fact, you may even be performing functional programming tasks in your current language without realizing it. Every time you create and use a lambda function, you’re likely using functional programming techniques (in an impure way, at least). In addition to using lambda functions, languages that implement the functional programming paradigm have some other features in common. Here is a quick overview of these features: First-class and higher-order functions: First-class and higher-order functions both allow you to provide a function as an input, as you would when using a higher-order function in calculus. Pure functions: A pure function has no side effects. When working with a pure function, you can Remove the function if no other functions rely on its output Obtain the same results every time you call the function with a given set of inputs Reverse the order of calls to different functions without any change to application functionality Process the function calls in parallel without any consequence Evaluate the function calls in any order, assuming that the entire language doesn’t allow side effects Recursion: Functional language implementations rely on recursion to implement looping. In general, recursion works differently in functional languages because no change in application state occurs. Referential transparency: The value of a variable (a bit of a misnomer because you can’t change the value) never changes in a functional language implementation because functional languages lack an assignment operator. You often find a number of other considerations for performing tasks in functional programming language implementations, but these issues aren’t consistent across languages. For example, some languages use strict (eager) evaluation, while other languages use non-strict (lazy) evaluation

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  The Software Life Cycle

  • Darrel Ince, Derek Andrews(Authors)
  • 2014(Publication Date)
  • Butterworth-Heinemann

    (Publisher)

  In practice, functional programs written without considering these issues may well be inefficient or even unrunnable, but this may be acceptable for early and intermediate representations (i.e. specifications of one sort or another). 26 The software life cycle For example, the order in which independent subexpressions are evaluated is not constrained by a purely functional program. A particular order may be decided on in due course, or a nondeterministic order, or parallel evaluation if this is feasible. This is information about the functional program which can be added at a later stage of development. In contrast, expressing a representation in a conventional language requires this kind of decision, even if it is not appropriate at the current stage of development. If it is stated that an operation involves three suboperations and then combines their results in some way, it is necessary to decide whether this should be expressed as a sequence of three procedure calls, for example, or three parallel tasks. With regard to data storage, functional languages tend to use dynamic (recursive) data structures such as lists and trees rather than arrays and record-structures. Data structures in functional programs are not updated by destructive assignment: new modified structures are constructed using copies of old values; old structures that are no longer referenced by any expression are garbage-collected at run time. In practice, generalized data structures and nondestructive updating may lead to inefficiencies. However, as with scheduling, information about optimized data structures and destructive updating can be added to a functional representation at a later stage of development. To summarize, it is necessary to factor out the different kinds of information that make up a system of executable software, and allow this information to be introduced at different stages of development.

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  Programming Language Fundamentals

  A Metalanguage Approach in Elm

  • Martin Erwig(Author)
  • 2024(Publication Date)
  • Wiley

    (Publisher)

  2 Functional Programming with Elm Chapter Summary An introduction to the basics of functional programming using the language Elm. Working with expressions and names in the Elm interpreter. Definition and use of functions, in particular, the concept of currying and partial function application. Recursion and how it relates to iteration. Lists, pattern matching, and the basics of general data types. (More details and examples of data types to follow in later chapters where they are used for representing syntax, semantics, and type systems.) The concept of higher-order functions and their use as as control structures. In imperative languages, such as C, Java, or Python, computation is expressed as transformations of state, that is, the underlying programming model views a program as a series of statements that perform successive changes to a state, which can be accessed through names called variables. For example, if a pro- gram declares an integer variable x, then the assignment x = 3 has the effect that referencing the variable x afterwards will yield the value 3, at least until x is changed by another assignment. The functional core of Elm does not have an underlying global state that can be manipulated. Specifically, Elm does not have an assignment operation for changing the values of variables. It doesn’t have while or for loops either. Elm is a functional programming language, in which every computation is ex- pressed as a function. A function has one or more parameters and is defined by an expression (also called the function’s body) that can refer to these parame- Programming Language Fundamentals: A Metalanguage Approach in Elm, First edition. Martin Erwig. © 2024 Martin Erwig. Published 2024 by John Wiley & Sons Inc. Companion website: www.wiley.com/go/ProgrammingLanguageFun 14 2 Functional Programming with Elm Concept Elm C, Java, etc.

  Sign up to read

  Learn more about book