TOML

    To parse a file, use . If the file has a syntax error, an exception is thrown:

    3. julia> TOML.parse("""
    4.            value = 0.0.0
    5.        """)
    6. ERROR: TOML Parser error:
    7. none:1:16 error: failed to parse value
    8.       value = 0.0.0
    9.                  ^
    10. [...]

    There are other versions of the parse functions (TOML.tryparse and [TOML.tryparsefile]) that instead of throwing exceptions on parser error returns a with information:

    1. julia> using TOML
    3. julia> err = TOML.tryparse("""
    4.            value = 0.0.0
    5.        """);
    7. julia> err.type
    8. ErrGenericValueError::ErrorType = 14
    10. julia> err.line
    12. julia> err.column
    13. 16

    The TOML.print function is used to print (or serialize) data into TOML format.

    1. julia> using TOML
    3. julia> data = Dict(
    4.           "names" => ["Julia", "Julio"],
    5.           "age" => [10, 20],
    8. julia> TOML.print(data)
    9. names = ["Julia", "Julio"]
    10. age = [10, 20]
    12. julia> fname = tempname();
    14. julia> open(fname, "w") do io
    15.            TOML.print(io, data)
    16.        end
    18. julia> TOML.parsefile(fname)
    19. Dict{String, Any} with 2 entries:
    20.   "names" => ["Julia", "Julio"]

    Keys can be sorted according to some value

    For custom structs, pass a function that converts the struct to a supported type

    1. julia> using TOML
    3. julia> struct MyStruct
    4.            a::Int
    5.            b::String
    6.        end
    8. julia> TOML.print(Dict("foo" => MyStruct(5, "bar"))) do x
    9.            x isa MyStruct && return [x.a, x.b]
    10.            error("unhandled type $(typeof(x))")
    11.        end
    12. foo = [5, "bar"]

    — Function

    1. parse(x::Union{AbstractString, IO})
    2. parse(p::Parser, x::Union{AbstractString, IO})

    Parse the string or stream , and return the resulting table (dictionary). Throw a ParserError upon failure.

    — Function

    1. parsefile(f::AbstractString)
    2. parsefile(p::Parser, f::AbstractString)

    Parse file f and return the resulting table (dictionary). Throw a ParserError upon failure.

    See also .

    TOML.tryparse — Function

    Parse the string or stream x, and return the resulting table (dictionary). Return a upon failure.

    See also TOML.parse.

    — Function

    1. tryparsefile(f::AbstractString)
    2. tryparsefile(p::Parser, f::AbstractString)

    See also TOML.parsefile.

    — Function

    1. print([to_toml::Function], io::IO [=stdout], data::AbstractDict; sorted=false, by=identity)

    Write data as TOML syntax to the stream io. If the keyword argument sorted is set to true, sort tables according to the function given by the keyword argument by.

    The following data types are supported: AbstractDict, Integer, AbstractFloat, Bool, Dates.DateTime, Dates.Time, Dates.Date. Note that the integers and floats need to be convertible to Float64 and Int64 respectively. For other data types, pass the function to_toml that takes the data types and returns a value of a supported type.

    TOML.Parser — Type

    1. Parser()

    Constructor for a TOML Parser. Note that in most cases one does not need to explicitly create a Parser but instead one directly use use or TOML.parse. Using an explicit parser will however reuse some internal data structures which can be beneficial for performance if a larger number of small files are parsed.

    — Type

    • pos, the position in the string when the error happened
    • table, the result that so far was successfully parsed
    • type, an error type, different for different types of errors