Yes. I have actually invented a method for creating parity algorithms that can help you to swap two edges and two corners.

For example, the parity algorithm:

r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2

can be written as:

r2 B2 :

*Set-up moves*
l F2 :

*Set-up moves*
F2 l' :

*Set-up moves*
(U2 l U2 r' U2 r U2 l') :

*The commutator [U2, l U2 r'].*
l F2 :

*Set-up moves*
(r) :

*The extra quarter turn*
F2 l' :

*Set-up moves*
B2 r2 :

*Set-up moves*
=

[r2 B2: [l F2: [F2 l' : [U2, l U2 r'] ] (r) ] ]
The inner portion,

F2 l' :

*Set-up moves*
(U2 l U2 r' U2 r U2 l') :

*The commutator [U2, l U2 r'].*
l F2 :

*Set-up moves*
(r) :

*The extra quarter turn*

is an "interior J-Perm".

=

F2 l'

(U2 l U2 r' U2 r U2 l')

l F2

(r)
=

[F2 l' : [U2, l U2 r'] ] (r)
So, if we translate to the outer slices, lo and behold we have a

**J-Perm**:

F2 L'

(U2 L U2 R' U2 R U2 L')

L F2

(R)
If we shift the following moves from the beginning to the end, we get a

**T-Perm**.

L U2 R' U2 R U2 L'

L F2

R

F2 L' U2 :

*The moves that were moved here from the beginning.*
Note that this is equal to:

U2 L F2

F2 L'

(U2 L U2 R' U2 R U2 L')

L F2

(R)

F2 L' U2
**Summary:**
Basically we have the form:

B

A

(commutator)

A'

(quarter turn)

B'

Where we:

1) Started with a commutator

2) Applied set-up moves A to it to bring all pieces involved into the R slice

3) Applied a quarter turn to solve back exactly half of the pieces in slice R

Note that steps 1-3 make what I call a "base" algorithm.
4) Applied set-up moves B to Manipulate the remaining messed up pieces like we wish.

This algorithm form is what I call a symmetrical algorithm, because it has a lot of symmetry.

I have an

entire thread about creating symmetrical parity algorithms for big cubes. You should check it out, as the idea is the same. I have not finished contributing to that thread yet, but what I have so far is definitely enough for people to get started on constructing common parity algorithms.

**Non-symmetrical algorithm**
Non-symmetrical algorithms can be composed of a base algorithm (like in symmetrical algorithms) + another algorithm piece. Non-symmetrical algorithms do not have symmetry. An example is a J-perm you may use as your primary algorithm:

R U2 R' U' R U2 L' U R' U' L
This algorithm can be written as:

R U set-up moves

(U R' U' R) commutator [U, R']

U' R' set-up moves

(R U' L' U R' U' L U) commutator [R, U' L' U]

(U') quarter turn

=

[R U: [U, R'] ] [R, U' L' U] (U')
Clearly, to be able to construct this algorithm by hand, we:

1) Start out with the commutator U R' U' R

2) Add set-up moves R U (and invert them of course)

3) Add a corner commutator

4) Add the extra quarter turn to solve back half of the pieces.

We can also shift this algorithm to get a "

**y-perm"**
R U2 L' U R' U' L

R U2 R' U'
Note that this is equal to

U R U2 R'

R U2 R' U' R U2 L' U R' U' L

R U2 R' U'