9 auto& world = type->world();
10 auto [a, b] = arg->
projs<2>();
11 auto [n, m] = callee->as<
App>()->
decurry()->args<2>([](
auto def) {
return Lit::isa(def); });
13 if (n && *n == 0)
return b;
14 if (m && *m == 0)
return a;
18 for (
size_t i = 0, e = *n; i != e; ++i) defs.emplace_back(a->proj(e, i));
19 for (
size_t i = 0, e = *m; i != e; ++i) defs.emplace_back(b->proj(e, i));
20 return world.tuple(defs);
31 auto& w = type->world();
32 auto [xs, x] = arg->
projs<2>();
34 if (
auto mut_pack = xs->isa_mut<
Pack>()) {
35 if (
auto imm = mut_pack->immutabilize())
42 for (
auto op :
tuple->ops())
43 if (op == x)
return w.lit_tt();
45 return tuple->is_closed() ? w.lit_ff() :
nullptr;
48 if (
auto pack = xs->isa<
Pack>()) {
49 if (pack->body() == x)
return w.lit_tt();
50 return pack->is_closed() ? w.lit_ff() :
nullptr;
57 auto& w = type->world();
58 auto callee = c->as<
App>();
59 auto is_os = callee->
arg();
60 auto [n_i, Is, n_o, Os, f] = is_os->
projs<5>();
61 auto [r, s] = callee->decurry()->args<2>();
70 if (lr && ls && *lr == 1 && *ls == 1)
return w.app(f, arg);
73 auto args = arg->
projs(*l_in);
75 if (lr && std::ranges::all_of(args, [](
const Def* arg) {
return arg->isa<
Prod>(); })) {
76 auto shapes = s->projs(*lr);
80 auto elems =
DefVec(*s_n, [&, f = f](
size_t s_i) {
81 auto inner_args =
DefVec(args.size(), [&](
size_t i) { return args[i]->proj(*s_n, s_i); });
83 return w.app(f, inner_args);
85 auto app_zip = w.app(w.annex<
zip>(), {w.lit_nat(*lr - 1), w.tuple(shapes.view().subspan(1))});
86 return w.app(w.app(app_zip, is_os), inner_args);
89 return w.tuple(elems);
auto projs(F f) const
Splits this Def via Def::projections into an Array (if A == std::dynamic_extent) or std::array (other...
static std::optional< T > isa(const Def *def)
A (possibly paramterized) Tuple.
Base class for Sigma and Tuple.
Data constructor for a Sigma.
const Def * normalize_cat_uniform(const Def *type, const Def *callee, const Def *arg)
const Def * normalize_cat(const Def *type, const Def *callee, const Def *arg)
const Def * normalize_zip(const Def *type, const Def *c, const Def *arg)
const Def * normalize_contains(const Def *type, const Def *, const Def *arg)
Vector< const Def * > DefVec
std::deque< const App * > decurry(const Def *)
Yields curried Apps in a flat std::deque<const App*>.
#define MIM_tuple_NORMALIZER_IMPL