Higher level programming in C

Overview

Cello

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.

Examples

#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;
}

Articles

Learning Resources:

Articles about its creation and internal workings:

More Examples

#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;
}

F.A.Q

  • 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.

Comments
  • Support for Lambdas on OS X

    Support for Lambdas on OS X

    Nested functions aren't properly supported in Clang it seems - even when compiling to GNU99. To replace them it seems the use of Blocks would be sufficient. Hopefully with some macro use it is possible to provide an identical interface.

    http://thirdcog.eu/pwcblocks/

    From a brief look over this page seems it would be very difficult to use and implement them via the same interface but I don't have a mac to test on so any contribution to this would be more than welcome.

    opened by orangeduck 19
  • Add libCello to Homebrew

    Add libCello to Homebrew

    I'm not sure if you'd like to add libCello to Homebrew but in case you do I thought I'd lend a hand.

    require 'formula'
    
    class Libcello < Formula
      homepage 'http://libcello.org/'
      url 'http://libcello.org/static/libCello-1.0.0.tar.gz'
      sha1 '005466d3dab88bf39e466bd12e9522a80aad617a'
    
      head 'https://github.com/orangeduck/libCello.git'
    
      def install
        system "make", "check"
        system "make", "install", "PREFIX=#{prefix}"
      end
    end
    

    The formula is currently waiting on changes from issue #24 before it will build successfully.

    opened by novabyte 14
  • Stack overflow when using Cello with OpenGL/GLFW

    Stack overflow when using Cello with OpenGL/GLFW

    This is weird.

    This is really, really, really weird.

    Here's the shortest example I could come up with:

    #include <GLFW/glfw3.h>
    #include <Cello.h>
    
    int main(int argc, char** argv) {
        glfwInit();
        GLFWwindow* w = glfwCreateWindow(800, 600, "test", NULL, NULL);
        glfwMakeContextCurrent(w);
    
        new(String);  // <-- This is the magic line.
    
        glfwTerminate();
        return 0;
    }
    

    And to build it:

    pkgs="glfw3 x11 xrandr xi xxf86vm xcursor xinerama gl"
    
    $CC `pkg-config --cflags $pkgs` -c -o tst.o tst.c
    $CC -o tst tst.o `pkg-config --libs $pkgs` -lCello -lm -lpthread
    

    When I try to run it, it segfaults at new(String). The stack trace is corrupted, but you can get the idea:

    (lldb) bt
    * thread #1: tid = 17223, 0x000000000042c613 tst`Type_Method_At_Offset(self=0x000000000064af20, cls=0x000000000064e828, offset=0, method_name="current") + 35 at Type.c:358, name = 'tst', stop reason = signal SIGSEGV: invalid address (fault address: 0x7fffff7fefe8)
      * frame #0: 0x000000000042c613 tst`Type_Method_At_Offset(self=0x000000000064af20, cls=0x000000000064e828, offset=0, method_name="current") + 35 at Type.c:358
        frame #1: 0x000000000042c5dd tst`type_method_at_offset(self=0x000000000064af20, cls=0x000000000064e828, offset=0, method_name="current") + 45 at Type.c:384
        frame #2: 0x000000000042673a tst`current(type=0x000000000064af20) + 42 at Thread.c:64
        frame #3: 0x0000000000416af3 tst`exception_throw(obj=0x000000000064a010, fmt="", args=0x00007fffff7ff298) + 35 at Exception.c:372
        frame #4: 0x000000000042d2d1 tst`Type_Of(self=<unavailable>) + 625 at Type.c:486
    (lldb) 
    

    In the original program, it was more obvious that it was a stack overflow. In this case, I'm not sure exactly why the trace isn't complete, but I know it's some kind of stack corruption from the overflow.

    opened by refi64 12
  • Improving of Dictionary implementation

    Improving of Dictionary implementation

    Improved the Dictionary implementation

    • Open addressing and linear probing (could be improved with something better ).
    • it resize dynamically
    • dictionary resizes to prime sizes, (with limits)
    • added test case to test dictionary rehashing when resizing (insertion of 500000 different Int keys)
    • small fix on the Makefile clean
    opened by mogui 9
  • thread-local storage not supported for this target

    thread-local storage not supported for this target

    I can't build on OS X. I figure it's something machine-specific, as other people are raising issues about post-build problems. That said, I can't figure out what the problem is.

    In file included from Array.c:5:
    ../include/Cello/Exception.h:41: error: thread-local storage not supported for this target
    ../include/Cello/Exception.h:42: error: thread-local storage not supported for this target
    ../include/Cello/Exception.h:43: error: thread-local storage not supported for this target
    

    The code:

    extern __thread bool __exc_active;
    extern __thread int __exc_depth;
    extern __thread jmp_buf __exc_buffers[__EXC_MAX_DEPTH];
    

    autoreconf -i suggested ACLOCAL_AMFLAGS=-I m4 in Makefile.am, which didn't help. ./configure; make still results in the build errors above.

    gcc -v details:

    Using built-in specs.
    Target: i686-apple-darwin11
    Configured with: /private/var/tmp/llvmgcc42/llvmgcc42-2336.11~182/src/configure
      --disable-checking
      --enable-werror
      --prefix=/Applications/Xcode.app/Contents/Developer/usr/llvm-gcc-4.2
      --mandir=/share/man
      --enable-languages=c,objc,c++,obj-c++
      --program-prefix=llvm-
      --program-transform-name=/^[cg][^.-]*$/s/$/-4.2/
      --with-slibdir=/usr/lib
      --build=i686-apple-darwin11
      --enable-llvm=/private/var/tmp/llvmgcc42/llvmgcc42-2336.11~182/dst-llvmCore/Developer/usr/local
      --program-prefix=i686-apple-darwin11-
      --host=x86_64-apple-darwin11
      --target=i686-apple-darwin11
      --with-gxx-include-dir=/usr/include/c++/4.2.1
    Thread model: posix
    gcc version 4.2.1 (Based on Apple Inc. build 5658) (LLVM build 2336.11.00)
    

    Any ideas? What should I check next?

    opened by garthk 8
  • Problematic Map_Put() / Map_Get()

    Problematic Map_Put() / Map_Get()

    It is implied from Map_Get() that the tree in md->root should at the very least be a Binary Search Tree. However the Map_Put() does not seem to respect the restriction that after inserting a new node, the key of any node is greater than any key from left subtree and less than any from right subtree.

    And it seems that the Map_Put() would easily lead to degeneration of the tree into a linked list, after a few times of insertions.

    opened by zhangchn 7
  • Lambda fail

    Lambda fail

    When trying to compile lambda example I get this:

    lambdas.c:52:37: error: expected ';' at end of declaration
      var Welcome_Pair(var fst, var snd) {
                                        ^
                                        ;
    lambdas.c:57:18: error: use of undeclared identifier 'welcome_uncurried'
      lambda_uncurry(welcome_uncurried, Welcome_Pair, 2);
                     ^
    /usr/include/Cello/Lambda.h:61:67: note: expanded from macro 'lambda_uncurry'
    #define lambda_uncurry(name, func_ptr, argc) lambda_uncurry##argc(name, func_ptr)
                                                                      ^
    /usr/include/Cello/LambdaCurry.h:13:10: note: expanded from macro 'lambda_uncurry2'
      lambda(name, args) { return func_ptr(at(args,0), at(args,1)); }
             ^
    /usr/include/Cello/Function.h:48:5: note: expanded from macro 'lambda'
        name->func = ^ var (var args)
        ^
    lambdas.c:59:8: error: use of undeclared identifier 'welcome_uncurried'
      call(welcome_uncurried, $(String, "John"), $(String, "David"));
           ^
    /usr/include/Cello/Function.h:13:30: note: expanded from macro 'call'
    #define call(x, ...) call_vl(x, var_list_new(__VA_ARGS__))
                                 ^
    3 errors generated.
    

    Which basically means this:

      /*
      ** We can use normal c-functions too.
      ** If they have all argument types as "var".
      ** Then they can be uncurried.
      */
    
      var Welcome_Pair(var fst, var snd) {
        print("Hello %s and %s!\n", fst, snd);
        return None;
      }
    
      lambda_uncurry(welcome_uncurried, Welcome_Pair, 2);
    
      call(welcome_uncurried, $(String, "John"), $(String, "David"));
    

    is not working.

    opened by qrpnxz 7
  • remove duplication from makefile: check for clang

    remove duplication from makefile: check for clang

    We remove the duplicate entries in ifeq Darwin/Linux by merging them and simply adding a new section which adds extra cflags/libs in case we're compiling with clang.

    Please note that on e.g. Ubuntu this will require to install libblocksruntime-dev which provides libBlocksRuntime

    opened by igalic 7
  • make check fails on master

    make check fails on master

    [email protected] ~/src/libCello (git)-[master] % make CC=gcc check
    gcc tests/core.c -c -I ./include -std=gnu99 -Wall -Werror -Wno-unused -O3 -g -fPIC -o obj/core.o
    gcc tests/data.c -c -I ./include -std=gnu99 -Wall -Werror -Wno-unused -O3 -g -fPIC -o obj/data.o
    gcc tests/exceptions.c -c -I ./include -std=gnu99 -Wall -Werror -Wno-unused -O3 -g -fPIC -o obj/exceptions.o
    gcc tests/functional.c -c -I ./include -std=gnu99 -Wall -Werror -Wno-unused -O3 -g -fPIC -o obj/functional.o
    gcc tests/memory.c -c -I ./include -std=gnu99 -Wall -Werror -Wno-unused -O3 -g -fPIC -o obj/memory.o
    gcc tests/ptest.c -c -I ./include -std=gnu99 -Wall -Werror -Wno-unused -O3 -g -fPIC -o obj/ptest.o
    gcc tests/test.c -c -I ./include -std=gnu99 -Wall -Werror -Wno-unused -O3 -g -fPIC -o obj/test.o
    gcc tests/threading.c -c -I ./include -std=gnu99 -Wall -Werror -Wno-unused -O3 -g -fPIC -o obj/threading.o
    gcc obj/core.o obj/data.o obj/exceptions.o obj/functional.o obj/memory.o obj/ptest.o obj/test.o obj/threading.o libCello.a -lpthread -ldl -lm -o test
    ./test
    
        +-------------------------------------------+
        | ptest          MicroTesting Magic for C   |
        |                                           |
        | Daniel Holden ([email protected]) |
        +-------------------------------------------+
    
    
      ===== Suite Core =====
    
        | Test Type ... Passed! 
        | Test Cast ... Passed! 
        | Test New ... Passed! 
        | Test Assign ... Passed! 
        | Test Copy ... Passed! 
        | Test Eq ... Passed! 
        | Test Ord ... Passed! 
        | Test Hash ... Passed! 
        | Test Collection ... Passed! 
        | Test Iter ... Passed! 
        | Test Push ... Passed! 
        | Test At ... Passed! 
        | Test Dict ... Passed! 
        | Test As Ctype ... Passed! 
        | Test Stream ... Passed! 
        | Test Type New ... Passed! 
        | Test Type Implements ... Passed! 
        | Test Type Parent ... Failed! 
    
            1. Segmentation Fault
    
        | Stopping Execution.
    [email protected] ~/src/libCello (git)-[master] % 
    

    unfortunately, I can't find a core-file, so I can't tell why it's failing

    opened by igalic 7
  • CMake Support + Unix EndLine

    CMake Support + Unix EndLine

    CMake Support

    I have written CMakeLists.txt files to:

    • build Cello library, tests and demos
    • install Cello library and associated headers
    • check platform
    • specify compilation depending on:
      • release mode (debug/release)
      • build platform (Clang/GCC/MSVC)

    I manage to build Cello with:

    • GNU Makefiles on Ubuntu
    • QtCreator on Ubuntu
    • KDevelop3 on Ubuntu
    • GNU Makefiles on OSX
    • XCode on OSX

    I added tests for MSVC compiler, but I don't manage to build library with this compiler. MSVC doesn't support C99 and doesn't understand most of the macros in Prelude.h I targeted to use Cello to develop application that should run onto (INtime Real Time OS) and TwinCAT that both use MSVC as compiler. But it doesn't seem to fit my needs as it seems hard to build the library with this compiler

    Headers location

    I move headers to include/Cello. This way they are organised as they will be installed => we don't need to install Cello on our system to test it and launch tests/demos.

    I update #include in all implementation files to this new location.

    Unix EndLine

    I don't make any change to the source code except that I change EndLine parameters to UNIX. I found both Windows and Unix EndLine usage in source code.

    Conclusions

    Hope CMake support will still help you

    Bertrand

    opened by bcachet 7
  • Unable to pass file create test

    Unable to pass file create test

    There is a problem with the test_file_create() on Ubuntu linux, compiled by gcc.

    *** glibc detected *** ./tests/test: double free or corruption (!prev): 0x0000000000e0feb0 ***

    Looks like problem is here - tests/data.c:1348 - delete(f2)

    opened by codefriend 6
  • Failed to compile on GCC 8.1.0

    Failed to compile on GCC 8.1.0

    Environment: gcc version 8.1.0 (x86_64-posix-sjlj-rev0, Built by MinGW-W64 project) Seems that the expanding method for macro has changed. Get a series of error, such as: D:/WorkSpace/C/cello_test/include/Cello.h:559:28: error: number of arguments doesn't match prototype #define tuple_in(_, ...) $(Tuple, (var[]){ __VA_ARGS__ })

    opened by Caikera 0
  • Moving objects between threads

    Moving objects between threads

    Suppose I have many (thousands to millions of) objects per thread, all managed by the GC on the heap, and several dozen threads. These objects are concurrent actors. A thread can run a single actor at a time.

    There is a theoretical problem where one thread may be starving some of its actors due to too many incoming messages, while another thread has no work to do, leading to poor multicore performance. In this situation, a possible technique is to evict actors from the busy thread to the idle thread.

    What's the best way to move a GC object from one thread to another? I am prepared to accept that it isn't possible and that I will have to copy the object in chunks by sending messages between threads.

    opened by MostAwesomeDude 1
  • Doesn't work with Emscripten

    Doesn't work with Emscripten

    I just try it out with Emscripten to use Cello on the Web. But unfortunately it doesn't work

    Here is my log:


    Shell_Common.js:513 atexit() called, but EXIT_RUNTIME is not set, so atexits() will not be called. set EXIT_RUNTIME to 1 (see the FAQ) printErr @ Shell_Common.js:513 Shell_Common.js:490 Shell_Common.js:490 +-------------------------------------------+ Shell_Common.js:490 | ptest MicroTesting Magic for C | Shell_Common.js:490 | | Shell_Common.js:490 | http://github.com/orangeduck/ptest | Shell_Common.js:490 | | Shell_Common.js:490 | Daniel Holden ([email protected]) | Shell_Common.js:490 +-------------------------------------------+ Shell_Common.js:513 Calling stub instead of signal() printErr @ Shell_Common.js:513 Shell_Common.js:513 Calling stub instead of signal() printErr @ Shell_Common.js:513 Shell_Common.js:513 Calling stub instead of signal() printErr @ Shell_Common.js:513 Shell_Common.js:490 Shell_Common.js:490 Shell_Common.js:490 ===== Suite Array ===== Shell_Common.js:490 Shell_Common.js:513 Invalid function pointer '1020' called with signature 'ii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this) printErr @ Shell_Common.js:513 Shell_Common.js:513 This pointer might make sense in another type signature: i: 0 iii: 0 iiii: 0 iiiii: undefined vii: 0 di: undefined vi: 0 viii: 0 v: 0 viiii: 0 viiiii: 0 viiiiii: 0
    printErr @ Shell_Common.js:513 Shell_Common.js:490 1020 Shell_Common.js:513 1020 printErr @ Shell_Common.js:513 Shell_Common.js:513 exception thrown: abort(1020) at Error at jsStackTrace (http://localhost:6931/App.js:1107:13) at stackTrace (http://localhost:6931/App.js:1124:12) at abort (http://localhost:6931/App.js:162179:44) at nullFunc_ii (http://localhost:6931/App.js:5750:876) at Array.b2184 (http://localhost:6931/App.js:133200:13) at Array._Array_Assign (http://localhost:6931/App.js:8487:38) at _assign (http://localhost:6931/App.js:8791:34) at _copy (http://localhost:6931/App.js:6589:9) at Array._test_array_new (http://localhost:6931/App.js:38249:9) at _pt_run (http://localhost:6931/App.js:37842:31) printErr @ Shell_Common.js:513 App.js:41 Uncaught abort(1020) at Error at jsStackTrace (http://localhost:6931/App.js:1107:13) at stackTrace (http://localhost:6931/App.js:1124:12) at abort (http://localhost:6931/App.js:162179:44) at nullFunc_ii (http://localhost:6931/App.js:5750:876) at Array.b2184 (http://localhost:6931/App.js:133200:13) at Array._Array_Assign (http://localhost:6931/App.js:8487:38) at _assign (http://localhost:6931/App.js:8791:34) at _copy (http://localhost:6931/App.js:6589:9) at Array._test_array_new (http://localhost:6931/App.js:38249:9) at _pt_run (http://localhost:6931/App.js:37842:31)


    See my fork to get this result: https://github.com/Cwc-Lib/Cello

    opened by Maeiky 2
  • Question about Array

    Question about Array

    Hello! I'm working on a std=gnu90 codebase with dynamic memory not allowed. I would like to use Cello's Array type to pass arrays into functions instead of pointers and to use bound checks. Can Array be statically allocated? And if so, what is the minimal subset of Cello's codebase I need to use it in my codebase?

    opened by okla 0
Releases(v2.0.3)
Owner
Daniel Holden
Animation & Machine Learning at Epic Games. Writer / Programmer.
Daniel Holden
This project contains the carefully compiled easy to medium level Data Structures & Algorithm questions.

Engineering-Daze Hey everyone! ?? This project contains the carefully compiled easy to medium level Data Structures & Algorithm questions. Engineering

DSC-Banasthali 8 Apr 30, 2022
A low-latency LRU approximation cache in C++ using CLOCK second-chance algorithm. Multi level cache too. Up to 2.5 billion lookups per second.

LruClockCache Low-latency LRU approximation cache in C++ using CLOCK second-chance algorithm. (see wiki for details) using MyKeyType = std::string; us

Hüseyin Tuğrul BÜYÜKIŞIK 33 Oct 13, 2022
Flexible level editor

Tiled Map Editor - https://www.mapeditor.org/ About Tiled Tiled is a general purpose tile map editor for all tile-based games, such as RPGs, platforme

mapeditor.org 9.2k Nov 29, 2022
Implementing dynamic lists in C

Dynamic-Lists Implementing dynamic lists in C <begginer level> DESCRIPTION: This header file <list.h> implements python-like lists and it's functions.

null 2 Feb 2, 2022
A fast hash map/hash table (whatever you want to call it) for the C programming language.

C HashMap A fast hash map/hash table (whatever you want to call it) for the C programming language. It can associate a key with a pointer or integer v

Mashpoe 71 Nov 23, 2022
This is a beginner-friendly project aiming to build a problem-set on different data structures and algorithms in different programming languages.

DSAready Overview This is a beginner-friendly project that aims to create a problem-set for various Data Structures and Algorithms. Being a programmer

Riddhi Jain 13 Aug 17, 2022
Templates, algorithms and data structures implemented and collected for programming contests.

Templates, algorithms and data structures implemented and collected for programming contests.

Shahjalal Shohag 2k Nov 18, 2022
This repository aims to contain solutions and explanations to various competitive programming problems, which may be important for interviews and online tests of different companies.

Competitive Programming Solutions Compilation Hello everyone ?? This repository contains solutions and explanations to various competitive programming

Abhinav Agrawal 34 Oct 9, 2022
Competitive Programming Solutions Compilation

Competitive Programming Solutions Compilation Hello everyone ?? This repository contains solutions and explanations to various competitive programming

Abhinav Agrawal 34 Oct 9, 2022
Collection of all the LeetCode problem solutions using different programming languages.

LeetCode Solutions Collection of all the LeetCode problem solutions using different programming languages. To contribute, you can make a file for the

Jay Patel 34 Sep 2, 2022
Competitive Programming Problem Set

Competitive Programming Problem Set Please press ⭐ button if you like this repo ❤ . Your supports will encourage me a lot and help me put more my time

Tan Huynh 2 Jan 27, 2022
An open source initiative for implementing and testing algorithms in various programming languages.

Algorithms An open source initiative for implementing and testing algorithms in various programming languages. Contributing The idea here is to learn

Manipal's open source academic portal. 1 Nov 28, 2021
FEMTIC is a 3-D magnetotelluric inversion code. FEMTIC is made by object-oriented programming with C++.

FEMTIC FEMTIC is a 3-D magnetotelluric inversion code based on the following studies. FEMTIC was made using object-oriented programming with C++. FEMT

Yoshiya Usui 18 Nov 25, 2022
Implementation of K-D tree in C++ programming language.

KD_Trees Implementation of K-D tree in C++ programming language Demonstration Image What's in this repository anyway? This is a C++(PL) implementation

Shreyash 4 Dec 17, 2021
A tree-sitter grammar for the Gleam programming language

tree-sitter-gleam A tree-sitter grammar for the Gleam programming language This is, presently, very much a work-in-progress. DONE Parsing import state

Jonathan Arnett 0 Mar 30, 2022
This is my record of practicing programming skills on LeetCode since 2021.

My_LeetCode_Road This is my record of practicing programming skills on LeetCode since 2021. No. Chinese Title Englist Title Acceptance Difficulty 1 两数

Nebulae 3 Oct 5, 2022
Problem solution of Quera's Problems with different programming language and approach.

Quera-Problem-Solution Problem solution of Quera's Problems with different programming language and approach. How to use Each folder is the category o

Mohammad YousefiPour 6 Oct 10, 2022
This repository contains some data structures implementation in C programming language

This repository contains some data structures implementation in C programming language. I wrote the tutorial posts about these data structures on my personal blog site in Bengali language. If you know Bengali then visit my site

Hasan Abdullah 129 Nov 18, 2022
A collection of hash tables for parallel programming, including lock-free, wait-free tables.

Hatrack Hash tables for parallel programming This project consisists of fast hash tables suitable for parallel programming, including multiple lock-fr

null 60 Nov 18, 2022