relude- Safe, performant, user-friendly and lightweight Haskell Standard Library
Copyright(c) 2016 Stephen Diehl
(c) 2016-2018 Serokell
(c) 2018-2020 Kowainik
MaintainerKowainik <>
Safe HaskellUnsafe



⚠️ Warning ⚠️

This module contains unsafe partial functions. They are unavoidable sometimes, but we encourage you to use safer analogues:

Partial Total
head :: [a] -> a head :: NonEmpty a -> a
tail :: [a] -> [a] tail :: NonEmpty a -> [a]
read :: Read a => String -> a readMaybe :: Read a => String -> Maybe a
fromJust :: Maybe a -> a fromMaybe :: a -> Maybe a -> a

This module is intended to be imported qualified and it is not included in default prelude exports.

import qualified Relude.Unsafe as Unsafe

foo :: [a] -> a
foo = Unsafe.head

Unsafe list functions

head :: [a] -> a #

O(1). Extract the first element of a list, which must be non-empty.

tail :: [a] -> [a] #

O(1). Extract the elements after the head of a list, which must be non-empty.

last :: [a] -> a #

O(n). Extract the last element of a list, which must be finite and non-empty.

init :: [a] -> [a] #

O(n). Return all the elements of a list except the last one. The list must be non-empty.

(!!) :: [a] -> Int -> a infixl 9 #

List index (subscript) operator, starting from 0. It is an instance of the more general genericIndex, which takes an index of any integral type.

at :: Int -> [a] -> a Source #

Similar to !! but with flipped arguments. get element from list using index value starting from `0`.

>>> at 2 ["a", "b", "c"]

it is also useful when used in a partially applied position like:

>>> map (at 1) [["a","b","c"], ["a","b","c"], ["a","b","c"]]

Unsafe Maybe functions

fromJust :: HasCallStack => Maybe a -> a #

The fromJust function extracts the element out of a Just and throws an error if its argument is Nothing.



Basic usage:

>>> fromJust (Just 1)
>>> 2 * (fromJust (Just 10))
>>> 2 * (fromJust Nothing)
*** Exception: Maybe.fromJust: Nothing

Unsafe Text.Read functions

read :: Read a => String -> a #

The read function reads input from a string, which must be completely consumed by the input process. read fails with an error if the parse is unsuccessful, and it is therefore discouraged from being used in real applications. Use readMaybe or readEither for safe alternatives.

>>> read "123" :: Int
>>> read "hello" :: Int
*** Exception: no parse