type provided when a constant was expected

use burn::backend::Flex;
use burn::tensor::Tensor;

fn main() {
  let device = Default::default();
  let a = Tensor::<Flex, 2>::ones([2, 2], &device);
  println!("{a}");
}

   Compiling pa-old v0.1.0 (~/exp-burn/pa-old)
error[E0747]: type provided when a constant was expected
 --> src/main.rs:6:20
  |
6 |   let a = Tensor::<Flex, 2>::ones([2, 2], &device);
  |                    ^^^^
  |
help: if this generic argument was intended as a const parameter, surround it with braces
  |
6 |   let a = Tensor::<{ Flex }, 2>::ones([2, 2], &device);
  |                    +      +

For more information about this error, try `rustc --explain E0747`.
error: could not compile `pa-old` (bin "pa-old") due to 1 previous error

use burn::nn::{Linear, LinearConfig};
use burn::prelude::*;

#[derive(Module, Debug)]
struct Mlp<B: Backend> {
  fc: Linear<B>,
}

impl<B: Backend> Mlp<B> {
  fn new(device: &B::Device) -> Self {
    Self { fc: LinearConfig::new(3, 2).init(device) }
  }

  fn forward(&self, x: Tensor<B, 2>) -> Tensor<B, 2> {
    self.fc.forward(x)
  }
}

   Compiling pa-old v0.1.0 (~/exp-burn/pa-old)
error[E0405]: cannot find trait `Backend` in this scope
 --> src/bin/old_module.rs:5:15
  |
5 | struct Mlp<B: Backend> {
  |               ^^^^^^^ not found in this scope

error[E0405]: cannot find trait `Backend` in this scope
 --> src/bin/old_module.rs:9:9
  |
9 | impl<B: Backend> Mlp<B> {
  |         ^^^^^^^ not found in this scope

For more information about this error, try `rustc --explain E0405`.
error: could not compile `pa-old` (bin "old_module") due to 2 previous errors

error[E0107]: struct takes 0 generic arguments but 1 generic argument was supplied
  --> src/bin/old_linear.rs:7:7
   |
 7 |   fc: Linear<Flex>,
   |       ^^^^^^------ help: remove the unnecessary generics
   |       |
   |       expected 0 generic arguments
   |
note: struct defined here, with 0 generic parameters
  --> ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/burn-nn-0.22.1/src/modules/linear.rs:48:12
   |
48 | pub struct Linear {
   |            ^^^^^^

        tensor::{
            Bool, Device, ElementConversion, Float, Int, Shape, SliceArg, Tensor, TensorData,
            backend::Backend, cast::ToElement, s,
        },

use burn::tensor::{Device, Tensor};

fn main() {
  let device = Device::flex();
  let a = Tensor::<2>::ones([2, 2], &device);
  println!("{a}");
}

use burn::module::Module;
use burn::nn::{Linear, LinearConfig};
use burn::tensor::{Device, Tensor};

#[derive(Module, Debug)]
struct Mlp {
  fc: Linear,
}

impl Mlp {
  fn new(device: &Device) -> Self {
    Self { fc: LinearConfig::new(3, 2).init(device) }
  }

  fn forward(&self, x: Tensor<2>) -> Tensor<2> {
    self.fc.forward(x)
  }
}

fn main() {
  let device = Device::flex();
  let mlp = Mlp::new(&device);
  let x = Tensor::<2>::ones([4, 3], &device);
  let y = mlp.forward(x);
  println!("y dims {:?} on {:?}", y.dims(), y.device());
  println!("params {}", mlp.num_params());
}

Tensor {
  data:
[[1.0, 1.0],
 [1.0, 1.0]],
  shape:  [2, 2],
  device:  Device<Flex(Cpu)>,
  kind:  "Float",
  dtype:  "f32",
}

y dims [4, 2] on Device<Flex(Cpu)>
params 8