base - System.Console.GetOpt  

freely intersperse options and non-options

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)

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

dph-prim-interface - 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.

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

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

permutation - Data.Permute  

Construct an identity permutation of the given size.

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)

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

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

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)

parsec - Text.Parsec.Perm  

The type StreamPermParser s st a denotes a permutation parser that, when converted by the permute function, parses s streams with user state st and returns a value of type a on success.

Normally, a permutation parser is first build with special operators like (<||>) and than transformed into a normal parser using permute.

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