As discussed, I plan to add pattern synonyms Empty, :<|, and :|> to
make working with sequences more convenient. The remaining question is
what types they should have. From the Data.Sequence standpoint, the
best thing would be to make them work *only* for Seq, so that the Seq
type will be inferred from their use. However, modules using multiple
sequence types might benefit from more flexibility, via ad hoc
classes. This, however, requires that something else pin down the
sequence type, and could cause more confusing error messages. I'm
leaning toward the simple, monomorphic approach, but I figured I
should ask here in case anyone disagrees strongly.
{-# LANGUAGE PatternSynonyms, ScopedTypeVariables,
MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances,
ViewPatterns #-}
module Patt where
import Data.Sequence as S
import Prelude as P
class FastFront x xs | xs -> x where
fcons :: x -> xs -> xs
fviewl :: xs -> ViewLS x xs
class FastRear x xs | xs -> x where
fsnoc :: xs -> x -> xs
fviewr :: xs -> ViewRS x xs
class FastEmpty x xs | xs -> x where
fMkEmpty :: xs
fIsEmpty :: xs -> Bool
instance FastFront a (Seq a) where
fcons = (<|)
fviewl xs = case viewl xs of
EmptyL -> EmptyLS
y :< ys -> ConsLS y ys
instance FastFront a [a] where
fcons = (:)
fviewl [] = EmptyLS
fviewl (x : xs) = ConsLS x xs
instance FastRear a (Seq a) where
fsnoc = (|>)
fviewr xs = case viewr xs of
EmptyR -> EmptyRS
ys :> y -> SnocRS ys y
instance FastEmpty a (Seq a) where
fMkEmpty = mempty
fIsEmpty = S.null
instance FastEmpty a [a] where
fMkEmpty = []
fIsEmpty = P.null
data ViewLS x xs = EmptyLS | ConsLS x xs
data ViewRS x xs = EmptyRS | SnocRS xs x
pattern x :<| xs <- (fviewl -> ConsLS x xs) where
x :<| xs = fcons x xs
pattern xs :|> x <- (fviewr -> SnocRS xs x) where
xs :|> x = fsnoc xs x
pattern Empty <- (fIsEmpty -> True) where
Empty = fMkEmpty
