How to use the @effectful/transducers.Tag.expression function in @effectful/transducers

yield sl.enter(Tag.declarations, Tag.Array);
                for (const { sym, init } of vars) {
                  if (sym.substSym) continue;
                  yield sl.enter(Tag.push, Tag.VariableDeclarator);
                  yield sl.tok(Tag.id, Tag.Identifier, { sym, decl: true });
                  if (init) yield* init;
                  yield* sl.leave();
                }
                yield* lab();
              }

              for (const j of decls) if (j[1].raw != null) yield* j[1].raw;
              if (assigns.length) {
                for (const { sym, init } of assigns) {
                  yield sl.enter(Tag.push, Tag.ExpressionStatement);
                  yield sl.enter(Tag.expression, Tag.AssignmentExpression, {
                    node: { operator: "=" }
                  });
                  yield sl.tok(Tag.left, Tag.Identifier, {
                    sym,
                    lhs: true,
                    rhs: false,
                    decl: false
                  });
                  yield* init;
                  yield* sl.leave();
                  yield* sl.leave();
                }
              }
              // babel's hoist re-hack
              if (i.value.babelHoistReHack) {
                yield sl.enter(Tag.push, Tag.BlockStatement);

}
              if (declarators.length) {
                if (stmt && i.pos === Tag.push) {
                  for (const k of declarators) {
                    yield sl.enter(Tag.push, Tag.ExpressionStatement);
                    yield sl.enter(Tag.expression, Tag.AssignmentExpression, {
                      node: { operator: "=" }
                    });
                    yield* k;
                    yield* sl.leave();
                    yield* sl.leave();
                  }
                } else {
                  const lab = sl.label();
                  if (stmt) yield sl.enter(i.pos, Tag.ExpressionStatement);
                  let pos = stmt ? Tag.expression : i.pos;
                  if (declarators.length !== 1) {
                    yield sl.enter(pos, Tag.SequenceExpression);
                    yield sl.enter(Tag.expressions, Tag.Array);
                    pos = Tag.push;
                  }
                  for (const k of declarators) {
                    yield sl.enter(pos, Tag.AssignmentExpression, {
                      node: { operator: "=" }
                    });
                    yield* k;
                    yield* sl.leave();
                  }
                  yield* lab();
                }
              }
              Kit.skip(sl.leave());

if (!decls.has(sym)) decls.set(sym, { raw: null });
                      j.value.lhs = true;
                      j.value.rhs = false;
                      j.value.decl = false;
                    }
                    ids.push(j);
                  }
                  const sym = Bind.tempVarSym(top.value, "ex");
                  const lab = sl.label();
                  yield sl.peel(i);
                  yield sl.tok(Tag.param, Tag.Identifier, { sym });
                  yield sl.peel();
                  yield* sl.peelTo(Tag.body);
                  const blab = sl.label();
                  yield sl.enter(Tag.push, Tag.ExpressionStatement);
                  yield sl.enter(Tag.expression, Tag.AssignmentExpression, {
                    node: { operator: "=" }
                  });
                  yield* Kit.reposOne(ids, Tag.left);
                  yield sl.tok(Tag.right, Tag.Identifier, {
                    sym,
                    lhs: false,
                    rhs: true,
                    decl: false
                  });
                  yield* blab();
                  yield* _saveDecls();
                  yield* lab();
                }
                continue;
              }
              break;

function* toBlock(pos) {
    const lab = sl.label();
    const b = sl.take();
    if (b.value.expr) {
      yield hl("block", sl.enter(Tag.body, Tag.ExpressionStatement));
      yield sl.peel(Kit.setPos(b, Tag.expression));
    } else {
      if (
        symName(b.type) === "castToBlock" ||
        symName(b.type) === "castToBody"
      ) {
        yield* toBlock(pos);
        return;
      }
      if (b.type === Tag.BlockStatement) {
        yield sl.peel(Kit.setPos(b, pos));
      } else {
        yield sl.enter(pos, Tag.BlockStatement);
        yield sl.enter(Tag.body, Tag.Array);
        yield sl.peel(Kit.setPos(b, Tag.push));
      }
    }

function* _saveDecls(pureTry) {
      for (const i of sl.sub()) {
        if (i.enter) {
          switch (i.type) {
            case Tag.ClassDeclaration:
              const id = sl.cur().value.sym;
              if (!decls.has(id)) decls.set(id, { raw: null });
              yield sl.enter(i.pos, Tag.ExpressionStatement);
              yield sl.enter(Tag.expression, Tag.AssignmentExpression, {
                node: { operator: "=" }
              });
              yield sl.tok(Tag.left, Tag.Identifier, { sym: id });
              yield* sl.copy(
                Kit.setType(Kit.setPos(i, Tag.right), Tag.ClassExpression)
              );
              yield* sl.leave();
              yield* sl.leave();
              continue;
            case Tag.FunctionDeclaration:
              const old = decls.get(i.value.funcId);
              const init = [
                ...sl.copy(
                  Kit.setType(Kit.setPos(i, Tag.init), Tag.FunctionExpression)
                )
              ];

yield Kit.enter(Tag.push, Tag.VariableDeclarator);
              yield Kit.tok(Tag.id, Tag.Identifier, { sym: i.value.sym });
              yield Kit.enter(Tag.init, Kit.Subst);
            } else {
              yield D.copyComment(
                i,
                D.setComment(
                  Kit.enter(i.pos, Tag.ExpressionStatement, {
                    node: {},
                    eff: i.value.eff
                  }),
                  "S",
                  "font-size:xx-large;color:orange"
                )
              );
              yield Kit.enter(Tag.expression, Kit.Subst);
            }
          }
          if (i.leave) yield* Kit.repeat(hasBind ? 4 : 2, Kit.leave());
          break;
        case "bindPat":
          if (i.enter)
            yield Kit.tok(i.pos, Tag.Identifier, {
              sym: i.value.sym,
              node: i.value.node
            });
          break;
        default:
          yield i;
      }
    }
  },