@Override public void apply(KAs k) { sb.append("("); apply(k.pattern()); sb.append(" as "); apply(k.alias()); sb.append(")"); }
@Override public void apply(KAs k) { Sort sort = k.att().get(Sort.class); sb.append("\\and{"); convert(sort, false); sb.append("}("); apply(k.pattern()); sb.append(","); apply(k.alias()); sb.append(")"); }
public DefaultMutableTreeNode apply(KAs k) { DefaultMutableTreeNode pattern = apply(k.pattern()); DefaultMutableTreeNode alias = apply(k.alias()); if (pattern.isLeaf() && alias.isLeaf()) { String text = ToKast.apply(k); if (text.length() < 80) { return new DefaultMutableTreeNode(text); } } DefaultMutableTreeNode node = new DefaultMutableTreeNode("#as"); node.add(pattern); node.add(alias); return node; }
/** * Checks whether a lhs pattern is constructor-based, i.e., an application of a * function symbol to a list of constructor terms. * * @param term * @return */ public boolean isConstructorBased(K term) { if (term instanceof KApply) { return ((KApply) term).klist().items().stream().allMatch(this::isConstructorTerm); } if (term instanceof KAs) { return isConstructorBased(((KAs) term).pattern()); } KException.criticalError("Unexpecting isConstructorBased call on " + term.getClass()); return false; }
knode.add("pattern", toJson(alias.pattern())); knode.add("alias", toJson(alias.alias())); knode.add("att", alias.att().toString());
@Override public void apply(KApply k) { if (k.klabel().name().equals("<k>")) { if (!hasProblem.booleanValue()) { hasProblem.setTrue(); if (k.klist().items().size() == 1) { if (k.klist().items().get(0) instanceof KSequence) { KSequence seq = (KSequence) k.klist().items().get(0); if (seq.items().size() >= 1) { K head = seq.items().get(0); while (head instanceof KAs) { head = ((KAs) head).pattern(); } if (head instanceof KApply) { KApply app = (KApply) head; if (!(app.klabel() instanceof KVariable)) { if (!rhs || (!functions.contains(app.klabel()) && !anywhereKLabels.contains(app.klabel()))) { nextOps.add(app.klabel()); hasProblem.setFalse(); } } } } } } } } super.apply(k); } }.apply(side);
K head = kCell.items().get(0); while (head instanceof KAs) { head = ((KAs) head).pattern();
@Override public K apply(KAs k) { K res = apply(k.pattern()); KVariable var = (KVariable) k.alias(); if (!(res instanceof KSequence) && var.att().getOptional(Sort.class).orElse(Sorts.K()).equals(Sorts.K())) { res = KSequence(res); } return KAs(res, k.alias(), k.att()); } }.apply(term);
private Sort sort(K k) { if (k instanceof KSequence) return Sorts.K(); if (k instanceof KAs) return sort(((KAs) k).pattern()); if (k instanceof InjectedKLabel) return Sorts.KItem(); if (k instanceof KToken) return ((KToken) k).sort(); if (k instanceof KApply) return k.att().get(Production.class).sort(); if (k instanceof KVariable) return Sorts.K(); throw KEMException.compilerError("Could not compute sort of term", k); }
} else if (term instanceof KAs) { KAs as = (KAs) term; Sort patternSort = sort(as.pattern(), expectedSort); Sort rightSort = sort(as.alias(), expectedSort); return lubSort(patternSort, rightSort, expectedSort, term);
} else if (term instanceof KAs) { KAs kas = (KAs)term; return KAs(addInjections(kas.pattern(), actualSort), kas.alias(), att); } else { throw KEMException.internalError("Invalid category of k found.", term);