Stg.Prelude.List

Definitions found in Haskell's Data.List.

This module should be imported qualified to avoid clashes with standard Haskell definitions.

Documentation

nil :: Program

The empty list as a top-level closure.

nil : [a]

concat2 :: Program

Concatenate two lists. Haskell's (++).

concat2 : [a] -> [a] -> [a]

reverse :: Program

reverse a list.

reverse [1,2,3] = [3,2,1]

reverse : [a] -> [a]

foldl :: Program

Lazy left list fold. Provided mostly for seeing how it causes stack overflows.

foldl : (b -> a -> b) -> b -> [a] -> b

foldl' :: Program

Strict left list fold.

Careful: the STG only supports primitive and algebraic case scrutinees. As a result, you can only hand primitive or algebraic b values to this function or it will fail!

foldl' : (b -> a -> b) -> b -> [a] -> b

foldr :: Program

Right list fold.

foldr : (a -> b -> b) -> b -> [a] -> b

iterate :: Program

Build a list by repeatedly applying a function to an initial value.

iterate f x = [x, f x, f (f x), ...]

iterate : (a -> a) -> a -> [a]

cycle :: Program

Infinite list created by repeating an initial (non-empty) list.

cycle [x,y,z] = [x,y,z, x,y,z, x,y,z, ...]

cycle : [a] -> [a]

take :: Program

Take n elements form the beginning of a list.

take 3 [1..] = [1,2,3]

take : Int -> [a] -> [a]

filter :: Program

Keep only the elements for which a predicate holds.

filter even [1..] = [2, 4, 6, ...]

filter : (a -> Bool) -> [a] -> [a]

partition :: Program

Separate a list into parts that do and do not satisfy a predicate.

partition even [1..6] = ([2,4,6], [1,3,5])

partition : (a -> Bool) -> [a] -> ([a], [a])

repeat :: Program

Repeat a single element infinitely.

repeat 1 = [1, 1, 1, ...]

repeat : a -> [a]

replicate :: Program

Repeat a single element a number of times.

replicate 3 1 = [1, 1, 1]

replicate : Int -> a -> [a]

sort :: Program

Haskell's Prelude sort function at the time of implementing this. Not quite as pretty as the Haskell version, but functionally equivalent. :-)

This implementation is particularly efficient when the input contains runs of already sorted elements. For comparison, sorting [1..100] takes 6496 steps, whereas naiveSort requires 268082.

sort : [Int] -> [Int]

naiveSort :: Program

That Haskell sort function often misleadingly referred to as "quicksort".

naiveSort : [Int] -> [Int]

map :: Program

Apply a function to each element of a list.

map : (a -> b) -> [a] -> [b]

equals_List_Int :: Program

Equality of lists of integers.

equals_List_Int : [Int] -> [Int] -> Bool

length :: Program

Length of a list.

length : [a] -> Int

zip :: Program

Zip two lists into one. If one list is longer than the other ignore the exceeding elements.

zip [1,2,3,4,5] [10,20,30] ==> [(1,10),(2,20),(3,30)]

zip xs ys = zipWith Pair xs ys

zip : [a] -> [b] -> [(a,b)]

zipWith :: Program

Zip two lists into one using a user-specified combining function. If one list is longer than the other ignore the exceeding elements.

zipWith (+) [1,2,3,4,5] [10,20,30] ==> [11,22,33]

zipWith f xs ys = map f (zip xs ys)

zipWith : (a -> b -> c) -> [a] -> [b] -> [c]

forceSpine :: Program

Force the spine of a list.

forceSpine :: [a] -> [a]