content: -- |
  --   Module      :  Data.Edison.Sym
  --   Copyright   :  Copyright (c) 2006 Robert Dockins
  --   License     :  MIT; see COPYRIGHT file for terms and conditions
  --
  --   Maintainer  :  robdockins AT fastmail DOT fm
  --   Stability   :  stable
  --   Portability :  GHC, Hugs (MPTC and FD)
  --
  --   This module introduces a number of infix symbols which are aliases
  --   for some of the operations in the sequence and set abstractions.
  --   For several, the argument orders are reversed to more closely
  --   match usual symbolic usage.
  --
  --   The symbols are intended to evoke the the operations they
  --   represent.  Unfortunately, ASCII is pretty limited, and Haskell 98
  --   only allocates a few symbols to the operator lexical class.
  --   Thus, some of the operators are less evocative than one would
  --   like.  A future version of Edison may introduce unicode operators, which
  --   will allow a wider range of operations to be represented symbolicly.
  --
  --   Unlike most of the modules in Edison, this module is intended to be
  --   imported unqualified.  However, the definition of @(++)@ will conflict
  --   with the Prelude definition.  Either this definition or the Prelude
  --   definition will need to be imported @hiding ( (++) )@.  This definition
  --   subsumes the Prelude definition, and can be safely used in place of it.
  
  module Data.Edison.Sym where
  
  import qualified Prelude as P
  import qualified Data.Edison.Seq as S
  import qualified Data.Edison.Coll as C
  import qualified Data.Edison.Coll as A
  
  -- pull in the Sequence instance for lists to make sure (++)
  -- works as advertised
  import qualified Data.Edison.Seq.ListSeq
  
  
  -- | Left (front) cons on a sequence.  The new element appears on the left.
  --   Identical to 'S.lcons'.
  (<|) :: S.Sequence seq => a -> seq a -> seq a
  (<|) = S.lcons
  
  -- | Right (rear) cons on a sequence.  The new element appears on the right.
  --   Identical to 'S.rcons' with reversed arguments.
  (|>) :: S.Sequence seq => seq a -> a -> seq a
  (|>) = P.flip S.rcons
  
  -- | Append two sequences.  Identical to 'S.append'.  Subsumes the Prelude
  --   definition.
  (++) :: S.Sequence seq => seq a -> seq a -> seq a
  (++) = S.append
  
  -- | Lookup an element in a sequence.  Identical to 'S.lookup' with
  --   reversed arguments.
  (!) :: S.Sequence seq => seq a -> P.Int -> a
  (!) = P.flip S.lookup
  
  -- | Subset test operation.  Identical to 'C.subset'.
  (|=) :: C.SetX set a => set -> set -> P.Bool
  (|=) = C.subset
  
  -- | Set difference.  Identical to 'C.difference'.
  (\\) :: C.SetX set a => set -> set -> set
  (\\) = C.difference
  
  -- | Set intersection.  Identical to 'C.intersection'.
  (/\) :: C.SetX set a => set -> set -> set
  (/\) = C.intersection
  
  -- | Set union.  Identical to 'C.union'.
  (\/) :: C.SetX set a => set -> set -> set
  (\/) = C.union
  