Function Composition - forward composition versus backward composition

0 likes737 views

The document discusses function composition in Scala. It defines forward composition as applying one function f to the result of another function g, written as f andThen g. Backward composition applies functions in the opposite order, first applying g and then f to the result, written as f compose g. Both operations can be implemented as curried functions in Scala, with andThen and compose respectively, that take the functions as arguments and return a function combining their operations.

Software

That new function is called the forward composition of the two functions f and g. In Scala, this operation is written as f andThen g …
…
The forward composition is denoted by (pronounced “before”) and can be defined as
The symbol , means “is defined as”.
We could write the forward composition as a fully parametric function,
def andThen[X, Y, Z](f: X => Y)(g: Y => Z): X => Z = { x => g(f(x)) }
The type signature of this curried function is
This type signature requires the types of the function arguments to match in a certain way, or else the composition is undefined.
The backward composition of two functions f and g works in the opposite order: first g is applied and
then f is applied to the result. Using the symbol (pronounced “after”) for this operation, we can write
In Scala, the backward composition is called compose and used as f compose g. This method may be
Implemented as a fully parametric function
def compose[X, Y, Z](f: Y => X)(g: Z => Y): Z => X = { z => f(g(z)) }
The type signature of this curried function is Sergei Winitzki
sergei-winitzki-11a6431

The document discusses factoring effects out of impure procedures in Scala. It shows an example of a contest function that originally coupled the logic for computing the winner with printing the output. This was refactored to separate the pure winner logic into its own function, while the contest function now handles just calling winner and printing the result. This illustrates a general technique of factoring an impure procedure into a pure core function and separate input/output handling functions to isolate the side effects.

Applicative Functor - Part 3Philip Schwarz

Scalaz provides an Applicative typeclass that can be used for the username and password validation program. It automatically supplies instances of <*> and *> for Validation, where the error type is a Semigroup. While Validation[String, Int] works, the error type for the validation program is actually a non-empty list of strings to prevent empty error messages. Scalaz provides a NonEmpty list datatype that has a Semigroup instance and represents a list that can never be empty, making it a better fit as an error type than a standard List.

Monad Fact #4Philip Schwarz

The document explains the concept of monads in functional programming, defining a monad as an implementation of a minimal set of combinators that adhere to associativity and identity laws. It provides examples of the identity monad and its composition functions, illustrating how these relate to other monads such as option and list. Additionally, it explores the compositional responsibilities of the kleisli composition operator in different monads.

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part 2Philip Schwarz

The document explores functional programming concepts, particularly focusing on aggregation functions defined inductively and implemented using recursion, emphasizing the importance of mathematical principles in practical software development. It illustrates these concepts with examples in Scala and discusses the challenges of stack overflow errors in recursive implementations, offering solutions like tail-recursion. The text serves as both a tutorial and reference, aiming to provide clear definitions and explanations to help programmers grasp complex mathematical notions relevant to coding.

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part ...Philip Schwarz

The document discusses the implementation of functional programming techniques, focusing on folds, particularly right folds, to handle lists including those with infinite elements. It delves into the filter function, explaining how to replace constructors to filter elements based on a predicate, and introduces the heador function that returns the first element of a list or a default value if the list is empty. Key concepts such as lazy evaluation, the applicative functor, and the implications for performance and behavior when working with infinite lists are also explored.

Game of Life - Polyglot FP - Haskell - Scala - Unison - Part 3Philip Schwarz

The document discusses the implementation of a new IO monad in Scala that overcomes stack overflow errors using trampolining and functional programming concepts. It details how traditional IO actions can lead to stack overflow due to recursive calls and how the new IO type can manage control flow through data constructors instead of function calls. By reifying control flow as data constructors, the proposed solution maintains tail recursion and allows for infinite computations without stack overflow, effectively transforming the system into a coroutine model.

Introducing Assignment invalidates the Substitution Model of Evaluation and v...Philip Schwarz

The document discusses the implications of introducing assignment in programming languages, focusing on its effects on the substitution model of evaluation and referential transparency. It highlights how assignment allows for local state within computational objects, but complicates procedure application and increases the difficulty of reasoning about programs. Ultimately, the introduction of assignment challenges the notion of 'equals can be substituted for equals' in expressions, leading to issues of sameness and change in programming behaviors.

Monad Fact #2Philip Schwarz

The document discusses the equivalence of nested and chained flatmaps in the context of Kleisli arrows for monadic composition in Scala. It provides concrete examples with functions related to companies, drivers, and cars, demonstrating how to simplify compounding operations using flatmap and the for comprehension syntax. The key takeaway is the demonstration of monadic law of associativity and how both nested and chained forms achieve the same outcomes in function composition.

Sierpinski Triangle - Polyglot FP for Fun and Profit - Haskell and ScalaPhilip Schwarz

The document explores how to draw the Sierpiński triangle using Haskell and Scala, detailing a recursive algorithm for generating the fractal image. It discusses functional programming's role in managing side effects during graphics drawing, particularly through IO actions in Haskell as opposed to side-effecting functions in Scala. The document also provides code implementations and highlights the importance of using powers of two as initial sizes for uniform subdivisions in the triangle's construction.

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part 4Philip Schwarz

The document discusses the concept of folds in functional programming, particularly focusing on right folds and their ability to work with infinite lists. It explains the implementation of functions such as filter and heador using foldr, exploring the nuances of predicate matching and the lazy evaluation characteristics of certain functions. Additionally, it highlights the importance of understanding how the accumulator technique and applicative functions operate in this context.

N-Queens Combinatorial Problem - Polyglot FP for Fun and Profit – Haskell and...Philip Schwarz

The document discusses the migration of the 'guard' function in Haskell from MonadPlus to Alternative, explaining their differences and demonstrating how to write Haskell and Scala programs that solve the n-queens problem using graphics libraries. It details the definitions and instances of the Alternative type class, along with its behavior, and includes examples of using these concepts in both languages. The text also covers principles guiding the Doodle graphics library, emphasizing the composition of images and the separation of description and action in graphics rendering.

Function Applicative for Great Good of Palindrome Checker Function - Polyglot...Philip Schwarz

The document discusses the concept of point-free style in functional programming, particularly in Haskell, using examples like an applicative palindrome checker. It explains the benefits of this style, such as conciseness and clarity in expressing function compositions without explicitly mentioning the arguments. Additionally, it explores related concepts like extensionality and functional composition, emphasizing how these techniques can lead to more elegant and abstract code.

Functional Core and Imperative Shell - Game of Life Example - Haskell and ScalaPhilip Schwarz

This document discusses the structure of programs using the 'functional core and imperative shell' paradigm, specifically applying it to the Game of Life example in both Haskell and Scala. It provides a program structure flowchart that illustrates how the program is divided into a functional core, which handles logic, and an imperative shell, which manages input and output. The document also includes code snippets and describes the behavior of the Game of Life when run with a specific initial configuration.

Scala 3 enum for a terser Option Monad Algebraic Data TypePhilip Schwarz

The document discusses the implementation of a terser definition of the option monad using Scala 3 enums, highlighting the benefits and convenience it brings to algebraic data types (ADTs). It covers the essential methods for the option monad such as map, flatMap, and fold, while also emphasizing the integration of these methods within functional programming paradigms. Additionally, it includes practical examples demonstrating the option monad in action and a refresher on functor and monad laws.

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala Part 2 ...Philip Schwarz

The document discusses implementing aggregation functions inductively using recursion or folding. It explains that aggregation functions like sum, count, max can be defined inductively with a base case for empty sequences and a recursive step to process additional elements. Implementing functions recursively risks stack overflow for long inputs, but tail-recursion and accumulator tricks can help avoid this. Folds provide an alternative to recursion for defining aggregations by processing sequences from left to right or right to left.

Monads do not ComposePhilip Schwarz

The document discusses the composition of monads, functors, and applicative functors in functional programming, particularly in Scala. It outlines the relationships between these concepts, including definitions, examples of composition, and the challenges faced in composing monads. The document emphasizes that while functors and applicative functors can be composed, monads do not compose in a general manner due to the complexities involved in their definitions and operations.

The Functional Programming Triad of Map, Filter and FoldPhilip Schwarz

This document discusses the functional programming concepts of map, filter, and fold, using examples from languages like Scheme, Clojure, Scala, Haskell, and Unison. It explores the construction of compound data structures using the pair data type, which is foundational for representing lists and hierarchical data. The text emphasizes the importance of closure property in creating complex data structures and provides insights into safe and unsafe list manipulation functions across different programming languages.

The Functional Programming Triad of Folding, Scanning and Iteration - a first...Philip Schwarz

The document discusses the functional programming concepts of folding, scanning, and iteration, specifically in Scala and Haskell. It provides examples of implementing digit-to-integer and integer-to-digit conversion functions using folds and iterative constructs, exploring the readability and usability of code in both languages. Additionally, it highlights operators in Haskell and Scala that aid in function application, giving suggestions for improving readability.

Simple IO Monad in 'Functional Programming in Scala'Philip Schwarz

FunctorsPhilip Schwarz

The document discusses the concept of functors in category theory and programming, describing functors as mappings between categories that preserve the structure of objects and arrows. It highlights the role of functors in programming, particularly in functional programming, where they facilitate the application of functions over data structures like lists and options without altering the structures themselves. Various examples and definitions are provided to illustrate how functors operate and their importance in type systems.

Scala categorytheoryKnoldus Inc.

Category theory concepts such as objects, arrows, and composition directly map to concepts in Scala. Objects represent types, arrows represent functions between types, and composition represents function composition. Scala examples demonstrate how category theory diagrams commute, with projection functions mapping to tuple accessors. Thinking in terms of interfaces and duality enriches both category theory and programming language concepts. Learning category theory provides a uniform way to reason about programming language structures and properties of data types.

State MonadPhilip Schwarz

The document discusses the implementation and utility of the state monad in Scala, particularly in managing state in functional programming. It includes examples demonstrating the challenges of handling state without the monad and gradually introduces a more efficient state monad that simplifies state management in for expressions. Finally, it emphasizes understanding the underlying code and the principles of monads, including key concepts like unit and flatmap.

Monoids - Part 1 - with examples using Scalaz and CatsPhilip Schwarz

A monoid is an algebraic structure consisting of a set and a binary operation that is associative and has an identity element. Some key properties of monoids include: 1) A monoid consists of a type A, a binary operation op that combines two values of type A, and a zero value that acts as an identity. 2) The binary operation must be associative, meaning op(op(x,y),z) = op(x,op(y,z)). 3) The zero value must satisfy the identity laws: op(x, zero) = x and op(zero, x) = x. 4) Common examples of monoids include string concatenation

Clojure basicsKnoldus Inc.

The document provides an introduction to the Clojure programming language. It discusses that Clojure is a functional Lisp dialect that runs on the Java Virtual Machine. It extends the principle of code-as-data to include maps and vectors in addition to lists. The document also provides an overview of Clojure's core data structures, functions, concurrency features like atoms and agents, and how to get started with Clojure.

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part 5Philip Schwarz

The document discusses how right folds can efficiently operate on large and infinite lists in Haskell due to lazy evaluation and function strictness. It explains the implications of using strict left folds and introduces the concepts of lazy evaluation and reduction strategies relevant to functional programming. The document also covers the characteristics and comparisons of call-by-value and call-by-name evaluation, emphasizing lazy evaluation's advantages in programming with infinite structures.

Introduction to Functional Programming in JavaScripttmont

The document provides an in-depth overview of functional programming, highlighting key concepts such as lambda calculus, higher-order functions, and recursion. It discusses various functional programming languages including Haskell and Erlang, and illustrates concepts through JavaScript examples. Additionally, it touches on topics like Church numerals, addition in functional programming, and the Y combinator for defining recursive functions.

Monoids - Part 2 - with examples using Scalaz and CatsPhilip Schwarz

The document discusses monoids in Scalaz and Cats, specifically for the Option type. It explains that in Scalaz there are three Option monoids (optionFirst, optionLast, optionMonoid) that combine Options in different ways, while Cats only has one Option monoid (optionMonoid) that combines the contents. It also introduces MonoidK, which allows constructing a monoid that behaves like optionFirst by combining Options based on their orElse method. The document provides examples and explanations of how Semigroup, SemigroupK, Monoid, and MonoidK work and differ for types like List, Set, and Option. It also defines a monoid for endofunctions that composes

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part ...Philip Schwarz

This document discusses the concepts of evaluation strategies, particularly lazy evaluation, in Haskell and Scala, highlighting how right folds can be applied to infinite lists due to the non-strictness of functions. It explains the distinction between innermost and outermost reductions in terms of function application and argument evaluation, emphasizing that lazy evaluation allows programming with infinite structures. Additionally, it concludes that lazy evaluation, based on call-by-name, ensures efficient termination and avoids unnecessary repeated evaluations of expressions.

Folding Cheat Sheet Series Titles - a series of 9 decksPhilip Schwarz

Folding Cheat Sheet # 9 - List Unfolding 𝑢𝑛𝑓𝑜𝑙𝑑 as the Computational Dual of ...Philip Schwarz

More Related Content

What's hot (20)