module GLL.Types.Input (
  module GLL.Types.Input) where

import GLL.Types.Grammar
import qualified    Data.Array as A

type Input t      = (A.Array Int t, [t])
type RawParser t  = [t] -> [[t]]  -- input to list of prefixes

mkInput :: (Parseable t) => [t] -> Input t
mkInput :: forall t. Parseable t => [t] -> Input t
mkInput [t]
input = (forall i e. Ix i => (i, i) -> [e] -> Array i e
A.listArray (Int
0,Int
m) ([t]
inputforall a. [a] -> [a] -> [a]
++[forall a. Parseable a => a
eos]), [t]
input)
  where m :: Int
m = forall (t :: * -> *) a. Foldable t => t a -> Int
length [t]
input

inputLength :: Input t -> Int
inputLength :: forall t. Input t -> Int
inputLength = forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i e. Array i e -> (i, i)
A.bounds forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst

scanner_from_predicate :: (t -> Bool) -> RawParser t
scanner_from_predicate :: forall t. (t -> Bool) -> RawParser t
scanner_from_predicate t -> Bool
p (t
t:[t]
ts) | t -> Bool
p t
t = [[t
t]]
scanner_from_predicate t -> Bool
p [t]
_ = []

apply_scanner :: RawParser t -> Input t -> [[t]]
apply_scanner :: forall t. RawParser t -> Input t -> [[t]]
apply_scanner RawParser t
scanner (Array Int t
_,[t]
str) = RawParser t
scanner [t]
str

slice :: Input t -> Int -> Int -> [t]
slice :: forall t. Input t -> Int -> Int -> [t]
slice (Array Int t
arr, [t]
str) Int
l Int
r 
  | Int
lb forall a. Ord a => a -> a -> Bool
<= Int
l Bool -> Bool -> Bool
&& Int
r forall a. Ord a => a -> a -> Bool
<= Int
ub  = forall a b. (a -> b) -> [a] -> [b]
map (Array Int t
arr forall i e. Ix i => Array i e -> i -> e
A.!) [Int
l..Int
rforall a. Num a => a -> a -> a
-Int
1] 
  | Bool
otherwise           = []
  where (Int
lb,Int
ub) = forall i e. Array i e -> (i, i)
A.bounds Array Int t
arr

removePrefix :: Int -> Input t -> Input t
removePrefix :: forall t. Int -> Input t -> Input t
removePrefix Int
l (Array Int t
arr, [t]
str) = (Array Int t
arr, forall a. Int -> [a] -> [a]
drop Int
l [t]
str)