-- | Haskell implementations of hydra/lib/lists primitives

module Hydra.Lib.Lists where

import Hydra.Compute
import Hydra.Core
import Hydra.Graph
import qualified Hydra.Dsl.Terms as Terms

import qualified Data.List as L


apply :: [a -> b] -> [a] -> [b]
apply :: forall a b. [a -> b] -> [a] -> [b]
apply = [a -> b] -> [a] -> [b]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
(<*>)

at :: Int -> [a] -> a
at :: forall a. Int -> [a] -> a
at Int
i [a]
l = [a]
l [a] -> Int -> a
forall a. HasCallStack => [a] -> Int -> a
!! Int
i

bind :: [a] -> (a -> [b]) -> [b]
bind :: forall a b. [a] -> (a -> [b]) -> [b]
bind = [a] -> (a -> [b]) -> [b]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
(>>=)

concat :: [[a]] -> [a]
concat :: forall a. [[a]] -> [a]
concat = [[a]] -> [a]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
L.concat

concat2 :: [a] -> [a] -> [a]
concat2 :: forall a. [a] -> [a] -> [a]
concat2 [a]
l1 [a]
l2 = [a]
l1 [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ [a]
l2

cons :: a -> [a] -> [a]
cons :: forall a. a -> [a] -> [a]
cons = (:)

filter :: (a -> Bool) -> [a] -> [a]
filter :: forall a. (a -> Bool) -> [a] -> [a]
filter = (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
L.filter

foldl :: (b -> a -> b) -> b -> [a] -> b
foldl :: forall b a. (b -> a -> b) -> b -> [a] -> b
foldl = (b -> a -> b) -> b -> [a] -> b
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
L.foldl

head :: [a] -> a
head :: forall a. [a] -> a
head = [a] -> a
forall a. HasCallStack => [a] -> a
L.head

intercalate :: [a] -> [[a]] -> [a]
intercalate :: forall a. [a] -> [[a]] -> [a]
intercalate = [a] -> [[a]] -> [a]
forall a. [a] -> [[a]] -> [a]
L.intercalate

intersperse :: a -> [a] -> [a]
intersperse :: forall a. a -> [a] -> [a]
intersperse = a -> [a] -> [a]
forall a. a -> [a] -> [a]
L.intersperse

last :: [a] -> a
last :: forall a. [a] -> a
last = [a] -> a
forall a. HasCallStack => [a] -> a
L.last

length :: [a] -> Int
length :: forall a. [a] -> Int
length = [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
L.length

map :: (a -> b) -> [a] -> [b]
map :: forall a b. (a -> b) -> [a] -> [b]
map = (a -> b) -> [a] -> [b]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

nub :: Eq a => [a] -> [a]
nub :: forall a. Eq a => [a] -> [a]
nub = [a] -> [a]
forall a. Eq a => [a] -> [a]
L.nub

null :: [a] -> Bool
null :: forall a. [a] -> Bool
null = [a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
L.null

pure :: a -> [a]
pure :: forall a. a -> [a]
pure a
e = [a
e]

reverse :: [a] -> [a]
reverse :: forall a. [a] -> [a]
reverse = [a] -> [a]
forall a. [a] -> [a]
L.reverse

safeHead :: [a] -> Maybe a
safeHead :: forall a. [a] -> Maybe a
safeHead [] = Maybe a
forall a. Maybe a
Nothing
safeHead (a
x:[a]
_) = a -> Maybe a
forall a. a -> Maybe a
Just a
x

tail :: [a] -> [a]
tail :: forall a. [a] -> [a]
tail = [a] -> [a]
forall a. HasCallStack => [a] -> [a]
L.tail