content: {-# OPTIONS_HADDOCK prune #-}
  
  -- |
  -- Module      :  Data.List.Split
  -- Copyright   :  (c) Brent Yorgey, Louis Wasserman 2008-2012
  -- License     :  BSD-style (see LICENSE)
  -- Maintainer  :  Brent Yorgey <byorgey@gmail.com>
  -- Stability   :  stable
  -- Portability :  Haskell 2010
  --
  -- The "Data.List.Split" module contains a wide range of strategies
  -- for splitting lists with respect to some sort of delimiter, mostly
  -- implemented through a unified combinator interface.  The goal is to
  -- be flexible yet simple.  See below for usage, examples, and
  -- detailed documentation of all exported functions.  If you want to
  -- learn about the implementation, see "Data.List.Split.Internals".
  --
  -- A git repository containing the source (including a module with
  -- over 40 QuickCheck properties) can be found at
  -- <https://github.com/byorgey/split>.
  module Data.List.Split (
    -- * Getting started
    -- $started
  
    -- * Convenience functions
    -- $conv
    splitOn,
    splitOneOf,
    splitWhen,
    endBy,
    endByOneOf,
    wordsBy,
    linesBy,
  
    -- * Other splitting methods
    -- $other
    chunksOf,
    splitPlaces,
    splitPlacesBlanks,
    chop,
    divvy,
  
    -- * Splitting combinators
    -- $comb
    Splitter,
    defaultSplitter,
    split,
  
    -- ** Basic strategies
    -- $basic
    oneOf,
    onSublist,
    whenElt,
  
    -- ** Strategy transformers
    -- $transform
    dropDelims,
    keepDelimsL,
    keepDelimsR,
    condense,
    dropInitBlank,
    dropFinalBlank,
    dropInnerBlanks,
    mapSplitter,
  
    -- ** Derived combinators
    -- $derived
    dropBlanks,
    startsWith,
    startsWithOneOf,
    endsWith,
    endsWithOneOf,
    -- The following synonyms are deprecated, but
    -- still exported for now.  No documentation is
    -- generated for them via the 'OPTIONS_HADDOCK
    -- prune' pragma.
  
    sepBy,
    sepByOneOf,
    unintercalate,
    splitEvery,
    chunk,
  ) where
  
  import Data.List.Split.Internals
  
  -- $started
  -- To get started, you should take a look at the functions 'splitOn',
  -- 'splitOneOf', 'splitWhen', 'endBy', 'chunksOf', 'splitPlaces',
  -- and other functions listed in the next two sections.  These
  -- functions implement various common splitting operations, and one of
  -- them will probably do the job 90\% of the time.  For example:
  --
  -- >>> splitOn "x" "axbxc"
  -- ["a","b","c"]
  --
  -- >>> splitOn "x" "axbxcx"
  -- ["a","b","c",""]
  --
  -- >>> endBy ";" "foo;bar;baz;"
  -- ["foo","bar","baz"]
  --
  -- >>> splitWhen (<0) [1,3,-4,5,7,-9,0,2]
  -- [[1,3],[5,7],[0,2]]
  --
  -- >>> splitOneOf ";.," "foo,bar;baz.glurk"
  -- ["foo","bar","baz","glurk"]
  --
  -- >>> chunksOf 3 ['a'..'z']
  -- ["abc","def","ghi","jkl","mno","pqr","stu","vwx","yz"]
  --
  -- If you want more flexibility, however, you can use the combinator
  -- library in terms of which these functions are defined.  For more
  -- information, see the section labeled \"Splitting Combinators\".
  --
  -- The goal of this library is to be flexible yet simple.  It does not
  -- implement any particularly sophisticated list-splitting methods,
  -- nor is it tuned for speed.  If you find yourself wanting something
  -- more complicated or optimized, it probably means you should use a
  -- real parsing or regular expression library.
  
  -- $conv
  -- These functions implement some common splitting strategies.  Note
  -- that all of the functions in this section drop delimiters from the
  -- final output, since that is a more common use case.  If you wish to
  -- keep the delimiters somehow, see the \"Splitting Combinators\"
  -- section.
  
  -- $other
  -- Other useful splitting methods which are not implemented using the
  -- combinator framework.
  
  -- $comb
  -- The core of the library is the 'Splitter' type, which represents a
  -- particular list-splitting strategy.  All of the combinators revolve
  -- around constructing or transforming 'Splitter' objects; once a
  -- suitable 'Splitter' has been created, it can be run with the
  -- 'split' function.  For example:
  --
  -- >>> split (dropBlanks . condense $ whenElt (<0)) [1,2,4,-5,-6,4,9,-19,-30]
  -- [[1,2,4],[-5,-6],[4,9],[-19,-30]]
  
  -- $basic
  -- All these basic strategies have the same parameters as the
  -- 'defaultSplitter' except for the delimiter.
  
  -- $transform
  -- Functions for altering splitting strategy parameters.
  
  -- $derived
  -- Combinators which can be defined in terms of other combinators, but
  -- are provided for convenience.
  