-----------------------------------------------------------------------------
-- |
-- Module      :  Language.C.Data.RList
-- Copyright   :  (c) [2007..2008] Duncan Coutts, Benedikt Huber
-- License     :  BSD-style
-- Maintainer  : benedikt.huber@gmail.com
-- Stability   : experimental
-- Portability : ghc
--
-- Due to the way the grammar is constructed we very often have to build lists
-- in reverse. To make sure we do this consistently and correctly we have a
-- newtype to wrap the reversed style of list:
-----------------------------------------------------------------------------
module Language.C.Data.RList (
    RList,Reversed(..),
    empty,singleton,snoc,rappend,appendr,rappendr,rmap,reverse,
    viewr,
)
where
import Prelude hiding (reverse)
import qualified Data.List as List

newtype Reversed a = Reversed a
type RList a = Reversed [a]
empty :: Reversed [a]
empty :: forall a. Reversed [a]
empty = forall a. a -> Reversed a
Reversed []

singleton :: a -> Reversed [a]
singleton :: forall a. a -> Reversed [a]
singleton a
x = forall a. a -> Reversed a
Reversed [a
x]

snoc :: Reversed [a] -> a -> Reversed [a]
snoc :: forall a. Reversed [a] -> a -> Reversed [a]
snoc (Reversed [a]
xs) a
x = forall a. a -> Reversed a
Reversed (a
x forall a. a -> [a] -> [a]
: [a]
xs)
infixl 5 `snoc`

rappend :: Reversed [a] -> [a] -> Reversed [a]
rappend :: forall a. Reversed [a] -> [a] -> Reversed [a]
rappend (Reversed [a]
xs) [a]
ys = forall a. a -> Reversed a
Reversed (forall a. [a] -> [a]
List.reverse [a]
ys forall a. [a] -> [a] -> [a]
++ [a]
xs)

appendr :: [a] -> Reversed [a] -> Reversed [a]
appendr :: forall a. [a] -> Reversed [a] -> Reversed [a]
appendr [a]
xs (Reversed [a]
ys) = forall a. a -> Reversed a
Reversed ([a]
ys forall a. [a] -> [a] -> [a]
++ forall a. [a] -> [a]
List.reverse [a]
xs)

rappendr :: Reversed [a] -> Reversed [a] -> Reversed [a]
rappendr :: forall a. Reversed [a] -> Reversed [a] -> Reversed [a]
rappendr (Reversed [a]
xs) (Reversed [a]
ys) = forall a. a -> Reversed a
Reversed ([a]
ys forall a. [a] -> [a] -> [a]
++ [a]
xs)

rmap :: (a -> b) -> Reversed [a] -> Reversed [b]
rmap :: forall a b. (a -> b) -> Reversed [a] -> Reversed [b]
rmap a -> b
f (Reversed [a]
xs) = forall a. a -> Reversed a
Reversed (forall a b. (a -> b) -> [a] -> [b]
map a -> b
f [a]
xs)

reverse :: Reversed [a] -> [a]
reverse :: forall a. Reversed [a] -> [a]
reverse (Reversed [a]
xs) = forall a. [a] -> [a]
List.reverse [a]
xs

viewr :: Reversed [a] -> (Reversed [a] , a)
viewr :: forall a. Reversed [a] -> (Reversed [a], a)
viewr (Reversed []) = forall a. HasCallStack => [Char] -> a
error [Char]
"viewr: empty RList"
viewr (Reversed (a
x:[a]
xs)) = (forall a. a -> Reversed a
Reversed [a]
xs, a
x)