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

continuationpassing 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 singleargument functions
</>

discriminated union: See tagged union

disjoint union: See tagged union

endomorphism: Function that transforms one type to the same type, e.g. String > String
</>

equational reasoning: Thinking in terms of values and expressions that can be substituted in all contexts (like math equations)

firstorder functions: Functions that aren't higher order (see Higherorder functions
</>

firstorder 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.
</>

higherkinded types (HKT): Higherlevel type constructor abstracting over entities that are themselves type constructors
</>

higherorder functions (HOF): A function that returns a function and/or takes one or more functions as argument(s)
</>

higherorder logic: Mathematics/logic term for predicate logic with additional quantifiers/functions
</>

homomorphic encryption: Allows computation on encrypted data without decrypting it first
</>

homomorphism: A structurepreserving 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 > (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)
</>

pointfree 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 Firstorder 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 Pointfree style
</>

tagged union: Data structure that can hold a value of different but fixed types (only one at a time)
</>

type class: Allows adhoc 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