Conditional compilation using boolean expression syntax, rather than any(), all(), not()

Last update: Dec 28, 2022

Related tags

Overview

Conditional compilation expressions

Conditional compilation using boolean expression syntax, rather than any(), all(), not().

[dependencies]
efg = "0.1"

Summary

Rust's cfg and cfg_attr conditional compilation attributes use a restrictive domain-specific language for specifying configuration predicates. The syntax is described in the Conditional compilation page of the Rust reference. The reason for this syntax as opposed to ordinary boolean expressions was to accommodate restrictions that old versions of rustc used to have on the grammar of attributes.

However, all restrictions on the attribute grammar were lifted in Rust 1.18.0 by rust-lang/rust#40346. This crate explores implementing conditional compilation using ordinary boolean expressions instead: &&, ||, ! as usual in Rust syntax.

built into rustc	this crate
`#[cfg(any(thing1, thing2, …))]`	`#[efg(thing1 \|\| thing2 \|\| …)]`
`#[cfg(all(thing1, thing2, …))]`	`#[efg(thing1 && thing2 && …)]`
`#[cfg(not(thing))]`	`#[efg(!thing)]`

Examples

A real-world example from the quote crate:

#[efg(feature = "proc-macro" && !(target_arch = "wasm32" && target_os = "unknown"))]
extern crate proc_macro;

and from the proc-macro2 crate:

#[efg(super_unstable || feature = "span-locations")]
pub fn start(&self) -> LineColumn {

License

^{Licensed under either of Apache License, Version 2.0 or MIT license at your option.}
_{Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.}

Pure Rust port of CRFsuite: a fast implementation of Conditional Random Fields (CRFs)

crfs-rs Pure Rust port of CRFsuite: a fast implementation of Conditional Random Fields (CRFs) Currently only support prediction, model training is not

24 Nov 23, 2022

Eternally liquid. Forward compatible. Nested, conditional, & Multi-resourced NFTs.

RMRK Substrate Rust Setup First, complete the basic Rust setup instructions. Run Use Rust's native cargo command to build and launch the template node

67 Dec 25, 2022

Rust regex in ECMAScript regular expression syntax!

ecma_regex The goal of ecma_regex is to provide the same functionality as the regex crate in ECMAScript regular expression syntax. Reliable regex engi

6 Mar 7, 2023

Bitpack a boolean into a pointer using bit magic.

ptr-bool tl;dr: a pointer and boolean with the same size as a pointer. A convenience crate used to bitpack a boolean and pointer into the same eight b

2 Oct 24, 2022

An expression based data notation, aimed at transpiling itself to any cascaded data notation.

Lala An expression oriented data notation, aimed at transpiling itself to any cascaded data notation. Lala is separated into three components: Nana, L

37 Mar 9, 2022

A working example of multi targets compilation for Rust using Github Actions.

A working example of multi targets compilation for Rust using Github Actions. Supports Windows, MacOSX, x86_64, ARM and Raspberry PI Linux.

41 Dec 17, 2022

Compiler & Interpreter for the (rather new and very experimental) Y programming language.

Y Lang Why would anyone build a new (and rather experimental) language with no real world use case. Design Y (pronounced as why) is based on the idea

8 Mar 5, 2023

Choose Rust types at compile-time via boolean constants

condtype Choose Rust types at compile-time via boolean constants, brought to you by Nikolai Vazquez. If you find this library useful, consider starrin

36 May 8, 2023

Supporting code for the paper "Optimized Homomorphic Evaluation of Boolean Functions" submitted to Eurocrypt 2024

This repository contains the code related to the paper Optimized Homomorphic Evaluation of Boolean Functions. The folder search_algorithm contains the

3 Oct 23, 2023

Single-side boolean deserializers.

serde-bool Single value, true or false, boolean deserializers. Examples Supporting serde untagged enums where only one boolean value is valid, allowin

5 Dec 3, 2023

A language that ports⚓: examining the limits of compilation⚙️.

⚓ harbor ⚓ A language that ports: examining the limits of compilation. Demo | Crates | Contact Me Written in Rust 🦀 💖 NOTE: Click the images above f

80 Dec 20, 2022

Create target folder as a RAMdisk for faster Rust compilation.

cargo-ramdisk This crate is only supported for unix like systems! cargo-ramdisk creates a ramdisk at the target folder of your project for ridiculousl

20 Jan 8, 2023

auto-rust is an experimental project that aims to automatically generate Rust code with LLM (Large Language Models) during compilation, utilizing procedural macros.

Auto Rust auto-rust is an experimental project that aims to automatically generate Rust code with LLM (Large Language Models) during compilation, util

6 May 14, 2023

Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase

utoipa_auto_discovery Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase Crate

4 Jun 9, 2023

Just in time Oxidation. A little experimentation with inkwell and copy-and-patch compilation

Experimental Copy-and-Patch compiler backend written in Rust This is supposed to become an experimental compiler backend based on Copy and Patch to be

4 Feb 27, 2024

Simple library to host lv2 plugins. Is not meant to support any kind of GUI.

lv2-host-minimal Simple library to host lv2 plugins. Is not meant to support any kind of GUI. Host fx plugins (audio in, audio out) Set parameters Hos

11 Aug 31, 2022

A lightweight microkernel/IPC based operating system built with Rust which is not a clone of any existing operating system

Noble Operating System Noble is a lightweight microkernel and IPC based operating system built with Rust which is not a clone of any existing operatin

3 Jan 10, 2022

ISG lets you use YouTube as cloud storage for ANY files, not just video

I was working on this instead of my finals, hope you appreciate it. I'll add all relevant executables when I can Infinite-Storage-Glitch AKA ISG (writ

3.6k Feb 23, 2023

A special rope, designed to work with any data type that is not String

AnyRope AnyRope is an arbitrary data type rope for Rust, designed for similar operations that a rope would do, but targeted at data types that are not

27 Mar 22, 2023

Comments

Suggestion: change `=` operator to `==` and add `!=` in 0.2

First of all, I think this crate is a great idea! It always irked me how verbose the syntax for cfg was compared to regular Rust.

Suggestion: if we're going for syntax simplification, I'd love to also simplify frequent not(feature = "somefeature") not only to !(feature = "somefeature") but all the way to feature != "somefeature".

It feels a lot more natural to use != operator, but I suspect it will also require changing = to more Rust-like ==. It would be a breaking change, but perhaps a good thing for consistency with the rest of Rust syntax.

opened by RReverser 5
specifying ranges
https://github.com/rust-lang/rfcs/pull/3036 describes a family of predicates to target minimum versions of platform APIs. For example min_libc_version would return the version of libc. It was expected that max_* variants would be specified eventually as well [^max], allowing ranges of OS versions to be targeted.

Unfortunately the RFC hasn't seen any updates in a while, but the challenges it attempts to address still exist. I'm wondering whether efg could help prototype syntax to specify ranges within attributes. It'd be neat if we could target a specific version range Windows by writing something like this:

#[cfg(windows && os_version >= "6.0.6000" && os_version < "7.3.5000")]

Or possibly taking it further and allowing shorthands such as:

#[cfg(windows && "6.0.6000" <= os_version < "7.3.5000")]

I'm not sure what this feature should look like, but I think having the ability to specify ranges using shorthands would be neat as well. What do you think?

[^max]: Being able to specify the maximum OS version is useful when you're writing polyfills for older versions. This would allow a developers to say something like: "This code runs on windows 10+ only", which can be leveraged to produce more optimized code.
opened by yoshuawuyts 2

Releases(0.1.3)

0.1.3(Dec 18, 2022)
Documentation improvements

Source code(tar.gz)
Source code(zip)
0.1.2(Dec 18, 2022)
Improve error messages when an attribute is written with invalid syntax

Support checking feature values just by juxtaposition, for example target_arch "wasm32" && target_os "unknown" equivalent to target_arch = "wasm32" && target_os = "unknown" (#2)

Source code(tar.gz)
Source code(zip)
0.1.1(Dec 6, 2021)

Source code(tar.gz)
Source code(zip)
0.1.0(Dec 6, 2021)

Source code(tar.gz)
Source code(zip)

Conditional compilation using boolean expression syntax, rather than any(), all(), not()

Related tags

Overview

Conditional compilation expressions

Summary

Examples

License

You might also like...

Pure Rust port of CRFsuite: a fast implementation of Conditional Random Fields (CRFs)

Eternally liquid. Forward compatible. Nested, conditional, & Multi-resourced NFTs.

Rust regex in ECMAScript regular expression syntax!

Bitpack a boolean into a pointer using bit magic.

An expression based data notation, aimed at transpiling itself to any cascaded data notation.

A working example of multi targets compilation for Rust using Github Actions.

Compiler & Interpreter for the (rather new and very experimental) Y programming language.

Choose Rust types at compile-time via boolean constants

Supporting code for the paper "Optimized Homomorphic Evaluation of Boolean Functions" submitted to Eurocrypt 2024

Single-side boolean deserializers.

A language that ports⚓: examining the limits of compilation⚙️.

Create target folder as a RAMdisk for faster Rust compilation.

auto-rust is an experimental project that aims to automatically generate Rust code with LLM (Large Language Models) during compilation, utilizing procedural macros.

Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase

Just in time Oxidation. A little experimentation with inkwell and copy-and-patch compilation

Simple library to host lv2 plugins. Is not meant to support any kind of GUI.

A lightweight microkernel/IPC based operating system built with Rust which is not a clone of any existing operating system

ISG lets you use YouTube as cloud storage for ANY files, not just video

A special rope, designed to work with any data type that is not String

Comments

Suggestion: change `=` operator to `==` and add `!=` in 0.2

specifying ranges

Releases(0.1.3)

0.1.3(Dec 18, 2022)

0.1.2(Dec 18, 2022)

0.1.1(Dec 6, 2021)

0.1.0(Dec 6, 2021)

Owner

David Tolnay

Algorithms and Data Structures of all kinds written in Rust.

All Algorithms implemented in Rust

enum-map enum-map xfix/enum-map [enum-map] — An optimized map implementation for enums using an array to store values.

Library containing various Data Structures implemented using Rust.

Coding-challenge - Algorithms and Data-structures, problems and solutions in Rust language using cargo-workspaces

Starlight is a JS engine in Rust which focuses on performance rather than ensuring 100% safety of JS runtime.

GGML bindings that aim to be idiomatic Rust rather than directly corresponding to the C/C++ interface

🧮 Boolean expression evaluation engine. A Rust port of boolrule.

Explain semver requirements by converting them into less than, greater than, and/or equal to form.

Simple expression transformer that is not Coq.