Python lists.wrapList函数代码示例

 def _uncall(self):
     from typhon.objects.collections.lists import wrapList
     from typhon.objects.collections.maps import EMPTY_MAP
     # [1,2,3].asSet().diverge() -> [[[1,2,3], "asSet"], "diverge"]
     rv = wrapList(self.objectSet.keys())
     return [wrapList([rv, StrObject(u"asSet"), wrapList([]), EMPTY_MAP]),
             StrObject(u"diverge"), wrapList([]), EMPTY_MAP]

 def _uncall(self):
     from typhon.objects.makers import theMakeBytes
     from typhon.objects.collections.lists import wrapList
     from typhon.objects.collections.maps import EMPTY_MAP
     ints = [IntObject(ord(c)) for c in self._bs]
     return [theMakeBytes, StrObject(u"fromInts"),
             wrapList([wrapList(ints)]), EMPTY_MAP]

 def _uncall(self):
     from typhon.objects.collections.lists import wrapList
     from typhon.scopes.safe import theMakeMap
     pairs = wrapList([wrapList([k, v])
                       for k, v in self.objectMap.items()])
     rv = wrapList([pairs])
     return [theMakeMap, StrObject(u"fromPairs"), rv, EMPTY_MAP]

 def testListEqualityRecursion(self):
     first = wrapList([IntObject(42), NullObject])
     # Hax.
     first.objs.append(first)
     second = wrapList([IntObject(42), NullObject])
     # Hax.
     second.objs.append(second)
     self.assertEqual(optSame(first, second), EQUAL)

 def _uncall(self):
     from typhon.objects.collections.maps import EMPTY_MAP
     from typhon.scopes.safe import theSlotBinder
     return [wrapList([theSlotBinder, StrObject(u"run"),
                      wrapList([self.guard])]),
             StrObject(u"run"),
             wrapList([self.slot, NullObject]),
             EMPTY_MAP]

def unsealException(specimen, ej):
    """
    Unseal a specimen.
    """

    if isinstance(specimen, SealedException):
        trail = wrapList([StrObject(s) for s in specimen.trail])
        return wrapList([specimen.value, trail])
    throwStr(ej, u"Cannot unseal non-thrown object")

def unsealException(specimen, ej):
    """
    Unseal a specimen.
    """

    if isinstance(specimen, SealedException):
        ue = specimen.ue
        trail = wrapList([StrObject(s) for s in ue.formatTrail()])
        return wrapList([ue.getPayload(), trail])
    throwStr(ej, u"Cannot unseal non-thrown object")

 def _uncall(self):
     from typhon.objects.collections.lists import wrapList
     from typhon.objects.collections.maps import EMPTY_MAP
     return [
         makeSourceSpan, StrObject(u"run"),
         wrapList([wrapBool(self._isOneToOne), IntObject(self.startLine),
                    IntObject(self.startCol), IntObject(self.endLine),
                    IntObject(self.endCol)]), EMPTY_MAP]

    def runMatchers(self, atom, args, namedArgs):
        message = wrapList([StrObject(atom.verb), wrapList(args),
                            namedArgs])
        for matcher in self.getMatchers():
            with Ejector() as ej:
                try:
                    return self.runMatcher(matcher, message, ej)
                except Ejecting as e:
                    if e.ejector is ej:
                        # Looks like unification failed. On to the next
                        # matcher!
                        continue
                    else:
                        # It's not ours, cap'n.
                        raise

        raise Refused(self, atom, args)

 def sendAll(self, atom, args, namedArgs):
     if self.checkSlot():
         ref = self.resolutionBox.get()
         return send(ref, atom, args, namedArgs)
     else:
         return send(self.handler, HANDLESEND_3, [StrObject(atom.verb),
                                                  wrapList(args),
                                                  namedArgs], EMPTY_MAP)

def getAddrInfo(node, service):
    node = unwrapBytes(node)
    service = unwrapBytes(service)
    vat = currentVat.get()
    p, r = makePromise()
    emptyAI = nullptr(ruv.s.addrinfo)
    with io:
        ai = emptyAI
        try:
            ai = ruv.magic_getAddrInfo(vat, node, service)
        except object as err:
            smash(r, StrObject(u"libuv error: %s" % err))
        else:
            resolve(r, wrapList(walkAI(ai)[:]))
    return p

    def connectStream(self):
        vat = currentVat.get()
        stream = ruv.alloc_tcp(vat.uv_loop)

        source, sourceResolver = makePromise()
        sink, sinkResolver = makePromise()

        # Ugh, the hax.
        resolvers = wrapList([sourceResolver, sinkResolver])
        ruv.stashStream(ruv.rffi.cast(ruv.stream_tp, stream),
                        (vat, resolvers))

        # Make the actual connection.
        ruv.tcpConnect(stream, self.host, self.port, connectStreamCB)

        # Return the promises.
        return [source, sink]

    def connect(self):
        vat = currentVat.get()
        stream = ruv.alloc_tcp(vat.uv_loop)

        fount, fountResolver = makePromise()
        drain, drainResolver = makePromise()

        # Ugh, the hax.
        resolvers = wrapList([fountResolver, drainResolver])
        ruv.stashStream(ruv.rffi.cast(ruv.stream_tp, stream),
                        (vat, resolvers))

        # Make the actual connection.
        ruv.tcpConnect(stream, self.host, self.port, connectCB)

        # Return the promises.
        return [fount, drain]

    def connectStream(self):
        """
        Connect this endpoint, returning a `[source, sink]` pair.of vows.
        """

        vat = currentVat.get()
        stream = ruv.alloc_tcp(vat.uv_loop)

        source, sourceResolver = makePromise()
        sink, sinkResolver = makePromise()

        # Ugh, the hax.
        resolvers = wrapList([sourceResolver, sinkResolver])
        ruv.stashStream(ruv.rffi.cast(ruv.stream_tp, stream),
                        (vat, resolvers))
        vat.enqueueEvent(ConnectStreamIOEvent(
            vat, stream, self.host, self.port, self.inet_type))
        # Return the promises.
        return [source, sink]

 def uncall(self):
     return wrapList([self._test, self._then, self._otherwise])