1. 3

  2. 1

    Most of these definitions seem pretty good, but I have some critique of a few of them.

    An abstraction is a precise description of the ways in which different data types share common structure.

    Hm, that definition captures only a very narrow sense of the word. Functional programming is based on lambda calculus, and in lambda calculus the word abstraction means lambda abstraction (i.e., what most people would informally call a function). Of course, the word abstraction can also mean many other things, even within functional programming.

    An algebra is a set of objects together with a set of operations on those objects.

    I think it’s more common for object, in a mathematical sense, to refer to an entire group (which is more consistent with its usage in category theory), not the elements of a group. The word elements is more appropriate for a group because a group is a set with some structure, and a set contains elements.

    Functional Effect

    Interesting. I’ve never heard this term outside of this blog post. In papers about monads and algebraic effects, the term computational effect is the term I usually encounter.

    To map over a polymorphic data type is to change one type parameter into another type, by specifying a way to transform values of that type. For example, a list of integers can be mapped into a list of strings, by specifying a way to transform an integer into a string. To be well-defined, mapping over any polymorphic data type with an identity function must yield something that is equal to the original value.

    I’d really expect to see at least a passing mention of the word functor here, if for nothing else to give the reader a keyword to Google. It’s interesting that only one of the functor laws is mentioned here (the identity law, but not the composition law). Seems arbitrary?

    Sometimes called generics, parametric polymorphism is a feature of some programming languages that allows universally quantifying a function or a data type over one or more type parameters. Such polymorphic functions and polymorphic data types are said to be parameterized by those type parameters. Parametric polymorphism allows the creation of generic code, which works across many different data types; and also the creation of generic data types (like collections).

    This is good, but it misses the most important point about parametric polymorphism: parametricity. This property distinguishes parametric polymorphism from ad hoc polymorphism.

    Universal quantification asserts that a statement or type holds for all possible values of a given variable.

    It’s a bit awkward to talk about a type “holding” for values. This makes a little more sense in the context of Curry-Howard, but even then it’s still fairly awkward exposition. I would expect this entry to make at least a passing mention to parametric polymorphism, which also makes an appearance in this glossary.

    A universal type is a type that is universally quantified over. In programming languages, all type parameters of functions and data types are universal types.

    Hm, I’m still getting this feeling that the glossary contains many related (or even synonymous) terms without linking them together in a helpful way.

    1. 1

      Thank you for your feedback, I incorporated much of it into a revision!

      I didn’t change abstraction since I am deliberately using a more narrow definition, a functional analogue of how the word is used in mainstream programming languages like Java. (Any definition that considers #define of the C preprocessor to be a form of abstraction is not useful in everyday parlance nor related at all to how mainstream programming language communities use the term.)