+ga_swap_second f =
+ ga_swap >>> ga_first f >>> ga_swap
+ -- implementation of ga_second for GArrowSwap
+ -- See also
+ -- http://haskell.org/haskellwiki/Class_system_extension_proposal
+ -- "Allowing superclass methods to be overridden in derived classes";
+ -- if we had this we could do a better job here
+
+
+
+------------------------------------------------------------------------
+-- Products, Coproducts, etc
+
+
+class (GArrow g (**) u,
+ GArrow g (<*>) v) =>
+ GArrowProd g (**) u (<*>) v where
+ ga_prod_copy :: g x (x<*>x)
+ ga_prod_drop :: g x v
+
+class (GArrow g (**) u,
+ GArrow g (<+>) v) =>
+ GArrowSum g (**) u v (<+>) where
+ ga_merge :: g (x<+>x) x
+ ga_never :: g v x
+
+
+
+
+
+------------------------------------------------------------------------
+-- Loop
+
+class GArrow g (**) u => GArrowLoop g (**) u where
+ ga_loopl :: g (x**z) (y**z) -> g x y
+ ga_loopr :: g (z**x) (z**y) -> g x y
+
+
+------------------------------------------------------------------------
+-- Literal. Note that ga_literal should never appear in (unflattened)
+-- Haskell programs, though the user may wish to write implementations
+-- of this function (I haven't yet found a way to enforce this
+-- restriction using exports)
+
+class GArrow g (**) u => GArrowLiteral g (**) u t r where
+ ga_literal :: t -> g u r
+
+
+
+
+------------------------------------------------------------------------
+-- Constant and Run, which are dual to each other
+
+class GArrow g (**) u => GArrowEval g (**) u r t where
+ ga_eval :: g u r -> t
+
+class GArrow g (**) u => GArrowConstant g (**) u t r where
+ ga_constant :: t -> g u r
+
+
+
+------------------------------------------------------------------------
+-- Reify and Reflect, which are "curried" versions
+
+-- If you have this for R the identity map on types, you're basically
+-- a Control.Arrow; you can also define essentially all the other
+-- methods of GArrow, GArrowDrop, GArrowCopy, etc in terms of this.
+class GArrow g (**) u => GArrowReify g (**) u x y r q where
+ ga_reify :: (x -> y) -> g r q
+
+class GArrow g (**) u => GArrowReflect g (**) u r q x y where
+ ga_reflect :: g r q -> (x -> y)
+