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)
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 :: 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)

parco - Text.Parco.Perm  

The parser permute perm parses a permutation of parsers 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 :: 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)

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 :: 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 :: v s -> v s -> v s Class Method

scan-vector-machine - Control.Parallel.ScanVectorMachine.ScanVectorMachine  

Permutation: permute v1 v2 returns a vector v3 where v3[v2[i]] = v1[i] for all i. Both vectors must be the same length and the elements of v2 must all be distinct, non-negative, and less than the lengths of the vectors.

permute :: (Data Length -> Data Index -> Data Index) -> Vector a -> Vector a
permute :: (Data Length -> Data Index -> Data Index) -> Vector DIM1 a -> Vector DIM1 a

feldspar-language - Feldspar.Repa  

Permute a vector

permute :: (a -> m (Maybe b)) -> [a] -> m (Maybe [b])

xml-enumerator-combinators - Text.XML.Enumerator.Combinators.General  

Permute all parsers until none return Just.

permute :: (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.

permutation - Data.Permute  

Construct an identity permutation of the given size.

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

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

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

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

Generalised permutation parser combinator

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

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