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"
int main(int argc, char** argv) {
/* Stack objects are created using "$" */
var i0 = $(Int, 5);
var i1 = $(Int, 3);
var i2 = $(Int, 4);
/* Heap objects are created using "new" */
var items = new(Array, Int, i0, i1, i2);
/* Collections can be looped over */
foreach (item in items) {
print("Object %$ is of type %$\n",
item, type_of(item));
}
/* Heap objects destructed via Garbage Collection */
return 0;
}#include "Cello.h"
int main(int argc, char** argv) {
/* Shorthand $ can be used for basic types */
var prices = 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 (key in prices) {
var val = get(prices, key);
print("Price of %$ is %$\n", key, val);
}
return 0;
}Learning Resources:
Articles about its creation and internal workings:
- Best Improvements of Cello 2.0
- A Fat Pointer Library
- Cello vs C++ vs ObjC
- Benchmarks
- Garbage Collection
#include "Cello.h"
int main(int argc, char** argv) {
var items = new(Array, Int,
$I( 8), $I( 5), $I(20),
$I(15), $I(16), $I(98));
/* Iterate over indices using "range" */
foreach (i in range($I(len(items)))) {
print("Item Range %i is %i\n", i, get(items, i));
}
/* Iterate over every other item with "slice" */
foreach (item in slice(items, _, _, $I(2))) {
print("Item Slice %i\n", item);
}
return 0;
}#include "Cello.h"
/* Define a normal C structure */
struct Point {
float x, y;
};
/* Make it compatible with Cello */
var Point = Cello(Point);
int main(int argc, char** argv) {
/* Create on Stack or Heap */
var p0 = $(Point, 0.0, 1.0);
var p1 = 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 */
return 0;
}- 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 [email protected], 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.