#primitives #u128 #i128

extprim_literals

Plugin for creating extra primitive types literals (u128!(n), i128!(n))

10 releases (stable)

Uses old Rust 2015

2.0.3 Jul 11, 2017
2.0.2 Jun 16, 2017
2.0.0 Mar 18, 2017
1.2.0 Jan 12, 2017
0.2.2 Jan 10, 2015

#1056 in Rust patterns

Download history 98/week @ 2023-10-23 91/week @ 2023-10-30 99/week @ 2023-11-06 92/week @ 2023-11-13 107/week @ 2023-11-20 144/week @ 2023-11-27 224/week @ 2023-12-04 100/week @ 2023-12-11 106/week @ 2023-12-18 130/week @ 2023-12-25 89/week @ 2024-01-01 96/week @ 2024-01-08 96/week @ 2024-01-15 104/week @ 2024-01-22 125/week @ 2024-01-29 85/week @ 2024-02-05

426 downloads per month
Used in 2 crates

MIT/Apache

195KB
3.5K SLoC

extprim

Travis (Linux and OS X) Build status AppVeyor (Windows) Build status Coverage Status crates.io MIT / Apache 2.0

Thanks to RFC 1504 “int128”, you can use i128 and u128 directly on nightly Rust starting from 1.16. Using the built-in types are preferred.

Extra primitive types for stable Rust. Currently includes:

  • u128 (unsigned 128-bit integers)
  • i128 (signed 128-bit integers)

Documentation

You may also find other primitive types in other crates:

Usage

# Cargo.toml
[dependencies]
extprim = "1"

If you want to use the u128!() and i128!() macros, please include the extprim_literals plugin.

# Cargo.toml
[dependencies]
extprim = "1"
extprim_literals = "2"

Example

#[macro_use]
extern crate extprim_literals;
extern crate extprim;

use std::str::FromStr;
use extprim::i128::i128;

fn main() {
    let a = i128::from_str("100000000000000000000000000000000000000").unwrap();
            // convert string to u128 or i128
    let b = i128::new(10).pow(38);
            // 64-bit integers can be directly new'ed
    assert_eq!(a, b);

    let c = i128::from_parts(5421010862427522170, 687399551400673280);
            // represent using the higher- and lower-64-bit parts
    let d = c - a;
            // standard operators like +, -, *, /, %, etc. work as expected.
    assert_eq!(d, i128::zero());

    const e: i128 = i128!(100000000000000000000000000000000000000);
            // use the literal macros
    assert_eq!(a, e);
}

lib.rs:

Literal macros for extprim.

This crate provides a syntex extension (on stable) so that the extprim types can be constructed at compile-time using the i128!() and u128!() macros.

Setup

Simply add extprim_literals to dependencies in Cargo.toml:

[dependencies]
extprim_literals = "2.0"

Use the macros in src/consts.rs:

#[macro_use] extern crate extprim_literals;
extern crate extprim;
use extprim::u128::u128;

const TEN: u128 = u128!(10);

Dependencies

~1–2MB
~37K SLoC