Generic

Generic is a WIP language made by User:Tailcalled in a way that makes many concepts from Category Theory easy to define.

Concepts

The main elements in the language are currently concepts. They are a way to define something in an extremely abstract way. They are a bit like interfaces or typeclasses, and are used in some of the same areas as typeclasses, but are more first-class.

Defining the concept 'Category' from category theory is done this way:

 concept Category
   obj in coll
   hom(A in obj, B in obj) in coll
   id(A in obj) in hom(A, A)
   compose(A in obj, B in obj, C in obj, f in hom(A, B), g in hom(B, C)) in hom(A, C)

'coll' is the collection of most (possibly all?) collections. Explaining each line:

 concept Category

This basically names the concept. The compiler/interpreter has to make a global collection called 'Category'.

   obj in coll

This line states that every category has a collection called 'obj'.

   hom(A in obj, B in obj) in coll

This means that there is a set for every two elements in obj. That collection is referred to as hom(A, B).

   id(A in obj) in hom(A, A)

This states that there is an element in hom(A, A) for element A in obj.

   compose(A in obj, B in obj, C in obj, f in hom(A, B), g in hom(B, C)) in hom(A, C)

This states that for every three elements A, B, C in obj, and every element in hom(A, B) and every element in hom(B, C), there is an element in hom(A, C).

One example of how concepts are more first-class than typeclasses can be seen in this definition of functors:

 concept Functor
   src in Category
   dst in Category
   F(A in src.obj) in dst.obj
   f(A in src.obj, B in src.obj, m in src.hom(A, B)) in dst.hom(F(A), F(B))

This functor has two categories, src and dst, defined like this:

   src in Category
   dst in Category

Category is the collection of all categories. Accessing a part of a specific implementation of a concept can also be done:

   F(A in src.obj) in dst.obj

This maps every element of obj in the category src to an element of obj in dst.

Actual Code

Tailcalled has currently not designed any kind of way to actually code something, but he's working on it.

Collections

Tailcalled has not yet decided on whether to use set theory, type theory or something completely different, which is why he used the word 'collection' instead of set or type. Collections might be declared with a syntax like this:

 coll List given (A in coll)
   with () -- () is the empty product
   given
     head in A
     tail in List(A)
   be
     with (head, tail)

This makes anything of the form (a, (b, (c, (d, (e, (f, ())))))) a list iff a-f are all in one collection. A collection of disjoint unions could be defined like this:

 coll Sum given (A in coll, B in coll)
   given
     fst in A
   be
     with (#false, fst)
   given
     snd in B
   be
     with (#true, snd)

This system would probably require something that's equivalent to dependent typing.