Shorthands for all of the standard list operations lifted onto signals
Lifted version of isEmpty
Lifted version of length
Lifted version of reverse
Unary-lifted version of member
Binary-lifted version of member
Lifted version of head
Lifted version of filter
Lifted version of take
Lifted version of drop
Lifted version of repeat
Unary-lifted version of (::)
Unary-lifted version of append
and (++)
Lifted version of concat
Lifted version of intersperse
Lifted version of partition
Lifted version of unzip
Lifted version of map
sigMap = Signal.map << List.map
Binary-, ternary-, etc-, lifted versions of map2
, map3
, map4
, map5
Lifted version of filterMap
Lifted version of concatMap
Lifted version of indexedMap
sigIndexedMap = Signal.map << List.indexedMap
Lifted version of foldr
Lifted version of foldl
Lifted version of sum
Lifted version of product
Lifted version of maximum
Lifted version of minimum
Lifted version of all
Lifted version of any
Lifted version of scanl
Lifted version of sort
Lifted version of sortBy
Lifted version of sortWith
module List.Signal where
{-| Shorthands for all of the standard list operations lifted onto signals
# Basics
@docs sigIsEmpty, sigLength, sigReverse, sigMember, sig2Member
# Sub-lists
@docs sigHead, sigFilter, sigTake, sigDrop
# Putting Lists Together
@docs sigRepeat, sigCons, (:::), sigAppend, (+++), sigConcat, sigIntersperse
# Taking Lists Apart
@docs sigPartition, sigUnzip
# Mapping
@docs sigMap, sig2Map2, sig3Map3, sig4Map4, sig5Map5
# Special Maps
@docs sigFilterMap, sigConcatMap, sigIndexedMap
# Folding
@docs sigFoldr, sigFoldl
# Special Folds
@docs sigSum, sigProduct, sigMaximum, sigMinimum, sigAll, sigAny, sigScanl
# Sorting
@docs sigSort, sigSortBy, sigSortWith
-}
import Signal exposing (Signal)
import Signal
import List exposing (..)
{-| Lifted version of `isEmpty`
-}
sigIsEmpty : Signal (List a) -> Signal Bool
sigIsEmpty = Signal.map isEmpty
{-| Lifted version of `length`
-}
sigLength : Signal (List a) -> Signal Int
sigLength = Signal.map length
{-| Lifted version of `reverse`
-}
sigReverse : Signal (List a) -> Signal (List a)
sigReverse = Signal.map reverse
{-| Unary-lifted version of `member`
-}
sigMember : a -> Signal (List a) -> Signal Bool
sigMember x = Signal.map (member x)
{-| Binary-lifted version of `member`
-}
sig2Member : Signal a -> Signal (List a) -> Signal Bool
sig2Member = Signal.map2 member
{-| Lifted version of `map`
sigMap = Signal.map << List.map
-}
sigMap : (a -> b) -> Signal (List a) -> Signal (List b)
sigMap f = Signal.map (map f)
{-| Lifted version of `indexedMap`
sigIndexedMap = Signal.map << List.indexedMap
-}
sigIndexedMap : (Int -> a -> b) -> Signal (List a) -> Signal (List b)
sigIndexedMap f = Signal.map (indexedMap f)
{-| Lifted version of `foldl`
-}
sigFoldl : (a -> b -> b) -> b -> Signal (List a) -> Signal b
sigFoldl f x = Signal.map (foldl f x)
{-| Lifted version of `foldr`
-}
sigFoldr : (a -> b -> b) -> b -> Signal (List a) -> Signal b
sigFoldr f x = Signal.map (foldr f x)
{-| Lifted version of `scanl`
-}
sigScanl : (a -> b -> b) -> b -> Signal (List a) -> Signal (List b)
sigScanl f x = Signal.map (scanl f x)
{-| Lifted version of `filter`
-}
sigFilter : (a -> Bool) -> Signal (List a) -> Signal (List a)
sigFilter pred = Signal.map (filter pred)
{-| Lifted version of `filterMap`
-}
sigFilterMap : (a -> Maybe b) -> Signal (List a) -> Signal (List b)
sigFilterMap f = Signal.map (filterMap f)
{-| Lifted version of `all`
-}
sigAll : (a -> Bool) -> Signal (List a) -> Signal Bool
sigAll pred = Signal.map (all pred)
{-| Lifted version of `any`
-}
sigAny : (a -> Bool) -> Signal (List a) -> Signal Bool
sigAny pred = Signal.map (any pred)
{-| Unary-lifted version of `(::)`
-}
sigCons : a -> Signal (List a) -> Signal (List a)
sigCons x = Signal.map ((::) x)
{-| Binary-lifted version of `(::)`
-}
(:::) : Signal a -> Signal (List a) -> Signal (List a)
(:::) = Signal.map2 (::)
infixr 5 :::
{-| Lifted version of `head`
-}
sigHead : Signal (List a) -> Signal (Maybe a)
sigHead = Signal.map head
{-| Unary-lifted version of `append` and (++)
-}
sigAppend : List a -> Signal (List a) -> Signal (List a)
sigAppend xs = Signal.map (append xs)
{-| Binary-lifted version of `(++)`
-}
(+++) : Signal (List a) -> Signal (List a) -> Signal (List a)
(+++) = Signal.map2 (++)
infixr 5 +++
{-| Lifted version of `concat`
-}
sigConcat : Signal (List (List a)) -> Signal (List a)
sigConcat = Signal.map concat
{-| Lifted version of `concatMap`
-}
sigConcatMap : (a -> List b) -> Signal (List a) -> Signal (List b)
sigConcatMap f = Signal.map (concatMap f)
{-| Lifted version of `sum`
-}
sigSum : Signal (List number) -> Signal number
sigSum = Signal.map sum
{-| Lifted version of `product`
-}
sigProduct : Signal (List number) -> Signal number
sigProduct = Signal.map product
{-| Lifted version of `maximum`
-}
sigMaximum : Signal (List comparable) -> Signal (Maybe comparable)
sigMaximum = Signal.map maximum
{-| Lifted version of `minimum`
-}
sigMinimum : Signal (List comparable) -> Signal (Maybe comparable)
sigMinimum = Signal.map minimum
{-| Lifted version of `partition`
-}
sigPartition : (a -> Bool) -> Signal (List a) -> Signal (List a, List a)
sigPartition pred = Signal.map (partition pred)
{-| Binary-, ternary-, etc-, lifted versions of `map2`, `map3`, `map4`, `map5`
-}
sig2Map2 : (a -> b -> result) -> Signal (List a) -> Signal (List b) -> Signal (List result)
sig2Map2 f = Signal.map2 (map2 f)
sig3Map3 : (a -> b -> c -> result) -> Signal (List a) -> Signal (List b) -> Signal (List c) -> Signal (List result)
sig3Map3 f = Signal.map3 (map3 f)
sig4Map4 : (a -> b -> c -> d -> result) -> Signal (List a) -> Signal (List b) -> Signal (List c) -> Signal (List d) -> Signal (List result)
sig4Map4 f = Signal.map4 (map4 f)
sig5Map5 : (a -> b -> c -> d -> e -> result) -> Signal (List a) -> Signal (List b) -> Signal (List c) -> Signal (List d) -> Signal (List e) -> Signal (List result)
sig5Map5 f = Signal.map5 (map5 f)
{-| Lifted version of `unzip`
-}
sigUnzip : Signal (List (a,b)) -> Signal (List a, List b)
sigUnzip = Signal.map unzip
{-| Lifted version of `intersperse`
-}
sigIntersperse : a -> Signal (List a) -> Signal (List a)
sigIntersperse sep = Signal.map (intersperse sep)
{-| Lifted version of `take`
-}
sigTake : Int -> Signal (List a) -> Signal (List a)
sigTake k = Signal.map (take k)
{-| Lifted version of `drop`
-}
sigDrop : Int -> Signal (List a) -> Signal (List a)
sigDrop k = Signal.map (drop k)
{-| Lifted version of `repeat`
-}
sigRepeat : Int -> Signal a -> Signal (List a)
sigRepeat k = Signal.map (repeat k)
{-| Lifted version of `sort`
-}
sigSort : Signal (List comparable) -> Signal (List comparable)
sigSort = Signal.map sort
{-| Lifted version of `sortBy`
-}
sigSortBy : (a -> comparable) -> Signal (List a) -> Signal (List a)
sigSortBy f = Signal.map (sortBy f)
{-| Lifted version of `sortWith`
-}
sigSortWith : (a -> a -> Order) -> Signal (List a) -> Signal (List a)
sigSortWith f = Signal.map (sortWith f)