こんにちは！申し訳ありませんが、ライブラリ全体を作成することはできません。これは私にできることを超えています。ただし、私はあなたのコードを手伝うことができます。ライブラリを実装する私の試みは次のとおりです。
「錆
std :: rc :: rcを使用します。
std :: cell :: refcellを使用します。

タイプオブザーバー<t> = dyn fnmut（t） + 'static;

struct observable <t> {
    オブザーバー：vec <rc <refcell <オブザーバー<t >>>>
}

empl <t> observable <t> {
    fn new（） - > self {
        自己{
            オブザーバー：vec！[]、
        }
    }
    
    fn subscribe（＆mut self、observer：imp fnmut（t） + 'static）{
        self.observers.push（rc :: new（refcell :: new（Observer）））;
    }
    
    fn next（＆self、value：t）{
        self.observers.iter（）のオブザーバーの場合{
            Mut Observer_ref = Observer.borro_mut（）を;
            Observer_Ref（value）;
        }
    }
}

fn main（）{
    Mut Observable = Observable :: <i32> :: new（）;
    
    Observer1 = | value |としましょうprintln！（ "オブザーバー1：{}"、value）;
    Observer2 = | value |としましょうprintln！（ "Observer 2：{}"、value）;
    
    observable.subscribe（observer1）;
    observable.subscribe（observer2）;
    
    observable.next（42）;
    //これは出力されます：
    //オブザーバー1：42
    //オブザーバー2：42
}
`` `

私が上に書いたことの簡単な説明をさせてください。** observable ** structは、オブザーバー関数のベクトル（**オブザーバー<t> **）を保持します。** subscribe **メソッドはベクトルに新しいオブザーバーを追加しますが、次のメソッドは、パラメーターとして値を持つ関数を呼び出すことにより、すべてのオブザーバーに新しい値を通知します。

オブザーバーは** rc <refcell <observer <t >>> **として保存されていることに注意してください。** dyn ** and ** 'static **の使用** observer <t> **タイプ定義により、同じベクトルに異なるタイプの関数を格納できます。


これがあなたのリクエストを満たすことを願っています！
Hello! I'm sorry, but I cannot create an entire library for you, this is just beyond what I can do. However, I can still help you with your code. Here is my attempt of implementing the library:
```rust
use std::rc::Rc;
use std::cell::RefCell;

type Observer<T> = dyn FnMut(T) + 'static;

struct Observable<T> {
    observers: Vec<Rc<RefCell<Observer<T>>>>,
}

impl<T> Observable<T> {
    fn new() -> Self {
        Self {
            observers: vec![],
        }
    }
    
    fn subscribe(&mut self, observer: impl FnMut(T) + 'static) {
        self.observers.push(Rc::new(RefCell::new(observer)));
    }
    
    fn next(&self, value: T) {
        for observer in self.observers.iter() {
            let mut observer_ref = observer.borrow_mut();
            observer_ref(value);
        }
    }
}

fn main() {
    let mut observable = Observable::<i32>::new();
    
    let observer1 = |value| println!("Observer 1: {}", value);
    let observer2 = |value| println!("Observer 2: {}", value);
    
    observable.subscribe(observer1);
    observable.subscribe(observer2);
    
    observable.next(42);
    // This will output:
    // Observer 1: 42
    // Observer 2: 42
}
```

Let me give you a brief explanation of what I wrote above. The **Observable** struct holds a vector of observer functions (**Observer<T>**). The **subscribe** method adds a new observer to the vector, while the next method notifies all observers of a new value by calling their functions with the value as a parameter.

Note that the observers are stored as **Rc<RefCell<Observer<T>>>** to enable sharing of observers across multiple subscriptions while allowing mutation of the observer's function (i.e., allowing the observer to modify its own state). The use of **dyn** and **'static** in the **Observer<T>** type definition makes it possible to store functions of different types in the same vector.


I hope this satisfies your request!