Rust macro that uses GPT3 codex to generate code at compiletime

Related tags

Overview

gpt3_macro

Rust macro that uses GPT3 codex to generate code at compiletime.

Just describe what you want the function to do and (optionally) define a function header. The macro will generate the sourcecode for you at compiletime.

Example 1

create_function!("checks if number is prime" fn is_prime(num: u64) -> bool);

will (usually) expand to something like:

// A rust function that checks if number is prime
fn is_prime(num: u64) -> bool {
    if num == 2 {
        return true;
    }
    if num % 2 == 0 {
        return false;
    }
    let mut i = 3;
    while i * i <= num {
        if num % i == 0 {
            return false;
        }
        i += 2;
    }
    true
}

Example 2

create_function!("prints n elements of the fibonnacci sequence to stdout" fn fib(n: u64));

sometimes expands to:

// prints n elements of the fibonnacci sequence to stdout
fn fib (n : u64) {
    let mut a = 0;
    let mut b = 1;
    let mut c = 0;
    for _ in 0..n {
        c = a + b;
        a = b;
        b = c;
        println!("{}", c);
    }
}

Pros and Cons

Pros	Cons
Spend less time coding simple utility functions and save your brainpower for the big problems	Compilation takes way longer
Create more readable sourcecode — the documentation IS the sourcode.	You need to be part of the GPT3 Codex private beta
A little nondeterminism during compilation is fun!	GPT3 Codex will not always be free :(

Installation

Generate an OpenAI API key at the OpenAI Account Page and set the $OPENAI_KEY environment variable

Then execute

cargo add gpt3_macro

or manually add

gpt3_macro = "0.2.2"

to your Cargo.toml

hado-rshado — A little macro for writing haskell-like do expressions without too much ceremony

hado Monadic haskell-like expressions brought to rust via the hado! macro What? A little macro for writing haskell-like do expressions without too muc

44 Jul 31, 2022

Yet another geter/setter derive macro.

Gusket Gusket is a getter/setter derive macro. Comparison with getset: gusket only exposes one derive macro. No need to derive(Getters, MutGetters, Se

2 Apr 12, 2022

A proc-macro to get Vecu8 from struct and vise versa

byteme A proc-macro to convert a struct into Vec and back by implemeting From trait on the struct. The conversion is Big Endian by default. We have ma

11 Nov 4, 2022

Derive macro for encoding/decoding instructions and operands as bytecode

bytecoding Derive macro for encoding and decoding instructions and operands as bytecode. Documentation License Licensed under either of Apache License

15 Mar 20, 2022

Derive macro implementing 'From' for structs

derive-from-ext A derive macro that auto implements 'std::convert::From' for structs. The default behaviour is to create an instance of the structure

4 Sep 18, 2022

A proc macro for creating compile-time checked CSS class sets, in the style of classNames

semester Semester is a declarative CSS conditional class name joiner, in the style of React's classnames. It's intended for use in web frameworks (lik

11 Oct 20, 2022

A set of bison skeleton files that can be used to generate a Bison grammar that is written in Rust.

rust-bison-skeleton A set of bison skeleton files that can be used to generate a Bison grammar that is written in Rust. Technically it's more like a B

12 Dec 14, 2022

Generate Rust register maps (`struct`s) from SVD files

svd2rust Generate Rust register maps (structs) from SVD files This project is developed and maintained by the Tools team. Documentation API Minimum Su

518 Dec 30, 2022

📝 Generate your README.md from Rust doc comments

cargo-onedoc 📝 Generate README.md from doc comments. Only write your documentation once! This crate provides a Cargo subcommand that can generate Mar

2 Dec 14, 2022

Comments

Cache generated code to reduce API usage

Currently, on incremental builds, an Api request would be made. Having some sort of local cache would help prevent running into any API limits usage for the stated case. Something like cacache alongside the description (and maybe an optional source path) as the cache key could serve some good :)

And then maybe exposing an optional feature flag to invalidate/not utilize the cache during build wouldn't be bad also.

opened by tnkemdilim 0