Matching brackets in Rust
the introduction of enum Bracket is good and idiomatic. However, this is not the only useful form, there are at least 2 other forms that would work just fine.
brackets_are_balanced can be simplified when we notice that all Brackets in Vec&lt;Bracket&gt; are of the Open variant, so we do not need to store Brackets, just their chars.
the introduction of fn new is against standard practice. A conversion constructor should not be called fn new and every constructor should return only Self (= Bracket). That's why the function should be renamed to from_char.
it's common practice to name enum variants with PascalCase, in your program, Bracket::Open and Bracket::Close. Not sure why you did all uppercase.
the result of brackets.pop() does not need matching, it can be simply compared.

The refactored code is
#![warn(missing_crate_level_docs)]
#![warn(missing_docs)]
//! # Matching Brackets
//!
//! `matching_brackets` is a collection of utilities to solve [this exercise](https://exercism.io/my/solutions/8ecfdc024536471a8c36ac2a3ff4b119).

enum Bracket {
    Open(char),
    Close(char),
}

impl Bracket {
    pub fn from_char(c: char) -&gt; Option&lt;Bracket&gt; {
        match c {
            '{' | '[' | '(' =&gt; Some(Bracket::Open(c)),
            '}' =&gt; Some(Bracket::Close('{')),
            ']' =&gt; Some(Bracket::Close('[')),
            ')' =&gt; Some(Bracket::Close('(')),
            _ =&gt; None,
        }
    }
}

/// Check if the input `string` has balanced brackets.
///
/// # Examples
///
/// ```rust
/// use matching_brackets::brackets_are_balanced;
/// assert!(brackets_are_balanced(&quot;(((185 + 223.85) * 15) - 543)/2&quot;));
/// assert!(brackets_are_balanced(&quot;([{}({}[])])&quot;));
/// assert!(!brackets_are_balanced(&quot;{[)][]}&quot;))
/// ```
pub fn brackets_are_balanced(string: &amp;str) -&gt; bool {
    let mut brackets: Vec&lt;char&gt; = vec![];
    for c in string.chars() {
        match Bracket::from_char(c) {
            Some(Bracket::Open(char_bracket)) =&gt; {
                brackets.push(char_bracket);
            }
            Some(Bracket::Close(char_close_bracket)) =&gt; {
                if brackets.pop() != Some(char_close_bracket) {
                    return false;
                }
            }
            _ =&gt; {}
        }
    }
    brackets.is_empty()
}
```