string_utils - [mainnet]

A module for formatting move values as strings.

use 0x1::string;

Constants

The number of values in the list does not match the number of ”{}” in the format string.

const EARGS_MISMATCH: u64 = 1;

The format string is not valid.

const EINVALID_FORMAT: u64 = 2;

Formatting is not possible because the value contains delayed fields such as aggregators.

const EUNABLE_TO_FORMAT_DELAYED_FIELD: u64 = 3;

Structs

`Cons`

struct Cons<T, N> has copy, drop, store

Fields

car: T
cdr: N

`NIL`

struct NIL has copy, drop, store

Fields

dummy_field: bool

`FakeCons`

[test_only]

struct FakeCons<T, N> has copy, drop, store

Fields

car: T
cdr: N

Functions

`to_string`

Format a move value as a human readable string, eg. to_string(&1u64) == “1”, to_string(&false) == “false”, to_string(&@0x1) == “@0x1”. For vectors and structs the format is similar to rust, eg. to_string(&cons(1,2)) == “Cons { car: 1, cdr: 2 }” and to_string(&vector[1, 2, 3]) == ”[ 1, 2, 3 ]” For vectors of u8 the output is hex encoded, eg. to_string(&vector[1u8, 2u8, 3u8]) == “0x010203” For std::string::String the output is the string itself including quotes, eg. to_string(&std::string::utf8(b”My string”)) == ""My string""

public fun to_string<T>(s: &T): string::String

Implementation

public fun to_string<T>(s: &T): String {
    native_format(s, false, false, true, false)
}

`to_string_with_canonical_addresses`

Format addresses as 64 zero-padded hexadecimals.

public fun to_string_with_canonical_addresses<T>(s: &T): string::String

Implementation

public fun to_string_with_canonical_addresses<T>(s: &T): String {
    native_format(s, false, true, true, false)
}

`to_string_with_integer_types`

Format emitting integers with types ie. 6u8 or 128u32.

public fun to_string_with_integer_types<T>(s: &T): string::String

Implementation

public fun to_string_with_integer_types<T>(s: &T): String {
    native_format(s, false, true, true, false)
}

`debug_string`

Format vectors and structs with newlines and indentation.

public fun debug_string<T>(s: &T): string::String

Implementation

public fun debug_string<T>(s: &T): String {
    native_format(s, true, false, false, false)
}

`format1`

Formatting with a rust-like format string, eg. format2(&b”a = {}, b = {}”, 1, 2) == “a = 1, b = 2”.

public fun format1<T0: drop>(fmt: &vector<u8>, a: T0): string::String

Implementation

public fun format1<T0: drop>(fmt: &vector<u8>, a: T0): String {
    native_format_list(fmt, &list1(a))
}

`format2`

public fun format2<T0: drop, T1: drop>(fmt: &vector<u8>, a: T0, b: T1): string::String

Implementation

public fun format2<T0: drop, T1: drop>(fmt: &vector<u8>, a: T0, b: T1): String {
    native_format_list(fmt, &list2(a, b))
}

`format3`

public fun format3<T0: drop, T1: drop, T2: drop>(fmt: &vector<u8>, a: T0, b: T1, c: T2): string::String

Implementation

public fun format3<T0: drop, T1: drop, T2: drop>(fmt: &vector<u8>, a: T0, b: T1, c: T2): String {
    native_format_list(fmt, &list3(a, b, c))
}

`format4`

public fun format4<T0: drop, T1: drop, T2: drop, T3: drop>(fmt: &vector<u8>, a: T0, b: T1, c: T2, d: T3): string::String

Implementation

public fun format4<T0: drop, T1: drop, T2: drop, T3: drop>(fmt: &vector<u8>, a: T0, b: T1, c: T2, d: T3): String {
    native_format_list(fmt, &list4(a, b, c, d))
}

`cons`

fun cons<T, N>(car: T, cdr: N): string_utils::Cons<T, N>

Implementation

fun cons<T, N>(car: T, cdr: N): Cons<T, N> { Cons { car, cdr } }

`nil`

fun nil(): string_utils::NIL

Implementation

fun nil(): NIL { NIL {} }

`list1`

fun list1<T0>(a: T0): string_utils::Cons<T0, string_utils::NIL>

Implementation

inline fun list1<T0>(a: T0): Cons<T0, NIL> { cons(a, nil()) }

`list2`

fun list2<T0, T1>(a: T0, b: T1): string_utils::Cons<T0, string_utils::Cons<T1, string_utils::NIL>>

Implementation

inline fun list2<T0, T1>(a: T0, b: T1): Cons<T0, Cons<T1, NIL>> { cons(a, list1(b)) }

`list3`

fun list3<T0, T1, T2>(a: T0, b: T1, c: T2): string_utils::Cons<T0, string_utils::Cons<T1, string_utils::Cons<T2, string_utils::NIL>>>

Implementation

inline fun list3<T0, T1, T2>(a: T0, b: T1, c: T2): Cons<T0, Cons<T1, Cons<T2, NIL>>> { cons(a, list2(b, c)) }

`list4`

fun list4<T0, T1, T2, T3>(a: T0, b: T1, c: T2, d: T3): string_utils::Cons<T0, string_utils::Cons<T1, string_utils::Cons<T2, string_utils::Cons<T3, string_utils::NIL>>>>

Implementation

inline fun list4<T0, T1, T2, T3>(a: T0, b: T1, c: T2, d: T3): Cons<T0, Cons<T1, Cons<T2, Cons<T3, NIL>>>> { cons(a, list3(b, c, d)) }

`native_format`

fun native_format<T>(s: &T, type_tag: bool, canonicalize: bool, single_line: bool, include_int_types: bool): string::String

Implementation

native fun native_format<T>(s: &T, type_tag: bool, canonicalize: bool, single_line: bool, include_int_types: bool): String;

`native_format_list`

fun native_format_list<T>(fmt: &vector<u8>, val: &T): string::String

Implementation

native fun native_format_list<T>(fmt: &vector<u8>, val: &T): String;

Specification

`to_string`

public fun to_string<T>(s: &T): string::String

aborts_if false;
ensures result == spec_native_format(s, false, false, true, false);

`to_string_with_canonical_addresses`

public fun to_string_with_canonical_addresses<T>(s: &T): string::String

aborts_if false;
ensures result == spec_native_format(s, false, true, true, false);

`to_string_with_integer_types`

public fun to_string_with_integer_types<T>(s: &T): string::String

aborts_if false;
ensures result == spec_native_format(s, false, true, true, false);

`debug_string`

public fun debug_string<T>(s: &T): string::String

aborts_if false;
ensures result == spec_native_format(s, true, false, false, false);

`format1`

public fun format1<T0: drop>(fmt: &vector<u8>, a: T0): string::String

aborts_if args_mismatch_or_invalid_format(fmt, list1(a));
ensures result == spec_native_format_list(fmt, list1(a));

`format2`

public fun format2<T0: drop, T1: drop>(fmt: &vector<u8>, a: T0, b: T1): string::String

aborts_if args_mismatch_or_invalid_format(fmt, list2(a, b));
ensures result == spec_native_format_list(fmt, list2(a, b));

`format3`

public fun format3<T0: drop, T1: drop, T2: drop>(fmt: &vector<u8>, a: T0, b: T1, c: T2): string::String

aborts_if args_mismatch_or_invalid_format(fmt, list3(a, b, c));
ensures result == spec_native_format_list(fmt, list3(a, b, c));

`format4`

public fun format4<T0: drop, T1: drop, T2: drop, T3: drop>(fmt: &vector<u8>, a: T0, b: T1, c: T2, d: T3): string::String

aborts_if args_mismatch_or_invalid_format(fmt, list4(a, b, c, d));
ensures result == spec_native_format_list(fmt, list4(a, b, c, d));

`native_format`

fun native_format<T>(s: &T, type_tag: bool, canonicalize: bool, single_line: bool, include_int_types: bool): string::String

pragma opaque;
aborts_if false;
ensures result == spec_native_format(s, type_tag, canonicalize, single_line, include_int_types);

`native_format_list`

fun native_format_list<T>(fmt: &vector<u8>, val: &T): string::String

pragma opaque;
aborts_if args_mismatch_or_invalid_format(fmt, val);
ensures result == spec_native_format_list(fmt, val);

fun spec_native_format<T>(s: T, type_tag: bool, canonicalize: bool, single_line: bool, include_int_types: bool): String;

fun spec_native_format_list<T>(fmt: vector<u8>, val: T): String;

fun args_mismatch_or_invalid_format<T>(fmt: vector<u8>, val: T): bool;