Hoogle Search

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

fix :: (a -> a) -> a

rio RIO.Prelude

fix f is the least fixed point of the function f, i.e. the least defined x such that f x = x. When f is strict, this means that because, by the definition of strictness, f ⊥ = ⊥ and such the least defined fixed point of any strict function is ⊥.
Examples
We can write the factorial function using direct recursion as
```
>>> let fac n = if n <= 1 then 1 else n * fac (n-1) in fac 5
120
```
This uses the fact that Haskell’s let introduces recursive bindings. We can rewrite this definition using fix, Instead of making a recursive call, we introduce a dummy parameter rec; when used within fix, this parameter then refers to fix’s argument, hence the recursion is reintroduced.
```
>>> fix (\rec n -> if n <= 1 then 1 else n * rec (n-1)) 5
120
```
Using fix, we can implement versions of repeat as fix . (:) and cycle as fix . (++)
```
>>> take 10 $ fix (0:)
[0,0,0,0,0,0,0,0,0,0]
```
```
>>> map (fix (\rec n -> if n < 2 then n else rec (n - 1) + rec (n - 2))) [1..10]
[1,1,2,3,5,8,13,21,34,55]
```
Implementation Details
The current implementation of fix uses structural sharing
```
fix f = let x = f x in x
```
A more straightforward but non-sharing version would look like
```
fix f = f (fix f)
```
floatRadix :: RealFloat a => a -> Integer

rio RIO.Prelude

a constant function, returning the radix of the representation (often 2)
commonPrefixes :: Text -> Text -> Maybe (Text, Text, Text)

rio RIO.Text

O(n) Find the longest non-empty common prefix of two strings and return it, along with the suffixes of each string at which they no longer match. If the strings do not have a common prefix or either one is empty, this function returns Nothing. Examples:
```
>>> commonPrefixes "foobar" "fooquux"
Just ("foo","bar","quux")
```
```
>>> commonPrefixes "veeble" "fetzer"
Nothing
```
```
>>> commonPrefixes "" "baz"
Nothing
```
dropPrefix :: Text -> Text -> Text

rio RIO.Text

Drop prefix if present, otherwise return original Text.
dropSuffix :: Text -> Text -> Text

rio RIO.Text

Drop prefix if present, otherwise return original Text.
isInfixOf :: Text -> Text -> Bool

rio RIO.Text

O(n+m) The isInfixOf function takes two Texts and returns True if and only if the first is contained, wholly and intact, anywhere within the second. In (unlikely) bad cases, this function's time complexity degrades towards O(n*m).
isPrefixOf :: Text -> Text -> Bool

rio RIO.Text

O(n) The isPrefixOf function takes two Texts and returns True if and only if the first is a prefix of the second.
isSuffixOf :: Text -> Text -> Bool

rio RIO.Text

O(n) The isSuffixOf function takes two Texts and returns True if and only if the first is a suffix of the second.

rio	RIO.Prelude

rio	RIO.Prelude

stripPrefix :: Text -> Text -> Maybe Text

rio	RIO.Text

O(n) Return the suffix of the second string if its prefix matches the entire first string. Examples:

>>> stripPrefix "foo" "foobar"
Just "bar"

>>> stripPrefix ""    "baz"
Just "baz"

>>> stripPrefix "foo" "quux"
Nothing

This is particularly useful with the ViewPatterns extension to GHC, as follows:

{-# LANGUAGE ViewPatterns #-}
import Data.Text as T

fnordLength :: Text -> Int
fnordLength (stripPrefix "fnord" -> Just suf) = T.length suf
fnordLength _                                 = -1

stripSuffix :: Text -> Text -> Maybe Text

rio	RIO.Text

O(n) Return the prefix of the second string if its suffix matches the entire first string. Examples:

>>> stripSuffix "bar" "foobar"
Just "foo"

>>> stripSuffix ""    "baz"
Just "baz"

>>> stripSuffix "foo" "quux"
Nothing

This is particularly useful with the ViewPatterns extension to GHC, as follows:

{-# LANGUAGE ViewPatterns #-}
import Data.Text as T

quuxLength :: Text -> Int
quuxLength (stripSuffix "quux" -> Just pre) = T.length pre
quuxLength _                                = -1

Page 134 of many | Previous | Next

Hoogle Search

Examples

Implementation Details