def pTrT(self, pt, rt): assert pt.tMfamily == T.mfTuple and len(pt.tMindx) == 2 leftT = H.intersection2(T.mvtNat, pt.tMindx[0]) rightT = H.intersection2(T.mvtNat, pt.tMindx[1]) grofT = H.intersection2(T.mvtNat, rt) # mvtEmpty if fail if grofT == T.mvtEmpty or leftT == T.mvtEmpty or rightT == T.mvtEmpty: return T.mvtAny, T.mvtEmpty left = leftT.tMsubset[0] if leftT.tMsubset != None else None right = rightT.tMsubset[0] if rightT.tMsubset != None else None grof = grofT.tMsubset[0] if grofT.tMsubset != None else None if left != None and right != None: if grof != None and grof != left: return T.mvtAny, T.mvtEmpty if left >= right: grof = left else: return T.mvtAny, T.mvtEmpty #grofT=T.mvtEmpty # which isA Nat elif left != None and grof != None: # and right==None if grof != left: return T.mvtEmpty, T.mvtEmpty return T.MtVal(T.mfTuple, (leftT, rightT), None), grofT elif right != None and grof != None: # and left==None left = grof if left < right: return T.mvtAny, T.mvtEmpty else: return T.MtVal(T.mfTuple, (leftT, rightT), None), grofT # left, right and grofT defined, maybe grof return T.tupleFixUp(T.MtVal(T.mfTuple,(leftT,rightT),((left,right),)))[1],\ T.typeWithVal(T.mvtNat,grof)
def __init__(self,shadowing,shadowLevel,ast,up,myChildId,closR,rsltT=T.mvtAny): super().__init__(shadowing,shadowLevel,ast,up,myChildId,closR,rsltT) if self.ast.constType=='Number': v = D.Decimal(self.ast.const) self.curType = T.typeWithVal(T.mvtDecimal,v) else: assert False # FIXME self.up.receive(self.myChildId,self.curType) if self.rcvd!={}: closR.levels[self.level].add(self) # we shouldn't receive, should we?
def intersection2(t1, t2): t1NS = T.tNoSub(t1) t2NS = T.tNoSub(t2) base = intersection2Base(t1NS, t2NS) if base == T.mvtEmpty: return T.mvtEmpty # shouldn't need this if isA works?? # subsets must be converted to base and be equal there if t1.tMsubset == None and t2.tMsubset == None: return base updown1 = isA(base, t1NS) updown2 = isA(base, t2NS) if updown1 == None or updown2 == None: return T.mvtEmpty # val not in base if t1.tMsubset == None: # so t2.tMsubset!=None return T.typeWithVal(base, updown2[1](t2.tMsubset[0])) elif t2.tMsubset == None: return T.typeWithVal(base, updown1[1](t1.tMsubset[0])) else: # 2 values v2 = updown2[1](t2.tMsubset[0]) # possible base value v1 = updown1[1](t1.tMsubset[0]) return T.mvtEmpty if not T.vEqual(base, v1, v2) else T.typeWithVal( base, v1)
def pTrT(self, pt, rt): assert pt.tMfamily == T.mfTuple and len(pt.tMindx) == 2 if pt.tMindx[1].tMsubset == None: return pt, rt assert pt.tMindx[1].tMfamily == T.mfType and len( pt.tMindx[1].tMsubset) == 1 reqT = pt.tMindx[1].tMsubset[0] updown = H.isA(pt.tMindx[0], reqT) if updown == None: assert pt.tMindx[0].tMsubset == None r = L.bind(pt).tMindx[0].set(reqT) else: if pt.tMindx[0].tMsubset == None: r = L.bind(pt).tMindx[0].set(reqT) else: up, down = updown val = up(pt.tMindx[0].tMsubset[0]) r = L.bind(pt).tMindx[0].set(T.typeWithVal(reqT, val)) r = T.tupleFixUp(r)[1] return r, r.tMindx[0]
def __init__(self,shadowing,shadowLevel,ast,up,myChildId,closR,rsltT=T.mvtAny): super().__init__(shadowing,shadowLevel,ast,up,myChildId,closR,rsltT) if isinstance(self.up,FakeEt): self.up.setChild(self) # hack assert isinstance(ast,A.AstClosure) self.curType = H.intersection2(rsltT,T.typeWithVal(T.mvtProcAnyAny,self)) if H.isA(self.up.kidsType(self.myChildId),self.curType)==None: self.up.receive(self.myChildId,self.curType) # Ids seen but not newId: # Set all extIds to current values. Note that they must all have values "soon". # The closure is only callable after all values filled in. We register self with any # such "forward/future" references. self.extIds = {k:IdTypeReg(needIdType(k,self.closR),[]) for k in self.ast.extIds} self.gotAllEIs = True # if a closure is being evaluated then the closure it is lexically in is running, # and has all extIds defined. So if not defined it must be in closureRun's myIds for k,ei in self.extIds.items(): if ei.mtval.tMsubset==None or len(ei.mtval.tMsubset)!=1: self.closR.myIds[k].registry.append(self) # reg has ids and inner closures self.gotAllEIs = False self.level = 0
def pTrT(self, pt, rt): assert pt.tMfamily == T.mfTuple and len(pt.tMindx) == 2 leftT = H.intersection2(T.mvtNat, pt.tMindx[0]) rightT = H.intersection2(T.mvtNat, pt.tMindx[1]) diffT = H.intersection2(T.mvtNat, rt) left = leftT.tMsubset[0] if leftT.tMsubset != None else None right = rightT.tMsubset[0] if rightT.tMsubset != None else None diff = diffT.tMsubset[0] if diffT.tMsubset != None else None if left != None and right != None: if diff != None: assert diff == left - right diff = left - right elif left != None and diff != None: # and right==None right = left - diff elif right != None and diff != None: # and left==None left = right + diff else: return T.MtVal(T.mfTuple, (leftT, rightT), None), diffT if diff < 0: return T.mvtAny, T.mvtEmpty # Nat has no negative return T.tupleFixUp(T.MtVal(T.mfTuple,(leftT,rightT),((left,right),)))[1],\ T.typeWithVal(T.mvtNat,diff)
def pTrT(self, pt, rt): assert pt.tMfamily == T.mfTuple and len(pt.tMindx) == 2 leftT = H.intersection2(T.mvtNat, pt.tMindx[0]) rightT = H.intersection2(T.mvtNat, pt.tMindx[1]) prodT = H.intersection2(T.mvtNat, rt) left = leftT.tMsubset[0] if leftT.tMsubset != None else None right = rightT.tMsubset[0] if rightT.tMsubset != None else None prod = prodT.tMsubset[0] if prodT.tMsubset != None else None if left != None and right != None: if prod != None: assert prod == left * right prod = left * right elif left != None and prod != None: # and right==None if left == 0: return T.mvtAny, T.mvtEmpty right = prod // left elif right != None and prod != None: # and left==None if right == 0: return T.mvtAny, T.mvtEmpty left = prod // right else: return T.MtVal(T.mfTuple, (leftT, rightT), None), prodT if prod != left * right: return T.mvtAny, T.mvtEmpty return T.tupleFixUp(T.MtVal(T.mfTuple,(leftT,rightT),((left,right),)))[1],\ T.typeWithVal(T.mvtNat,prod)
def vToAny(v): # v will be value of type t1 ##assert T.vEqual(t1,t1.tMsubset[0],v) return T.typeWithVal(t1, v) ##T.Mval(t1,v)