swap -package:streamly-core

swap :: (a, b) -> (b, a)
base Data.Tuple, extra Data.Tuple.Extra, base-compat Data.Tuple.Compat, protolude Protolude, relude Relude.Container.Reexport, base-prelude BasePrelude, classy-prelude ClassyPrelude, basic-prelude CorePrelude, ihaskell IHaskellPrelude, base-compat-batteries Data.Tuple.Compat, foundation Foundation, Agda Agda.Utils.Tuple, ghc-internal GHC.Internal.Data.Tuple, rebase Rebase.Prelude
Swap the components of a pair.
swap :: (HasCallStack, PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m ()
vector Data.Vector.Generic.Mutable
Swap the elements at the given positions.
swap :: PrimMonad m => MVector (PrimState m) a -> Int -> Int -> m ()
vector Data.Vector.Mutable Data.Vector.Strict.Mutable
Swap the elements at the given positions.
swap :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> Int -> m ()
vector Data.Vector.Primitive.Mutable
Swap the elements at the given positions.
swap :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> Int -> m ()
vector Data.Vector.Storable.Mutable
Swap the elements at the given positions.
swap :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> Int -> m ()
vector Data.Vector.Unboxed.Mutable
Swap the elements at the given positions.
swap :: Pair a -> Pair a
ghc GHC.Data.Pair, ghc-lib-parser GHC.Data.Pair
swap :: Either a b -> Either b a
utility-ht Data.Either.HT
swap :: (a, b) -> (b, a)
utility-ht Data.Tuple.HT Data.Tuple.Lazy Data.Tuple.Strict, hxt Text.XML.HXT.DOM.Util
swap :: Pair a b -> Pair b a
strict Data.Strict.Tuple
Analogous to swap from Data.Tuple
swap :: (Contiguous arr, Element arr a, PrimMonad m) => Mutable arr (PrimState m) a -> Int -> Int -> m ()
contiguous Data.Primitive.Contiguous
Swap the elements of the mutable array at the given indices.
swap :: forall v n m a . (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> Finite n -> Finite n -> m ()
vector-sized Data.Vector.Generic.Mutable.Sized
O(1) Swap the elements at given type-safe positions using Finites.
swap :: forall n m a . PrimMonad m => MVector n (PrimState m) a -> Finite n -> Finite n -> m ()
vector-sized Data.Vector.Mutable.Sized
O(1) Swap the elements at the given type-safe positions using Finites.
swap :: forall n m a . (PrimMonad m, Prim a) => MVector n (PrimState m) a -> Finite n -> Finite n -> m ()
vector-sized Data.Vector.Primitive.Mutable.Sized
O(1) Swap the elements at the given type-safe positions using Finites.
swap :: forall n m a . (PrimMonad m, Storable a) => MVector n (PrimState m) a -> Finite n -> Finite n -> m ()
vector-sized Data.Vector.Storable.Mutable.Sized
O(1) Swap the elements at the given type-safe positions using Finites.
swap :: forall n m a . (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Finite n -> Finite n -> m ()
vector-sized Data.Vector.Unboxed.Mutable.Sized
O(1) Swap the elements at the given type-safe positions using Finites.
swap :: AdjacencyMap a b -> AdjacencyMap b a
algebraic-graphs Algebra.Graph.Bipartite.AdjacencyMap
Swap the parts of a given graph. Complexity: O(1) time and memory. 
swap empty            == empty
swap . leftVertex     == rightVertex
swap (vertices xs ys) == vertices ys xs
swap (edge x y)       == edge y x
swap . edges          == edges . map Data.Tuple.swap
swap . swap           == id
swap :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> ix -> m (Maybe (e, e))
massiv Data.Massiv.Array.Mutable
O(1) - Same as swapM, but instead of throwing an exception returns Nothing when either one of the indices is out of bounds and Just elements under those indices otherwise.
swap :: (SymVal a, SymVal b) => STuple a b -> STuple b a
sbv Data.SBV.Tuple
Swap the elements of a 2-tuple
swap :: SWord8 -> SWord8 -> S -> S
sbv Documentation.SBV.Examples.Crypto.RC4
Swaps two elements in the RC4 array.
swap :: (Indexed sh, Storable a) => Index sh -> Index sh -> Vector sh a -> Vector sh a
lapack Numeric.LAPACK.Vector
QC.forAll (QC.choose (1,100)) $ \dim ->
QC.forAll (QC.choose (0, dim-1)) $ \i ->
QC.forAll (QC.choose (0, dim-1)) $ \j ->
Vector.unit (Shape.ZeroBased dim) i
==
(Vector.swap i j (Vector.unit (Shape.ZeroBased dim) j) :: Vector Number_)
swap :: T a -> T a
synthesizer-core Synthesizer.Frame.Stereo, sample-frame Sound.Frame.Stereo
swap :: Swap p => p a b -> p b a
assoc Data.Bifunctor.Swap
swap :: HasCallStack => Array a % 1 -> Int -> Int -> Array a
linear-base Simple.Quicksort
swap a i j exchanges the positions of values at i and j of a.
swap :: MonadMPD m => Position -> Position -> m ()
libmpd Network.MPD
Swap the positions of two songs.