After years of dragging my feet I've been learning Haskell with the help of a few friends. Many Haskell concepts can be quite daunting so I decided to write one sentence summaries to simplify them for myself. These are not by any means complete but are useful as a jumping off point. This post draws inspiration from hemanth/functional-programming-jargon and the Standardized Ladder of Functional Programming.
A monad is composed of three functions and encodes control flow which allows pure functions to be strung together.
A recursive function is a function that calls itself inside its own definition.
A monad transformer allows you to stack more than one monad for use in a function.
Lift is an operation on a functor that uses
fmap to operate on the data contained in the functor.
Optics(lens and prisms) allow you to get and set data in a data type.
Currying uses partial application to return a function until all arguments are filled.
Map applies a function to every element of a list.
A predicate is a function that returns true or false.
Filter applies a predicate to a list and returns only elements which return true.
Pure functions always return the same output for a given input regardless of environment and cause no side effects.
A lambda is an unnamed function.
Lazy evaluation only evaluates expressions that your program actually uses.
Fold applies a function between elements of a list.
A morphism is a transformation from any object to any other object.
A category is a collection of objects, morphisms, and the configuration of the morphisms.
Functors are objects that can be
Types are an inherent characteristic of every Haskell expression.
Type classes are similar to OOP interfaces.
Algebraic data types are a method to describe the structure of types.
Parametric polymorphism allows generic type variables in place of types in the type signature of a function.
A monoid is a type with a single operation for combining values.
Free monads allow the transformation of functors to monads.