Struct Dict

pub struct Dict(/* private fields */);

A map from string keys to values.

You can construct a dictionary by enclosing comma-separated key: value pairs in parentheses. The values do not have to be of the same type. Since empty parentheses already yield an empty array, you have to use the special (:) syntax to create an empty dictionary.

A dictionary is conceptually similar to an array, but it is indexed by strings instead of integers. You can access and create dictionary entries with the .at() method. If you know the key statically, you can alternatively use field access notation (.key) to access the value. Dictionaries can be added with the + operator and joined together. To check whether a key is present in the dictionary, use the in keyword.

You can iterate over the pairs in a dictionary using a for loop. This will iterate in the order the pairs were inserted / declared.

Example

#let dict = (
  name: "Typst",
  born: 2019,
)

#dict.name \
#(dict.launch = 20)
#dict.len() \
#dict.keys() \
#dict.values() \
#dict.at("born") \
#dict.insert("city", "Berlin ")
#("name" in dict)

Implementations

impl Dict

pub fn new() -> Dict

Create a new, empty dictionary.

pub fn is_empty(&self) -> bool

Whether the dictionary is empty.

pub fn get(&self, key: &str) -> Result<&Value, EcoString>

Borrow the value at the given key.

pub fn at_mut(&mut self, key: &str) -> Result<&mut Value, HintedString>

Mutably borrow the value the given key maps to.

pub fn take(&mut self, key: &str) -> Result<Value, EcoString>

Remove the value if the dictionary contains the given key.

pub fn contains(&self, key: &str) -> bool

Whether the dictionary contains a specific key.

pub fn clear(&mut self)

Clear the dictionary.

pub fn iter(&self) -> Iter<'_, Str, Value>

Iterate over pairs of references to the contained keys and values.

pub fn finish(&self, expected: &[&str]) -> Result<(), EcoString>

Check if there is any remaining pair, and if so return an “unexpected key” error.

pub fn unexpected_keys( unexpected: Vec<&str>, hint_expected: Option<&[&str]>, ) -> EcoString

impl Dict

pub fn construct(value: ToDict) -> Dict

Converts a value into a dictionary.

Note that this function is only intended for conversion of a dictionary-like value to a dictionary, not for creation of a dictionary from individual pairs. Use the dictionary syntax (key: value) instead.

#dictionary(sys).at("version")

pub fn len(&self) -> usize

The number of pairs in the dictionary.

pub fn at(&self, key: Str, default: Option<Value>) -> Result<Value, EcoString>

Returns the value associated with the specified key in the dictionary. May be used on the left-hand side of an assignment if the key is already present in the dictionary. Returns the default value if the key is not part of the dictionary or fails with an error if no default value was specified.

pub fn insert(&mut self, key: Str, value: Value)

Inserts a new pair into the dictionary. If the dictionary already contains this key, the value is updated.

pub fn remove( &mut self, key: Str, default: Option<Value>, ) -> Result<Value, EcoString>

Removes a pair from the dictionary by key and return the value.

pub fn keys(&self) -> Array

Returns the keys of the dictionary as an array in insertion order.

pub fn values(&self) -> Array

Returns the values of the dictionary as an array in insertion order.

pub fn pairs(&self) -> Array

Returns the keys and values of the dictionary as an array of pairs. Each pair is represented as an array of length two.

Trait Implementations

impl Add for Dict

type Output = Dict

The resulting type after applying the + operator.

fn add(self, rhs: Dict) -> <Dict as Add>::Output

Performs the + operation.

impl AddAssign for Dict

fn add_assign(&mut self, rhs: Dict)

Performs the += operation.

impl Clone for Dict

fn clone(&self) -> Dict

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Dict

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Dict

fn default() -> Dict

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Dict

fn deserialize<D>( deserializer: D, ) -> Result<Dict, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Extend<(Str, Value)> for Dict

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = (Str, Value)>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl From<FirstLineIndent> for Dict

fn from(indent: FirstLineIndent) -> Dict

Converts to this type from the input type.

impl From<IndexMap<Str, Value>> for Dict

fn from(map: IndexMap<Str, Value>) -> Dict

Converts to this type from the input type.

impl From<PixelFormat> for Dict

fn from(format: PixelFormat) -> Dict

Converts to this type from the input type.

impl From<Position> for Dict

fn from(pos: Position) -> Dict

Converts to this type from the input type.

impl FromIterator<(Str, Value)> for Dict

fn from_iter<T>(iter: T) -> Dict

where T: IntoIterator<Item = (Str, Value)>,

Creates a value from an iterator.

impl FromValue for Dict

fn from_value(value: Value) -> Result<Dict, HintedString>

Try to cast the value into an instance of Self.

impl Hash for Dict

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> IntoIterator for &'a Dict

type Item = (&'a Str, &'a Value)

The type of the elements being iterated over.

type IntoIter = Iter<'a, Str, Value>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Dict as IntoIterator>::IntoIter

Creates an iterator from a value.

impl IntoIterator for Dict

type Item = (Str, Value)

The type of the elements being iterated over.

type IntoIter = IntoIter<Str, Value>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Dict as IntoIterator>::IntoIter

Creates an iterator from a value.

impl IntoValue for Dict

fn into_value(self) -> Value

Cast this type into a value.

impl NativeScope for Dict

fn constructor() -> Option<&'static NativeFuncData>

The constructor function for the type, if any.

fn scope() -> Scope

Get the associated scope for the type.

impl NativeType for Dict

const NAME: &'static str = "dictionary"

The type’s name.

fn data() -> &'static NativeTypeData

fn ty() -> Type

Get the type for the native Rust type.

impl PartialEq for Dict

fn eq(&self, other: &Dict) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Reflect for Dict

fn input() -> CastInfo

Describe what can be cast into this value.

fn output() -> CastInfo

Describe what this value can be cast into.

fn castable(value: &Value) -> bool

Whether the given value can be converted to T.

fn error(found: &Value) -> HintedString

Produce an error message for an unacceptable value type.

impl Repr for Dict

fn repr(&self) -> EcoString

Return the debug representation of the value.

impl Serialize for Dict

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Dict