Group: Functional programming

  • accumulate: See Fold
  • aggregate: See Fold
  • anonymous function: Another name for a Lambda (λ) </>
  • arity: Number of arguments taken by function/operation </>
  • associativity: Property where combination order is not relevant e.g. (a + b) + c is equal to a + (b + c)
  • auto currying: Conversion of a function into a function that can take fewer arguments than needed and return a function that will accept the rest (see Currying)
  • category theory: Branch of mathematics that formalizes structure using labeled, directed graphs </>
  • category: Collection of objects and the morphisms (transformations) between them </>
  • choice type: See tagged union
  • closure: Stores a function and a captured environment such that some variables are bound without being supplied by the caller </>
  • commutativity: Producing the same result regardless of order (e.g. 2 + 3 = 3 + 2) </>
  • composable: Providing components that can be selected and assembled in various combinations to satisfy varying requirements </>
  • compress: See Fold
  • continuation-passing style: Programming style where control is passed in the form of a continuation </>
  • continuation: Representation of the state of a program's execution which allows you to access and manipulate it (helpful for implementing asynchronous control flow, coroutines, generators, exceptions) </>
  • coproduct: See tagged union
  • currying: Conversion of a function that takes multiple arguments to a series of single-argument functions </>
  • discriminated union: See tagged union
  • disjoint union: See tagged union
  • endomorphism: Function that transforms one type to the same type, e.g. String -&gt; String </>
  • equational reasoning: Thinking in terms of values and expressions that can be substituted in all contexts (like math equations)
  • first-order functions: Functions that aren't higher order (see Higher-order functions </>
  • first-order logic: Mathematics/logic term for system of statements that are formally defined and can be evaluated to true/false (also known as Predicate logic) </>
  • fold: Application of a function against an accumulator and each element in a list/array that results in a single value </>
  • foldable: See Fold
  • function composition: Producing a function from two or more functions that feeds the output of one into the other(s) (see Partial application) </>
  • functor (C++): In C++, unlike functional programming, functor means a function object </>
  • functor (Functional Programming): Something that can mapped over. Simple examples are arrays and the Option type. Must preserve identity and be composable. </>
  • higher-kinded types (HKT): Higher-level type constructor abstracting over entities that are themselves type constructors </>
  • higher-order functions (HOF): A function that returns a function and/or takes one or more functions as argument(s) </>
  • higher-order logic: Mathematics/logic term for predicate logic with additional quantifiers/functions </>
  • homomorphic encryption: Allows computation on encrypted data without decrypting it first </>
  • homomorphism: A structure-preserving mapping function. Elements/structure may appear different before and after transformation, e.g. squaring a number. </>
  • idempotence: A function or service operation is idempotent if calling it multiple times does not produce a different result </>
  • idempotency: See idempotence
  • idempotent: See idempotence
  • inject: See Fold
  • isomorphism: Function that maps one structure to another without losing structure. Is reversible. e.g. x=1,y=2 -&gt; (1,2) </>
  • kind: The type of a type constructor </>
  • lambda calculus (λ-calculus): Formal system in mathematical logic for expressing computation based on function abstraction </>
  • lambda (λ): Anonymous function (no name) that can still be treated like a value, passed to other functions, returned, etc. </>
  • lens: An optic that applies to product types. See Optics
  • lift: transform a function into a function within another (usually more general) setting </>
  • map (function): Applies a given function to each element of a list and produces a new list of the results </>
  • maybe: Tagged union with two types often called Some and None. a.k.a. Option </>
  • monad: Abstraction that allows you to wrap values and provides function(s) for composition </>
  • morphism: A function that transforms one structure to another </>
  • optics: Functional abstraction/value that allows you to get/set particular things in complex data types
  • option: Tagged union with two types often called Some and None. a.k.a. Maybe </>
  • partial application: Process of fixing one or more function arguments to produce a function with fewer arguments </>
  • partial function: See partial application for the common CS meaning (link for this is a related mathematics term) </>
  • point-free style: Where a function is defined through function composition instead of identifying arguments </>
  • predicate logic: Mathematics/logic term for system of statements that are formally defined and can be evaluated to true/false (also known as First-order logic) </>
  • predicate: Function that returns true or false, often used as a filter </>
  • product type: Compound type (e.g. structs, records, and tuples) </>
  • pure function: A function whose outputs are determined solely by its inputs and that causes no side effects </>
  • purity: See pure function
  • reduce: See Fold. Also see MapReduce for distributed systems term
  • referential transparency: An expressions is referentially transparent if it can be replaced with its value and not affect the program (and vice versa) </>
  • semigroup: Type class / object with one associative operator (often named 'append', 'combine', or 'concat')
  • setoid: Functional programming term for an object with an equals method
  • side effect: Modification of state outside of a function, e.g. the heap or I/O (see Pure function) </>
  • sum type: See tagged union
  • tacit programming: See Point-free style </>
  • tagged union: Data structure that can hold a value of different but fixed types (only one at a time) </>
  • type class: Allows ad-hoc polymorphism by specificying the behaviors needed and not explicit inheritance </>
  • type constructor: Builds new types from old ones. e.g. given an Int to List[T], it builds List[Int] </>
  • variant record: See tagged union
  • variant: See tagged union