) -> Union[data.Posting, Sequence[data.Posting]]:

        if isinstance(index, slice):

            raise NotImplementedError("RelatedPostings[slice]")

        else:

            return self._postings[index]

    def __len__(self) -> int:

        return len(self._postings)

    def add(self, post: data.Posting) -> None:

        self._postings.append(post)

    def iter_with_balance(self) -> Iterable[Tuple[data.Posting, Balance]]:

        balance = MutableBalance()

        for post in self:

            balance.add_amount(post.units)

            yield post, balance

    def balance(self) -> Balance:

        for _, balance in self.iter_with_balance():

            pass

        try:

            return balance

        except NameError:

def test_balance_credit_card(credit_card_cycle):

    related = core.RelatedPostings()

    assert related.balance() == testutil.balance_map()

    expected = Decimal()

    for txn in credit_card_cycle:

        post = txn.postings[0]

        expected += post.units.number

        related.add(post)

        assert related.balance() == testutil.balance_map(USD=expected)

    assert expected == 0

def check_iter_with_balance(entries):

    expect_posts = [txn.postings[0] for txn in entries]

    expect_balances = []

    balance_tally = collections.defaultdict(Decimal)

    related = core.RelatedPostings()

    for post in expect_posts:

        number, currency = post.units

        balance_tally[currency] += number

        expect_balances.append(testutil.balance_map(balance_tally.items()))

        related.add(post)

    for (post, balance), exp_post, exp_balance in zip(

            related.iter_with_balance(),