base -System.Console.GetOpt  

freely intersperse options and non-options

permute :: Stream s Identity tok => StreamPermParser s st a -> Parsec s st a

parsec -Text.Parsec.Perm  Text.ParserCombinators.Parsec.Perm  

The parser permute perm parses a permutation of parser described by perm. For example, suppose we want to parse a permutation of: an optional string of a's, the character b and an optional c. This can be described by:

 test  = permute (tuple <$?> ("",many1 (char 'a'))
                        <||> char 'b' 
                        <|?> ('_',char 'c'))
       where
         tuple a b c  = (a,b,c)
permute :: Alternative m => Permutation m a -> m a

parsers -Text.Parser.Permutation  

The parser permute perm parses a permutation of parser described by perm. For example, suppose we want to parse a permutation of: an optional string of a's, the character b and an optional c. This can be described by:

 test  = permute (tuple <$?> ("",some (char 'a'))
                        <||> char 'b'
                        <|?> ('_',char 'c'))
       where
         tuple a b c  = (a,b,c)
permute :: (Shape ix, Shape ix', Elt a)=> (Exp a -> Exp a -> Exp a)-> Acc (Array ix' a)-> (Exp ix -> Exp ix')-> Acc (Array ix a)-> Acc (Array ix' a)

accelerate -Data.Array.Accelerate  

Forward permutation specified by an index mapping. The result array is initialised with the given defaults and any further values that are permuted into the result array are added to the current value using the given combination function.

The combination function must be associative and commutative. Elements that are mapped to the magic value ignore by the permutation function are dropped.

permute :: Elt a=> Array a-> Array Int-> Array a

dph-prim-interface -Data.Array.Parallel.Unlifted  

O(length result). Forwards permutation of array elements.

permutation -Data.Permute  

Construct an identity permutation of the given size.

permute :: Elt a=> Array a-> Array Int-> Array a

dph-prim-par -Data.Array.Parallel.Unlifted  

O(length result). Forwards permutation of array elements.

permute :: Elt a=> Array a-> Array Int-> Array a

dph-prim-seq -Data.Array.Parallel.Unlifted  

O(length result). Forwards permutation of array elements.

permute :: Permutation -> Array Int a -> Array Int a

combinat -Math.Combinat.Permutations  

Action of a permutation on a set. If our permutation is encoded with the sequence [p1,p2,...,pn], then in the two-line notation we have

( 1  2  3  ... n  )
( p1 p2 p3 ... pn )

We adopt the convention that permutations act on the left (as opposed to Knuth, where they act on the right). Thus,

permute pi1 (permute pi2 set) == permute (pi1 `multiply` pi2) set

The second argument should be an array with bounds (1,n). The function checks the array bounds.

permute :: Stream s Identity tok => StreamPermParser s st a -> Parsec s st a

parsec3 -Text.Parsec.Perm  

The parser permute perm parses a permutation of parser described by perm. For example, suppose we want to parse a permutation of: an optional string of a's, the character b and an optional c. This can be described by:

 test  = permute (tuple <$?> ("",many1 (char 'a'))
                        <||> char 'b' 
                        <|?> ('_',char 'c'))
       where
         tuple a b c  = (a,b,c)
permute :: Permutation -> Vector Double -> Vector Double

hmatrix-gsl-stats -Numeric.GSL.Permutation  

apply the permutation to a vector

permute :: PermParser tok st a -> GenParser tok st a

parsec2 -Text.ParserCombinators.Parsec.Perm  

The parser permute perm parses a permutation of parser described by perm. For example, suppose we want to parse a permutation of: an optional string of a's, the character b and an optional c. This can be described by:

  test  = permute (tuple <$?> ("",many1 (char 'a'))
                         <||> char 'b'
                         <|?> ('_',char 'c'))
        where
          tuple a b c  = (a,b,c)
permute :: (Data Length -> Data Index -> Data Index) -> Vector DIM1 a -> Vector DIM1 a

feldspar-language -Feldspar.Repa  

Permute a vector

permute :: Syntax a => (Data Length -> Data Index -> Data Index) -> Vector a -> Vector a

permutation -Data.Permute  

The immutable permutation data type. Internally, a permutation of size n is stored as an 0-based array of n Ints. The permutation represents a reordering of the integers 0, ..., (n-1). The permutation sents the value p[i] to i.

Generalised permutation parser combinator
permute :: (Alternative p, Monad p) => PermParser p a -> p a

permute -Text.ParserCombinators.Perm  

The parser permute perm parses a permutation of parser described by perm. For example, suppose we want to parse a permutation of: an optional string of a's, the character b and an optional c. This can be described by:

  test  = permute (tuple <$?> ("",many1 (char 'a'))
                         <||> char 'b' 
                         <|?> ('_',char 'c'))
        where
          tuple a b c  = (a,b,c)