-
Notifications
You must be signed in to change notification settings - Fork 0
/
Container.purs
90 lines (83 loc) · 2.3 KB
/
Container.purs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
module Data.Container where
import Prelude
import Control.Plus (class Plus)
import Data.Tuple (Tuple)
import Data.Array as A
import Data.Foldable (class Foldable)
import Data.FunctorWithIndex (mapWithIndex)
import Data.List as L
import Data.Maybe (Maybe)
import Data.TraversableWithIndex (class TraversableWithIndex)
import Data.Unfoldable (replicate) as L'
class
( Foldable f
, Plus f
, Applicative f
, TraversableWithIndex Int f
) <= Container f where
take :: Int -> f ~> f
drop :: Int -> f ~> f
cons :: forall a. a -> f a -> f a
index :: forall a. f a -> Int -> Maybe a
reverse :: f ~> f
last :: forall a. f a -> Maybe a
dropWhile :: forall a. (a -> Boolean) -> f a -> f a
findIndex :: forall a. (a -> Boolean) -> f a -> Maybe Int
replicate :: forall a. Int -> a -> f a
insert :: forall a. Ord a => a -> f a -> f a
slice :: Int -> Int -> f ~> f
zip :: forall a b. f a -> f b -> f (Tuple a b)
zipWith :: forall a b c. (a -> b -> c) -> f a -> f b -> f c
snoc :: forall a. f a -> a -> f a
fromFoldable :: forall g. Foldable g => g ~> f
insertBy :: forall a. (a -> a -> Ordering) -> a -> f a -> f a
insertAt :: forall a. Int -> a -> f a -> Maybe (f a)
deleteAt :: forall a. Int -> f a -> Maybe (f a)
length :: forall a. f a -> Int
instance containerArray :: Container Array where
take = A.take
drop = A.drop
cons = A.cons
index = A.index
reverse = A.reverse
last = A.last
dropWhile = A.dropWhile
findIndex = A.findIndex
replicate = A.replicate
insert = A.insert
slice = A.slice
zip = A.zip
zipWith = A.zipWith
snoc = A.snoc
fromFoldable = A.fromFoldable
insertBy = A.insertBy
insertAt = A.insertAt
deleteAt = A.deleteAt
length = A.length
instance containerList :: Container L.List where
take = L.take
drop = L.drop
cons = L.Cons
index = L.index
reverse = L.reverse
last = L.last
dropWhile = L.dropWhile
findIndex = L.findIndex
replicate = L'.replicate
insert = L.insert
slice = L.slice
zip = L.zip
zipWith = L.zipWith
snoc = L.snoc
fromFoldable = L.fromFoldable
insertBy = L.insertBy
insertAt = L.insertAt
deleteAt = L.deleteAt
length = L.length
infixl 8 index as !!
set :: forall f a. Container f => f a -> Int -> a -> f a
set xs i x = mapWithIndex f xs where
f :: Int -> a -> a
f n a
| n == i = x
| otherwise = a