public Pair<Category, Instance<String, String>> toInstance(FQLProgram env, InstConst ic) {
CatExp e = resolve(env, ic.sig);
if (!(e instanceof Const)) {
throw new RuntimeException("Can only create instances for finitely-presented categories.");
}
Const c = (Const) e;
Category src = c.accept(env, this);
Signature<String, String> sig = new Signature<>(c.nodes, c.arrows, c.eqs);
Map<Node, Set> nm = new HashMap<>();
for (String n0 : ic.nm.keySet()) {
Node n = sig.getNode(n0);
SetExp kkk = ic.nm.get(n.name);
if (kkk == null) {
throw new RuntimeException("Missing node mapping from " + n);
}
nm.put(n, kkk.accept(env, new SetOps(ENV)));
}
Map<Edge, Map> em = new HashMap<>();
for (String n0 : ic.em.keySet()) {
Edge n = sig.getEdge(n0);
Chc<FnExp, SetExp> chc = ic.em.get(n.name);
if (chc == null) {
throw new RuntimeException("Missing edge mapping from " + n);
}
if (chc.left) {
FnExp kkk = chc.l;
em.put(n, kkk.accept(env, new SetOps(ENV)).toMap());
} else {
SetExp sss = chc.r;
Set vvv = sss.accept(env, new SetOps(ENV));
Map<Object, Object> uuu = new HashMap<>();
for (Object o : vvv) {
if (!(o instanceof Pair)) {
throw new RuntimeException("Not a pair: " + o);
}
Pair oo = (Pair) o;
if (uuu.containsKey(oo.first)) {
throw new RuntimeException("Duplicate domain entry: " + o + " in " + ic);
}
uuu.put(oo.first, oo.second);
}
FnExp kkk =
new FnExp.Const(x -> uuu.get(x), ic.nm.get(n.source.name), ic.nm.get(n.target.name));
em.put(n, kkk.accept(env, new SetOps(ENV)).toMap());
}
}
return new Pair<>(src, new Instance(nm, em, sig));
}
private Triple<Category, Category, Mapping<String, String, String, String>> toMapping(
FQLProgram env, MapConst ic) {
CatExp src0 = resolve(env, ic.src);
if (src0 == null) {
throw new RuntimeException("Missing category: " + ic.src);
}
if (!(src0 instanceof Const)) {
throw new RuntimeException("Can only create mappings for finitely-presented categories.");
}
Const src = (Const) src0;
CatExp dst0 = resolve(env, ic.dst);
if (!(dst0 instanceof Const)) {
throw new RuntimeException("Can only create mappings for finitely-presented categories.");
}
Const dst = (Const) dst0;
Category srcX = src.accept(env, this);
Category dstX = dst.accept(env, this);
Signature<String, String> srcY = new Signature<>(src.nodes, src.arrows, src.eqs);
Signature<String, String> dstY = new Signature<>(dst.nodes, dst.arrows, dst.eqs);
Map<Node, Node> nm = new HashMap<>();
for (String n0 : ic.nm.keySet()) {
Signature<String, String>.Node n = srcY.getNode(n0);
String v = ic.nm.get(n.name);
if (v == null) {
throw new RuntimeException("Missing object mapping for " + n.name);
}
nm.put(n, dstY.getNode(v));
}
Map<Edge, Path> em = new HashMap<>();
for (String n0 : ic.em.keySet()) {
Signature<String, String>.Edge n = srcY.getEdge(n0);
Pair<String, List<String>> k = ic.em.get(n.name);
if (k == null) {
throw new RuntimeException("Missing arrow mapping for " + n.name);
}
em.put(n, dstY.path(k.first, k.second));
}
Mapping<String, String, String, String> I = new Mapping(nm, em, srcY, dstY);
return new Triple<>(srcX, dstX, I);
}
@Override
public Functor visit(FQLProgram env, FinalConst ic) {
CatExp e = resolve(env, ic.src);
if (!(e instanceof Const)) {
throw new RuntimeException("Can only create functors from finitely-presented categories.");
}
Const c = (Const) e;
Category cat = c.accept(env, this);
Signature<String, String> sig = new Signature<>(c.nodes, c.arrows, c.eqs);
Category target = ic.C.accept(env, this);
Map<Node, Functor> nm = new HashMap<>();
for (Node n : sig.nodes) {
FunctorExp kkk = ic.nm.get(n.name);
if (kkk == null) {
throw new RuntimeException("Missing node mapping from " + n);
}
Functor F = kkk.accept(env, this);
nm.put(n, F);
}
Map<Edge, Transform> em = new HashMap<>();
for (Edge n : sig.edges) {
TransExp chc = ic.em.get(n.name);
if (chc == null) {
throw new RuntimeException("Missing edge mapping from " + n);
}
em.put(n, chc.accept(env, this));
}
FUNCTION fff =
p0 -> {
Path p = (Path) p0;
Object fn = target.identity(nm.get(p.source));
for (Object nnn : p.path) {
Edge n = (Edge) nnn;
fn = target.compose(fn, em.get(n));
}
return fn;
};
return new Functor<>(cat, target, x -> nm.get(x), fff);
}