Result 到处都是

h = (x @ w1).relu()

let h = x.matmul(&w1)?.relu()?;

let h = x.matmul(&w).relu()?;

error[E0599]: no method named `relu` found for enum `Result<T, E>` in the current scope
   --> src/bin/noq.rs:6:24
    |
  6 |   let h = x.matmul(&w).relu()?;
    |           -            ^^^^ method not found in `Result<candle_core::Tensor, candle_core::Error>`
    |           |
    |           method `relu` is available on `&candle_core::Tensor`
    |
note: the method `relu` exists on the type `candle_core::Tensor`
   --> .../candle-core-0.11.0/src/tensor.rs:80:9
...
help: use the `?` operator to extract the `candle_core::Tensor` value, propagating a `Result::Err` value to the caller
    |
  6 |   let h = x.matmul(&w)?.relu()?;
    |                       +

let d = (&a + &b + &c)?;
let e = ((&a * 2.0)? + 1.0)?;
let f = (2.0 * &a + &b)?;

[3.0, 3.0, 3.0] [3.0, 3.0, 3.0] [3.0, 3.0, 3.0]

        impl<B: std::borrow::Borrow<Tensor>> std::ops::$trait<&Tensor> for Result<B> {
            type Output = Result<Tensor>;

            fn $fn1(self, rhs: &Tensor) -> Self::Output {
                Tensor::$fn1(self?.borrow(), rhs)
            }
        }

let y = (&x * 2.0 + 1.0)?;

error[E0277]: cannot add `{float}` to `Result<candle_core::Tensor, candle_core::Error>`
    --> src/bin/scalarchain.rs:5:21
     |
   5 |   let y = (&x * 2.0 + 1.0)?;
     |                     ^ no implementation for `Result<candle_core::Tensor, candle_core::Error> + {float}`
     |
     = help: the trait `std::ops::Add<{float}>` is not implemented for `Result<candle_core::Tensor, candle_core::Error>`
...

a = torch.ones(2, 3)
b = torch.ones(3, 2)
a + b
a @ a
a @ b.double()
a + b.t().double()
a @ b.to("mps")

("a + b", &a + &b),
("a.matmul(a)", a.matmul(&a)),
("a.matmul(b f64)", b.to_dtype(DType::F64).and_then(|b| a.matmul(&b))),
("a + b.t() f64", b.t().and_then(|b| b.to_dtype(DType::F64)).and_then(|b| &a + &b)),
("a cpu .matmul(b metal)", b.to_device(&metal).and_then(|b| a.matmul(&b))),

# PyTorch
a + b                RuntimeError: The size of tensor a (3) must match the size of tensor b (2) at non-singleton dimension 1
a @ a                RuntimeError: mm: mat1 and mat2 shapes cannot be multiplied (2x3 and 2x3)
a @ b.double()       RuntimeError: expected m1 and m2 to have the same dtype, but got: float != double
a + b.t().double()   ok torch.float64 [2, 3]
a.cpu() @ b.mps      RuntimeError: Tensor for argument #1 'mat1' is on CPU, but expected it to be on GPU (while checking arguments for mm)
# candle
a + b                  Err: shape mismatch in add, lhs: [2, 3], rhs: [3, 2]
a.matmul(a)            Err: shape mismatch in matmul, lhs: [2, 3], rhs: [2, 3]
a.matmul(b f64)        Err: dtype mismatch in matmul, lhs: F32, rhs: F64
a + b.t() f64          Err: dtype mismatch in add, lhs: F32, rhs: F64
a cpu .matmul(b metal) Err: device mismatch in matmul, lhs: Cpu, rhs: Metal { gpu_id: 4294968354 }

def mlp(x, w1, w2, w3):
  h = (x @ w1).relu()
  h = (h @ w2).relu()
  return h @ w3

Traceback (most recent call last):
  File ".../errs.py", line 17, in <module>
    mlp(x, w1, w2, w3)
    ~~~^^^^^^^^^^^^^^^
  File ".../errs.py", line 10, in mlp
    h = (h @ w2).relu()
         ~~^~~~
RuntimeError: mm: mat1 and mat2 shapes cannot be multiplied (4x16 and 8x16)

fn mlp(x: &Tensor, w1: &Tensor, w2: &Tensor, w3: &Tensor) -> candle_core::Result<Tensor> {
  let h = x.matmul(w1)?.relu()?;
  let h = h.matmul(w2)?.relu()?;
  h.matmul(w3)
}

Error: shape mismatch in matmul, lhs: [4, 16], rhs: [8, 16]

use anyhow::Context as _;

fn mlp_ctx(x: &Tensor, w1: &Tensor, w2: &Tensor, w3: &Tensor) -> anyhow::Result<Tensor> {
  let h = x.matmul(w1).context("mlp: x @ w1")?.relu()?;
  let h = h.matmul(w2).context("mlp: h @ w2")?.relu()?;
  Ok(h.matmul(w3).context("mlp: h @ w3")?)
}

{}:   mlp: h @ w2
{:#}: mlp: h @ w2: shape mismatch in matmul, lhs: [4, 16], rhs: [8, 16]

fn main() -> anyhow::Result<()> {
  let tok = Tokenizer::from_file("tokenizer.json")?;
  // ...
}

error[E0277]: `?` couldn't convert the error: `dyn std::error::Error + Send + Sync: Sized` is not satisfied
 --> src/bin/tokq.rs:4:51
  |
3 | fn main() -> anyhow::Result<()> {
  |              ------------------ required `dyn std::error::Error + Send + Sync: Sized` because of this
4 |   let tok = Tokenizer::from_file("tokenizer.json")?;
  |             --------------------------------------^ doesn't have a size known at compile-time
  |             |
  |             this can't be annotated with `?` because it has type `Result<_, Box<(dyn std::error::Error + Send + Sync + 'static)>>`
  |
  = help: the trait `Sized` is not implemented for `dyn std::error::Error + Send + Sync`
  = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
  = note: required for `Box<dyn std::error::Error + Send + Sync>` to implement `std::error::Error`
  = note: required for `anyhow::Error` to implement `From<Box<dyn std::error::Error + Send + Sync>>`

let tok = Tokenizer::from_file(&path).map_err(anyhow::Error::msg)?;

vocab 49152
Error: No such file or directory (os error 2)

for (tag, r) in cases {
  match r {
    Ok(t) => println!("{tag:22} ok {:?} {:?}", t.dtype(), t.dims()),
    Err(e) => println!("{tag:22} Err: {e}"),
  }
}