Question

You don’t offen see Maybe List except for error-handling for example, because lists are a bit Maybe themselves: they have their own “Nothing“: [] and their own “Just“: (:).
I wrote a list type using Maybe and functions to convert standard and to “experimental” lists. toStd . toExp == id.

data List a = List a (Maybe (List a))
    deriving (Eq, Show, Read)

toExp [] = Nothing
toExp (x:xs) = Just (List x (toExp xs))

toStd Nothing = []
toStd (Just (List x xs)) = x : (toStd xs)

What do you think about it, as an attempt to reduce repetition, to generalize?

Trees too could be defined using these lists:

type Tree a = List (Tree a, Tree a)

I haven’t tested this last piece of code, though.

Answer 1

All ADTs are isomorphic (almost–see end) to some combination of (,),Either,(),(->),Void and Mu where

data Void --using empty data decls or
newtype Void = Void Void

and Mu computes the fixpoint of a functor

newtype Mu f = Mu (f (Mu f))

so for example

data [a] = [] | (a:[a])

is the same as

data [a] = Mu (ListF a)
data ListF a f = End | Pair a f

which itself is isomorphic to

newtype ListF a f = ListF (Either () (a,f))

since

data Maybe a = Nothing | Just a

is isomorphic to

newtype Maybe a = Maybe (Either () a)

you have

newtype ListF a f = ListF (Maybe (a,f))

which can be inlined in the mu to

data List a = List (Maybe (a,List a))

and your definition

data List a = List a (Maybe (List a))

is just the unfolding of the Mu and elimination of the outer Maybe (corresponding to non-empty lists)

and you are done…

a couple of things

1. Using custom ADTs increases clarity and type safety

2. This universality is useful: see GHC.Generic

---

Okay, I said almost isomorphic. It is not exactly, namely

hmm = List (Just undefined)

has no equivalent value in the [a] = [] | (a:[a]) definition of lists. This is because Haskell data types are coinductive, and has been a point of criticism of the lazy evaluation model. You can get around these problems by only using strict sums and products (and call by value functions), and adding a special “Lazy” data constructor

data SPair a b = SPair !a !b
data SEither a b = SLeft !a | SRight !b
data Lazy a = Lazy a --Note, this has no obvious encoding in Pure CBV languages,
--although Laza a = (() -> a) is semantically correct, 
--it is strictly less efficient than Haskell's CB-Need 

and then all the isomorphisms can be faithfully encoded.