# Qwen format probe — M-expressions `head[a; b]`

**Model:** Qwen/Qwen3-Coder-Next; single-shot; own literal parser (atoms verbatim).

---

## L0_const — ✅ green

tokens: prompt=616 completion=56

model output:
```
module[
  m;
  fn[
    answer;
    type[
      fn-type[
        params[];
        ret[
          own[
            con[Int]
          ]
        ]
      ]
    ];
    params[];
    body[
      42
    ]
  ]
]
```

converted Form-A:
```
(module m (fn answer (type (fn-type (params) (ret (own (con Int))))) (params) (body 42)))
```


## L1_arith — ✅ green

tokens: prompt=618 completion=72

model output:
```
module[
  m;
  fn[
    triple;
    type[
      fn-type[
        params[
          own[
            con[Int]
          ]
        ];
        ret[
          own[
            con[Int]
          ]
        ]
      ]
    ];
    params[x];
    body[
      app[*; x; 3]
    ]
  ]
]
```

converted Form-A:
```
(module m (fn triple (type (fn-type (params (own (con Int))) (ret (own (con Int))))) (params x) (body (app * x 3))))
```


## L2_print — ✅ green

tokens: prompt=613 completion=79

model output:
```
module[
  m;
  fn[
    main;
    type[
      fn-type[
        params[];
        ret[
          own[
            con[Unit]
          ]
        ];
        effects[IO]
      ]
    ];
    params[];
    body[
      seq[
        app[print; 7];
        do[io/print_str; "\n"]
      ]
    ]
  ]
]
```

converted Form-A:
```
(module m (fn main (type (fn-type (params) (ret (own (con Unit))) (effects IO))) (params) (body (seq (app print 7) (do io/print_str "\n")))))
```


## L3_adt — ✅ green

tokens: prompt=632 completion=122

model output:
```
module[
  m;
  data[
    Light;
    ctor[Red];
    ctor[Green]
  ];
  fn[
    code;
    type[
      fn-type[
        params[
          own[
            con[Light]
          ]
        ];
        ret[
          own[
            con[Int]
          ]
        ]
      ]
    ];
    params[x];
    body[
      match[
        x;
        case[
          pat-ctor[Red];
          0
        ];
        case[
          pat-ctor[Green];
          1
        ]
      ]
    ]
  ]
]
```

converted Form-A:
```
(module m (data Light (ctor Red) (ctor Green)) (fn code (type (fn-type (params (own (con Light))) (ret (own (con Int))))) (params x) (body (match x (case (pat-ctor Red) 0) (case (pat-ctor Green) 1)))))
```


## L4_rec — ❌ convert

tokens: prompt=644 completion=301

model output:
```
module[
  m;
  data[
    IntList;
    ctor[Nil];
    ctor[
      Cons;
      con[Int];
      con[IntList]
    ]
  ];
  fn[
    length;
    type[
      fn-type[
        params[
          own[
            con[IntList]
          ]
        ];
        ret[
          own[
            con[Int]
          ]
        ]
      ]
    ];
    params[xs];
    body[
      match[
        xs;
        case[
          pat-ctor[Nil];
          0
        ];
        case[
          pat-ctor[Cons; h; t];
          app[
            +;
            1;
            app[length; t]
          ]
        ]
      ]
    ]
  ];
  fn[
    main;
    type[
      fn-type[
        params[];
        ret[
          own[
            con[Unit]
          ]
        ];
        effects[IO]
      ]
    ];
    params[];
    body[
      let[
        xs;
        term-ctor[
          IntList;
          Cons;
          1;
          term-ctor[
            IntList;
          Cons;
          2;
          term-ctor[
            IntList;
            Cons;
            3;
            term-ctor[IntList; Nil]
          ]
        ];
        seq[
          app[
            print;
            app[length; xs]
          ];
          do[io/print_str; "\n"]
        ]
      ]
    ]
  ]
]
```


**convert:**
```
own parser rejected output: unterminated [
```

## L5_series_len — ❌ check

tokens: prompt=875 completion=182

model output:
```
module[
  demo_m;
  fn[
    main;
    type[
      fn-type[
        params[];
        ret[
          own[
            con[Unit]
          ]
        ];
        effects[IO]
      ]
    ];
    params[];
    body[
      let[
        s;
        new[
          Series;
          con[Float];
          3
        ];
      ];
      let[
        s1;
        app[Series.push; s; 1.0];
      ];
      let[
        s2;
        app[Series.push; s1; 2.0];
      ];
      let[
        s3;
        app[Series.push; s2; 3.0];
      ];
      seq[
        app[
          print;
          app[Series.len; s3]
        ];
        do[io/print_str; "\n"]
      ]
    ]
  ]
]
```

converted Form-A:
```
(module demo_m (fn main (type (fn-type (params) (ret (own (con Unit))) (effects IO))) (params) (body (let s (new Series (con Float) 3)) (let s1 (app Series.push s 1.0)) (let s2 (app Series.push s1 2.0)) (let s3 (app Series.push s2 3.0)) (seq (app print (app Series.len s3)) (do io/print_str "\n")))))
```

**check:**
```
error: [surface-parse-error] parse error: expected term, got `)` at byte 134
```

## L6_series_at — ❌ check

tokens: prompt=883 completion=190

model output:
```
module[
  demo_m;
  fn[
    main;
    type[
      fn-type[
        params[];
        ret[
          own[
            con[Unit]
          ]
        ];
        effects[IO]
      ]
    ];
    params[];
    body[
      let[
        s;
        new[
          Series;
          con[Float];
          3
        ];
      ];
      let[
        s1;
        app[Series.push; s; 1.0];
      ];
      let[
        s2;
        app[Series.push; s1; 2.0];
      ];
      let[
        s3;
        app[Series.push; s2; 3.0];
      ];
      seq[
        app[
          print;
          app[
            Series.at;
            s3;
            0
          ]
        ];
        do[io/print_str; "\n"]
      ]
    ]
  ]
]
```

converted Form-A:
```
(module demo_m (fn main (type (fn-type (params) (ret (own (con Unit))) (effects IO))) (params) (body (let s (new Series (con Float) 3)) (let s1 (app Series.push s 1.0)) (let s2 (app Series.push s1 2.0)) (let s3 (app Series.push s2 3.0)) (seq (app print (app Series.at s3 0)) (do io/print_str "\n")))))
```

**check:**
```
error: [surface-parse-error] parse error: expected term, got `)` at byte 134
```

## L7_sma — ❌ check

tokens: prompt=966 completion=327

model output:
```
module[
  demo_m;
  fn[
    main;
    type[
      fn-type[
        params[];
        ret[
          own[
            con[Unit]
          ]
        ];
        effects[IO]
      ]
    ];
    params[];
    body[
      let[
        s;
        new[
          Series;
          con[Float];
          3
        ];
        let[
          s1;
          app[Series.push; s; 1.0];
        ];
        let[
          s2;
          app[Series.push; s1; 5.0];
        ];
        let[
          s3;
          app[Series.push; s2; 3.0];
        ];
        seq[
          app[
            print;
            app[
              /;
              app[Series.sum; s3];
              3.0
            ]
          ];
          let[
            s4;
            app[Series.push; s3; 8.0];
            seq[
              app[
                print;
                app[
                  /;
                  app[Series.sum; s4];
                  3.0
                ]
              ];
              let[
                s5;
                app[Series.push; s4; 6.0];
                seq[
                  app[
                    print;
                    app[
                      /;
                      app[Series.sum; s5];
                      3.0
                    ]
                  ];
                  let[
                    s6;
                    app[Series.push; s5; 2.0];
                  ]
            
```

converted Form-A:
```
(module demo_m (fn main (type (fn-type (params) (ret (own (con Unit))) (effects IO))) (params) (body (let s (new Series (con Float) 3) (let s1 (app Series.push s 1.0)) (let s2 (app Series.push s1 5.0)) (let s3 (app Series.push s2 3.0)) (seq (app print (app / (app Series.sum s3) 3.0)) (let s4 (app Series.push s3 8.0) (seq (app print (app / (app Series.sum s4) 3.0)) (let s5 (app Series.push s4 6.0) (seq (app print (app / (app Series.sum s5) 3.0)) (let s6 (app Series.push s5 2.0)))))))))))
```

**check:**
```
error: [surface-parse-error] parse error: expected term, got `)` at byte 166
```


---
## Ladder

- L0_const: ✅ green
- L1_arith: ✅ green
- L2_print: ✅ green
- L3_adt: ✅ green
- L4_rec: ❌ convert
- L5_series_len: ❌ check
- L6_series_at: ❌ check
- L7_sma: ❌ check