Cello is a library that brings higher level programming to C.
By acting as a modern, powerful runtime system Cello makes many things easy that were previously impractical or awkward in C such as:
- Generic Data Structures
- Polymorphic Functions
- Interfaces / Type Classes
- Constructors / Destructors
- Optional Garbage Collection
- Exceptions
- Reflection
And because Cello works seamlessly alongside standard C you get all the other benefits such as great performance, powerful tooling, and extensive libraries.
#include"Cello.h"intmain(intargc, char**argv) {
/* Stack objects are created using "$" */vari0=$(Int, 5);
vari1=$(Int, 3);
vari2=$(Int, 4);
/* Heap objects are created using "new" */varitems=new(Array, Int, i0, i1, i2);
/* Collections can be looped over */foreach (iteminitems) {
print("Object %$ is of type %$\n",
item, type_of(item));
}
/* Heap objects destructed via Garbage Collection */return0;
}#include"Cello.h"intmain(intargc, char**argv) {
/* Shorthand $ can be used for basic types */varprices=new(Table, String, Int);
set(prices, $S("Apple"), $I(12)); set(prices, $S("Banana"), $I( 6)); set(prices, $S("Pear"), $I(55)); /* Tables also support iteration */foreach (keyinprices) {
varval=get(prices, key);
print("Price of %$ is %$\n", key, val);
}
return0;
}Learning Resources:
Articles about its creation and internal workings:
#include"Cello.h"intmain(intargc, char**argv) {
varitems=new(Array, Int, $I( 8), $I( 5), $I(20), $I(15), $I(16), $I(98));
/* Iterate over indices using "range" */foreach (iinrange($I(len(items)))) {
print("Item Range %i is %i\n", i, get(items, i));
}
/* Iterate over every other item with "slice" */foreach (iteminslice(items, _, _, $I(2))) {
print("Item Slice %i\n", item);
}
return0;
}#include"Cello.h"/* Define a normal C structure */structPoint {
floatx, y;
};
/* Make it compatible with Cello */varPoint=Cello(Point);
intmain(intargc, char**argv) {
/* Create on Stack or Heap */varp0=$(Point, 0.0, 1.0);
varp1=new(Point, $(Point, 0.0, 2.0));
/* It can be shown, compared, hashed, etc... ** ** p0: <'Point' At 0x000000000022FC58> ** p1: <'Point' At 0x00000000004C7CC8> ** cmp: 1 ** hash: 2849275892l */print("p0: %$\np1: %$\ncmp: %i\nhash: %ul\n",
p0, p1, $I(cmp(p0, p1)), $I(hash(p0)));
/* And collected by the GC when out of scope */return0;
}- Why does this exist?
I made Cello as a fun experiment to see what C looks like hacked to its limits. As well as being a powerful library and toolkit, it should be interesting to those who want to explore what is possible in C.
- How does it work?
I recommend reading A Fat Pointer Library to get an overview of how Cello works. You can also peek at the source code, which I'm told is fairly readable, or ask me any questions you like via e-mail.
- Can it be used in Production?
It might be better to try Cello out on a hobby project first. Cello does aim to be production ready, but because it is a hack it has its fair share of oddities and pitfalls, and if you are working in a team, or to a deadline, there is much better tooling, support and community for languages such as C++.
- Is anyone using Cello?
People have experimented with it, but there is no high profile project I know of that uses it. Cello is too big and scary a dependency for new C projects if they want to be portable and easy to maintain.
- Can I get involved?
Yes! That would be great. If you do anything with Cello I'd love to know, you
can e-mail me at contact@theorangeduck.com, or help with the development at
the Cello github repo. Contributions
are very welcome.
- Who are you?
Hello! I'm Daniel Holden. You many know me from a book I wrote or my personal website. I also have a rarely updated twitter account.