module Language.Fay.Stdlib (($) ,(++) ,(.) ,Ordering(..) ,any ,compare ,concat ,const ,elem ,enumFrom ,enumFromTo ,fromIntegral ,filter ,find ,flip ,foldl ,foldr ,forM_ ,fst ,length ,mod ,insertBy ,intercalate ,intersperse ,lookup ,map ,mapM_ ,maybe ,not ,nub ,null ,otherwise ,prependToAll ,reverse ,snd ,sort ,sortBy ,when ,zip ,zipWith ,max ,min) where import Language.Fay.FFI import Prelude (Bool(..), Double, Eq(..), Int, Maybe(..), Monad(..), Num(..), Ord((>), (<)), (||)) -- START snd :: (t, t1) -> t1 snd (_,x) = x fst :: (t, t1) -> t fst (x,_) = x find :: (a -> Bool) -> [a] -> Maybe a find p (x:xs) = if p x then Just x else find p xs find _ [] = Nothing any :: (t -> Bool) -> [t] -> Bool any p (x:xs) = if p x then True else any p xs any _ [] = False filter :: (a -> Bool) -> [a] -> [a] filter p (x:xs) = if p x then x : filter p xs else filter p xs filter _ [] = [] not :: Bool -> Bool not p = if p then False else True null :: [t] -> Bool null [] = True null _ = False map :: (a -> b) -> [a] -> [b] map _ [] = [] map f (x:xs) = f x : map f xs nub :: Eq a => [a] -> [a] nub ls = nub' ls [] nub' :: Eq a => [a] -> [a] -> [a] nub' [] _ = [] nub' (x:xs) ls = if elem x ls then nub' xs ls else x : nub' xs (x : ls) elem :: Eq a => a -> [a] -> Bool elem x (y:ys) = x == y || elem x ys elem _ [] = False data Ordering = GT | LT | EQ sort :: Ord a => [a] -> [a] sort = sortBy compare compare :: Ord a => a -> a -> Ordering compare x y = if x > y then GT else if x < y then LT else EQ sortBy :: (t -> t -> Ordering) -> [t] -> [t] sortBy cmp = foldr (insertBy cmp) [] insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a] insertBy _ x [] = [x] insertBy cmp x ys = case ys of [] -> [x] y:ys' -> case cmp x y of GT -> y : insertBy cmp x ys' _ -> x : ys when :: Monad m => Bool -> m a -> m () when p m = if p then m >> return () else return () enumFrom :: Num a => a -> [a] enumFrom i = i : enumFrom (i + 1) enumFromTo :: (Eq t, Num t) => t -> t -> [t] enumFromTo i n = if i == n then [i] else i : enumFromTo (i + 1) n zipWith :: (a->b->c) -> [a]->[b]->[c] zipWith f (a:as) (b:bs) = f a b : zipWith f as bs zipWith _ _ _ = [] zip :: [a] -> [b] -> [(a,b)] zip (a:as) (b:bs) = (a,b) : zip as bs zip _ _ = [] flip :: (t1 -> t2 -> t) -> t2 -> t1 -> t flip f x y = f y x maybe :: t -> (t1 -> t) -> Maybe t1 -> t maybe m _ Nothing = m maybe _ f (Just x) = f x (.) :: (t1 -> t) -> (t2 -> t1) -> t2 -> t (f . g) x = f (g x) (++) :: [a] -> [a] -> [a] x ++ y = conc x y infixr 5 ++ ($) :: (t1 -> t) -> t1 -> t f $ x = f x infixr 0 $ -- | Append two lists. conc :: [a] -> [a] -> [a] conc (x:xs) ys = x : conc xs ys conc [] ys = ys concat :: [[a]] -> [a] concat = foldr conc [] foldr :: (t -> t1 -> t1) -> t1 -> [t] -> t1 foldr _ z [] = z foldr f z (x:xs) = f x (foldr f z xs) foldl :: (t1 -> t -> t1) -> t1 -> [t] -> t1 foldl _ z [] = z foldl f z (x:xs) = foldl f (f z x) xs lookup :: Eq a1 => a1 -> [(a1, a)] -> Maybe a lookup _key [] = Nothing lookup key ((x,y):xys) = if key == x then Just y else lookup key xys intersperse :: a -> [a] -> [a] intersperse _ [] = [] intersperse sep (x:xs) = x : prependToAll sep xs prependToAll :: a -> [a] -> [a] prependToAll _ [] = [] prependToAll sep (x:xs) = sep : x : prependToAll sep xs intercalate :: [a] -> [[a]] -> [a] intercalate xs xss = concat (intersperse xs xss) forM_ :: Monad m => [t] -> (t -> m a) -> m () forM_ (x:xs) m = m x >> forM_ xs m forM_ [] _ = return () mapM_ :: Monad m => (a -> m b) -> [a] -> m () mapM_ m (x:xs) = m x >> mapM_ m xs mapM_ _ [] = return () const :: a -> b -> a const a _ = a length :: [a] -> Int length (_:xs) = 1 + length xs length [] = 0 mod :: Double -> Double -> Double mod = ffi "%1 %% %2" min :: Double -> Double -> Double min = ffi "Math.min(%1,%2)" max :: Double -> Double -> Double max = ffi "Math.max(%1,%2)" fromIntegral :: Int -> Double fromIntegral = ffi "%1" otherwise :: Bool otherwise = True reverse :: [a] -> [a] reverse (x:xs) = reverse xs ++ [x] reverse [] = []