Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Module 0x1::string_utils

A module for formatting move values as strings.

use 0x1::string;

Struct Cons 

struct Cons<T, N> has copy, drop, store
Fields
car: T
cdr: N

Struct NIL 

struct NIL has copy, drop, store
Fields
dummy_field: bool

Struct FakeCons

[test_only] 

struct FakeCons<T, N> has copy, drop, store
Fields
car: T
cdr: N

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;

Function 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)
}

Function 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)
}

Function 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)
}

Function 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)
}

Function 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))
}

Function 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))
}

Function 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))
}

Function 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))
}

Function 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 } }

Function nil 

fun nil(): string_utils::NIL
Implementation 
fun nil(): NIL { NIL {} }

Function 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()) }

Function 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)) }

Function 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)) }

Function 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)) }

Function 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;

Function 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

Function to_string 

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

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

Function 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);

Function 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);

Function debug_string 

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

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

Function 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));

Function 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));

Function 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));

Function 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));

Function 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);

Function 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;