Finding the best name for mempty and empty List

[dan-zheng]

Context and motivation

In Haskell, mempty is the name for the monoid identity value.

On a different note: in Dex, we can construct an empty list via toList [] or AsList _ []. Both of these are function calls - it would be nice to have a single-identifier value whose meaning is "empty list".

Ideas

1. Define nil as empty List in the Prelude

def nil : List a = AsList _ []

instance Monoid (List a)
  mempty = nil
  ...

nil as empty list has precedent from languages like Lisp and Haskell.

This leaves the gnarly name mempty untouched.

2. Rename Monoid requirement mempty to nil

This would look like:

interface Monoid a
  nil : a
  mcombine : a -> a -> a

Benefits:

• nil is a nicer name than mempty, based on taste and aesthetics.
• There needn't be separate names for "empty list" and "monoid identity value". This reduces the API surface area in a desirable way.

Considerations here: nil might be confused with None (from data Option a = None | Some a in Haskell) or NULL & nullptr (from C/C++).

Having thought a bit, I think renaming mempty to nil still sounds quite good. Reasons:

• nil has precedent for meaning "empty (linked) list" from Lisp and Haskell and descendants like Idris.
• It seems reasonable (with good taste) to replace the gnarly name with mempty with nil also, which is simpler and a nice term-of-art with precedent.

OP's thoughts

I would be quite happy with (2), if everyone is comfortable. It might be nice to rename mcombine too - <> would be an easy non-controversial improvement.

Any thoughts?

[cristianurlea]

The absorbing/identity/neutral element is sometimes called zero, so I'll throw that in the hat of possible names.
I quite like ident as well, as a shorthand for identity element which does not clash with id, the function.
Another suggestion might be unit, as a monoid is a semigroup with a unit.

[apaszke]

unit might be easy to confuse with () (the only value of Unit type) 😕

[cristianurlea]

How about munit? That would force one to pronounce μ ( = mcombine ), which would be appropriate if not an over-the-top pun.

The only issue i see with mempty is that it gives the impression that every monoid is a container. Most of the time that's appropriate, with the only exception that comes to mind being where the the unit value represents a noop (think effects). Saying that one is performing the nil action isn't nearly as much of a stretch as mempty so it may well work.

[apaszke]

Huh, munit is actually quite nice. I think that the reason I've used to convince myself that mempty makes sense in a very general setting is because the list monoid is the free monoid. So "empty" is the most general version of the neutral element in some sense.

[dan-zheng]

I quite like munit too. How about this?

• Renaming mempty to munit.
  • "unit" is a better word than "empty" for the monoid identity value.
• Still adding nil for empty List to the Prelude
  • nil has much precedent for "empty list" from Lisp & Haskell & more. I'd prefer to type nil rather than (munit: List a) or alternatives.

Potential future changes:

• Eventually renaming mcombine to a better name, if it exists. Maybe <>, so long as (<>) a b can be used in prefix function notation.