Modulerelude-1.2.0.0Haskell2010

Relude.Unsafe

SPDX-License-Identifier : MIT Maintainer : Kowainik xrom.xkov@gmail.com Stability : Stable Portability : Portable

⚠️ 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

8 values

Packagerelude-1.2.0.0
Exports8
LanguageHaskell2010
LicenceMIT
SourceUnsafe.hs

Unsafe list functions

6 declarations

valuehead :: HasCallStack => [a] -> a

This is a partial function, it throws an error on empty lists. Use pattern matching, uncons or listToMaybe instead. Consider refactoring to use Data.List.NonEmpty.

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

To disable the warning about partiality put {-# OPTIONS_GHC -Wno-x-partial -Wno-unrecognised-warning-flags #-} at the top of the file. To disable it throughout a package put the same options into ghc-options section of Cabal file. To disable it in GHCi put :set -Wno-x-partial -Wno-unrecognised-warning-flags into ~/.ghci config file. See also the migration guide.

Examples

Example1 expression

>>> head [1, 2, 3]1

Example1 expression

>>> head [1..]1

Example1 expression

>>> head []*** Exception: Prelude.head: empty list

valuetail :: HasCallStack => [a] -> [a]

This is a partial function, it throws an error on empty lists. Replace it with drop 1, or use pattern matching or uncons instead. Consider refactoring to use Data.List.NonEmpty.

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

Examples

Example1 expression

>>> tail [1, 2, 3][2,3]

Example1 expression

>>> tail [1][]

Example1 expression

>>> tail []*** Exception: Prelude.tail: empty list

valuelast :: HasCallStack => [a] -> a

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

WARNING: This function is partial. Consider using unsnoc instead.

Examples

Example1 expression

>>> last [1, 2, 3]3

Example1 expression

>>> last [1..]* Hangs forever *

Example1 expression

>>> last []*** Exception: Prelude.last: empty list

valueinit :: HasCallStack => [a] -> [a]

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

WARNING: This function is partial. Consider using unsnoc instead.

Examples

Example1 expression

>>> init [1, 2, 3][1,2]

Example1 expression

>>> init [1][]

Example1 expression

>>> init []*** Exception: Prelude.init: empty list

value(!!) :: HasCallStack => [a] -> Int -> a

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

WARNING: This function is partial, and should only be used if you are sure that the indexing will not fail. Otherwise, use !?.

WARNING: This function takes linear time in the index.

Examples

Example1 expression

>>> ['a', 'b', 'c'] !! 0'a'

Example1 expression

>>> ['a', 'b', 'c'] !! 2'c'

Example1 expression

>>> ['a', 'b', 'c'] !! 3*** Exception: Prelude.!!: index too large

Example1 expression

>>> ['a', 'b', 'c'] !! (-1)*** Exception: Prelude.!!: negative index

valueat :: Int -> [a] -> a

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

Example1 expression

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

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

Example1 expression

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

Unsafe Maybe functions

1 declaration

valuefromJust :: HasCallStack => Maybe a -> a

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

Examples

Basic usage:

Example1 expression

>>> fromJust (Just 1)1

Example1 expression

>>> 2 * (fromJust (Just 10))20

Example1 expression

>>> 2 * (fromJust Nothing)*** Exception: Maybe.fromJust: Nothing...

WARNING: This function is partial. You can use case-matching instead.

Unsafe Text.Read functions

1 declaration

valueread :: 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.

Example1 expression

>>> read "123" :: Int123

Example1 expression

>>> read "hello" :: Int*** Exception: Prelude.read: no parse