Hoogle Search

Within LTS Haskell 24.32 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. FieldSortDescending :: FieldSortType

   xlsx	Codec.Xlsx.Types.PivotTable

   No documentation available.

2. FieldSortManual :: FieldSortType

   xlsx	Codec.Xlsx.Types.PivotTable

   No documentation available.

3. data FieldSortType

   xlsx	Codec.Xlsx.Types.PivotTable

   Sort orders that can be applied to fields in a PivotTable See 18.18.28 "ST_FieldSortType (Field Sort Type)" (p. 2454)

4. _pfiSortType :: PivotFieldInfo -> FieldSortType

   xlsx	Codec.Xlsx.Types.PivotTable

   No documentation available.

5. _sprSort :: SheetProtection -> Bool

   xlsx	Codec.Xlsx.Types.Protection

   sorting should not be allowed when the sheet is protected

6. sprSort :: Lens' SheetProtection Bool

   xlsx	Codec.Xlsx.Types.Protection

   No documentation available.

7. topSort :: Ord a => AdjacencyMap a -> [a]

   algebraic-graphs	Algebra.Graph.Acyclic.AdjacencyMap

   Compute a topological sort of an acyclic graph.

   topSort empty                          == []
   topSort (vertex x)                     == [x]
   topSort (shrink $ 1 * (2 + 4) + 3 * 4) == [1, 2, 3, 4]
   topSort (join x y)                     == fmap Left (topSort x) ++ fmap Right (topSort y)
   Right . topSort                        == topSort . fromAcyclic
   

8. isTopSortOf :: [Int] -> AdjacencyIntMap -> Bool

   algebraic-graphs	Algebra.Graph.AdjacencyIntMap.Algorithm

   Check if a given list of vertices is a correct topological sort of a graph.

   isTopSortOf [3,1,2] (1 * 2 + 3 * 1) == True
   isTopSortOf [1,2,3] (1 * 2 + 3 * 1) == False
   isTopSortOf []      (1 * 2 + 3 * 1) == False
   isTopSortOf []      empty           == True
   isTopSortOf [x]     (vertex x)      == True
   isTopSortOf [x]     (edge x x)      == False
   

9. topSort :: AdjacencyIntMap -> Either (Cycle Int) [Int]

   algebraic-graphs	Algebra.Graph.AdjacencyIntMap.Algorithm

   Compute a topological sort of a graph or discover a cycle. Vertices are explored in the decreasing order according to their Ord instance. This gives the lexicographically smallest topological ordering in the case of success. In the case of failure, the cycle is characterized by being the lexicographically smallest up to rotation with respect to Ord (Dual Int) in the first connected component of the graph containing a cycle, where the connected components are ordered by their largest vertex with respect to Ord a. Complexity: O((n + m) * min(n,W)) time and O(n) space.

   topSort (1 * 2 + 3 * 1)                    == Right [3,1,2]
   topSort (path [1..5])                      == Right [1..5]
   topSort (3 * (1 * 4 + 2 * 5))              == Right [3,1,2,4,5]
   topSort (1 * 2 + 2 * 1)                    == Left (2 :| [1])
   topSort (path [5,4..1] + edge 2 4)         == Left (4 :| [3,2])
   topSort (circuit [1..3])                   == Left (3 :| [1,2])
   topSort (circuit [1..3] + circuit [3,2,1]) == Left (3 :| [2])
   topSort (1 * 2 + (5 + 2) * 1 + 3 * 4 * 3)  == Left (1 :| [2])
   fmap (flip isTopSortOf x) (topSort x)      /= Right False
   topSort . vertices                         == Right . nub . sort
   

10. isTopSortOf :: Ord a => [a] -> AdjacencyMap a -> Bool

    algebraic-graphs	Algebra.Graph.AdjacencyMap.Algorithm

    Check if a given list of vertices is a correct topological sort of a graph.

    isTopSortOf [3,1,2] (1 * 2 + 3 * 1) == True
    isTopSortOf [1,2,3] (1 * 2 + 3 * 1) == False
    isTopSortOf []      (1 * 2 + 3 * 1) == False
    isTopSortOf []      empty           == True
    isTopSortOf [x]     (vertex x)      == True
    isTopSortOf [x]     (edge x x)      == False
    

Page 131 of many | Previous | Next