diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,11 +1,30 @@ Change log ========== +0.2.0 +===== + +* [#43](https://github.com/kowainik/relude/issues/43): + Implement `Relude.Extra.Newtype` module. +* [#46](https://github.com/kowainik/relude/issues/46): + Add a function that returns its own name. +* [#48](https://github.com/kowainik/relude/issues/48): + Export `<&>` from `base`. + Also reexport `fromLeft` and `fromRight` from `base` where possible. +* [#49](https://github.com/kowainik/relude/issues/49): + Speed up and refactor property tests. +* [#54](https://github.com/kowainik/relude/issues/54): + Improve documentation. + Add more examples to documentation and more tests. + Reexport `withReader` and `withReaderT`. + Remove `safeHead`. + Rename `Relude.List.Safe` to `Relude.List.NonEmpty`. + 0.1.1 ===== -* [#44](https://github.com/kowainik/relude/issues/44) - Implement parser deriviation from pretty-printers +* [#44](https://github.com/kowainik/relude/issues/44): + Implement parser deriviation from pretty-printers. 0.1.0 ===== diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,5 +1,5 @@ The MIT License (MIT) -Copyright (c) 2016-2017, Stephen Diehl, 2017, Serokell, 2018, Kowainik +Copyright (c) 2016, Stephen Diehl, 2016-2018, Serokell, 2018, Kowainik Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,13 +1,14 @@ -Relude -========= +# Relude +![Relude: cyclone logo](https://user-images.githubusercontent.com/4276606/44077619-d2abb39a-9fd6-11e8-9d9f-cc57a9d03fa0.png) [![Build Status](https://travis-ci.org/kowainik/relude.svg?branch=master)](https://travis-ci.org/kowainik/relude) [![Hackage](https://img.shields.io/hackage/v/relude.svg)](https://hackage.haskell.org/package/relude) [![Stackage LTS](http://stackage.org/package/relude/badge/lts)](http://stackage.org/lts/package/relude) [![Stackage Nightly](http://stackage.org/package/relude/badge/nightly)](http://stackage.org/nightly/package/relude) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) -`relude` is a custom prelude based on `universum`. `relude` tries to achieve the following goals: +`relude` is a custom prelude, an alternative to default `Prelude`. +`relude` tries to achieve the following goals: 1. **Avoid all** [**partial functions**](https://www.reddit.com/r/haskell/comments/5n51u3/why_are_partial_functions_as_in_head_tail_bad/) (like `head :: [a] -> a`). The types of partial functions lie about their @@ -16,7 +17,7 @@ are not exported by default. 2. **Type-safety**. We like to make invalid states unrepresantable. And if it's possible to express this concept through the types then we will do it. - + _Example:_ ```haskell whenNotNull :: Applicative f => [a] -> (NonEmpty a -> f ()) -> f () @@ -44,55 +45,32 @@ 7. **User-friendliness.** Ability to quickly migrate to `relude` if you're familiar with the common libraries like `text` and `containers`. 8. **Exploration.** Experiment with new ideas and proposals without introducing - breaking changes. + breaking changes. `relude` uses the approach with `Extra.*` modules which are not + exported by default so it's quite easy to bring something new and let users + decide to use it or not. This README contains introduction to `Relude` and a tutorial on how to use it. -Structure of this tutorial --------------------------- +## Structure of this tutorial This tutorial has several parts: -1. [Motivation.](#motivation-) -2. [Get started.](#get-started-) -3. [Difference from `Prelude`.](#difference-from-prelude-) -4. [Reexports.](#reexports-) -5. [What's new?](#whats-new-) +1. [Get started.](#get-started-) +2. [Difference from `Prelude`.](#difference-from-prelude-) +3. [Reexports.](#reexports-) +4. [What's new?](#whats-new-) 6. [Migration guide.](#migration-guide-) This is neither a tutorial on _Haskell_ nor tutorial on each function contained in `Relude`. For detailed documentation of every function together with examples and usage, see [_Haddock documentation_](http://hackage.haskell.org/package/relude). -Motivation [↑](#structure-of-this-tutorial) ------------------------------------------- - -We decided to base `relude` on `universum` due to the following reasons: - -1. `universum` helps to achieve our goals more than any other custom prelude. -2. We worked on `universum` a lot (just check contributors statistics) and we - know its internal structure. - -The motivation to create another alternative prelude instead of modifying -existing one is that it's hard to change preludes in any way. `relude` -uses approach with `Extra.*` modules which are not exported by default so it's -quite easy to bring something new (that satisfies `relude` goals) and let users -decide to use it or not. - -Unlike `universum`, we are: - -1. Not trying to replace `Foldable` with custom `Container` type class. We only - forbid `elem` and `notElem` functions for sets due to performance reasons. -2. Have less dependencies: no `vector`, no `microlens`, no `safe-exceptions`, no `type-operators`. -3. Have a lot of other different improvements. - -Get started [↑](#structure-of-this-tutorial) --------------------------------------------- +## Get started [↑](#structure-of-this-tutorial) If you want to start using `relude` in your project and explore it with the help of compiler, set everything up according to the instructions below. -### `base-noprelude` +### base-noprelude This is the recommended way to use custom prelude. It requires you to perform the following steps: @@ -107,6 +85,8 @@ import Relude ``` + > **NOTE:** if you use [`summoner`](https://github.com/kowainik/summoner) to generate Haskell project, + > this tool can automatically create such structure for you when you specify custom prelude. 3. Optionally modify your `Prelude` to include more or less functions. Probably you want to hide something from `Relude` module. Or maybe you want to add something from `Relude.Extra.*` modules! @@ -135,8 +115,7 @@ import Relude ``` -Difference from Prelude [↑](#structure-of-this-tutorial) --------------------------------------------------------- +## Difference from Prelude [↑](#structure-of-this-tutorial) * `head`, `tail`, `last`, `init` work with `NonEmpty a` instead of `[a]`. * `undefined` triggers a compiler warning, because you probably don't want to @@ -158,30 +137,32 @@ * You can't call `elem` and `notElem` functions over `Set` and `HashSet`. These functions are forbidden for these two types because of the performance reasons. * `error` takes `Text`. -* `lookup` doesn't work on list of pairs. +* `lookup` for lists is not exported. -Reexports [↑](#structure-of-this-tutorial) ------------------------------------------- +## Reexports [↑](#structure-of-this-tutorial) -### Commonly used libraries +`relude` reexports some parts of the following libraries: -First of all, we reexport some generally useful modules: `Control.Applicative`, -`Data.Traversable`, `Data.Monoid`, `Control.DeepSeq`, `Data.List`, and lots of -others. Just remove unneeded imports after importing `Relude` (you can use -`.hlint.yaml` file for this). +* `base` +* `containers` +* `unordered-containers` +* `text` +* `bytestring` +* `transformers` +* `mtl` +* `deepseq` +* `stm` -Then, some commonly used types: `Map/HashMap/IntMap`, `Set/HashSet/IntSet`, -`Seq`, `Text` and `ByteString` (as well as synonyms `LText` and `LByteString` -for lazy versions). +If you want to clean up imports after switching to `relude`, you can use +`relude`-specific [`.hlint.yaml`](.hlint.yaml) configuration for this task. -`liftIO` and `MonadIO` are exported by default. A lot of `IO` functions are -generalized to `MonadIO`. +### base -`deepseq` is exported. For instance, if you want to force deep evaluation of -some value (in IO), you can write `evaluateNF a`. WHNF evaluation is possible -with `evaluateWHNF a`. +Some generally useful modules from `base` package, like: `Control.Applicative`, +`Data.Traversable`, `Data.Monoid`, `Data.List`, and lots of others. -We also reexport big chunks of these libraries: `mtl`, `stm`. +`liftIO` and `MonadIO` are exported by default. A lot of `IO` functions are +generalized to `MonadIO`. [`Bifunctor`](http://hackage.haskell.org/package/base-4.9.1.0/docs/Data-Bifunctor.html) type class with useful instances is exported. @@ -189,33 +170,57 @@ * `first` and `second` functions apply a function to first/second part of a tuple (for tuples). * `bimap` takes two functions and applies them to first and second parts respectively. -### Text +`trace`, `traceM`, `traceShow`, etc. are available by default. GHC will warn you +if you accidentally leave them in code, however (same for `undefined`). -We export `Text` and `LText`, and some functions work with `Text` instead of `String` – +We also have `data Undefined = Undefined` (which, too, comes with warnings). + +`relude` reexports `Exception` type from the `base` package and introduces the +`bug` function as an alternative to `error`. There's also a very convenient +`Exc` pattern-synonym to handle exceptions of different types. + +See [`Relude.Exception`](src/Relude/Exception.hs) module for details on exceptions. + +### containers & unordered-containers + +The following types from these two packages are exported: +Then, some commonly used types: + +* Maps: strict versions of `Map`, `HashMap`, `IntMap`. +* Sets: `Set`, `HashSet`, `IntSet`. +* Sequences: `Seq`. + +### text & bytestring + +`relude` exports `Text` and `ByteString` (as well as synonyms `LText` and `LByteString` +for lazy versions) and some functions work with `Text` instead of `String` – specifically, IO functions (`readFile`, `putStrLn`, etc) and `show`. In fact, `show` is polymorphic and can produce strict or lazy `Text`, `String`, or `ByteString`. Also, `toText/toLText/toString` can convert `Text|LText|String` types to `Text/LText/String`. If you want to convert to and from `ByteString` use `encodeUtf8/decodeUtf8` functions. -### Debugging and `undefined`s +### transforms & mtl -`trace`, `traceM`, `traceShow`, etc. are available by default. GHC will warn you -if you accidentally leave them in code, however (same for `undefined`). +The following parts of these two libraries are exported: -We also have `data Undefined = Undefined` (which, too, comes with warnings). +* Transformers: `State[T]`, `Reader[T]`, `ExceptT`, `MaybeT`. +* Classes: `MonadReader`, `MonadState`, `MonadError`. -### Exceptions +### Deepseq -TODO: write about reexports, `Bug` and `Exc` pattern. +`deepseq` is exported. For instance, if you want to force deep evaluation of +some value (in `IO`), you can write `evaluateNF a`. WHNF evaluation is possible +with `evaluateWHNF a`. -What's new? [↑](#structure-of-this-tutorial) --------------------------------------------- +## What's new? [↑](#structure-of-this-tutorial) Finally, we can move to part describing the new cool features we bring with `relude`. -* Safe analogue for `head` function: `safeHead :: [a] -> Maybe a` or you can - use our `viaNonEmpty` function to get `Maybe a`: `viaNonEmpty head :: [a] -> Maybe a`. +### Available by default + +* Safe analogue for list functions: use `viaNonEmpty` function to get `Maybe a`. + + `viaNonEmpty head :: [a] -> Maybe a` * `uncons` splits a list at the first element. * `ordNub` and `sortNub` are _O(n log n)_ versions of `nub` (which is quadratic) and `hashNub` and `unstableNub` are almost _O(n)_ versions of `nub`. @@ -265,9 +270,32 @@ `evaluate` and `evaluate . force`. * `MonadFail` instance for `Either`. -Migration guide [↑](#structure-of-this-tutorial) ------------------------------------------------- +### Need to import explicitly +* Convenient functions to work with `(Bounded a, Enum a)` types: + 1. `universe :: (Bounded a, Enum a) => [a`: get all values of the type. + 2. `inverseMap :: (Bounded a, Enum a, Ord k) => (a -> k) -> k -> Maybe a`: convert functions like `show` to parsers. +* Nice helpers to deal with `newtype`s in a more pleasant way: + + ```haskell + ghci> newtype Foo = Foo Bool deriving Show + ghci> under not (Foo True) + Foo False + ``` + +* Functions to operate with `CallStack`: + + ```haskell + >>> foo :: HasCallStack => String; foo = ownName + >>> foo + "foo" + ``` + +* A lot of other cool things: + + Explore `Extra` modules: [`Relude.Extra`](src/Relude/Extra/) + +## Migration guide [↑](#structure-of-this-tutorial) + In order to replace default `Prelude` with `relude` you should start with instructions given in [_get started_](#get-started-) section. @@ -279,7 +307,6 @@ 1. Change `[a]` to `NonEmpty a` where it makes sense. 2. Use functions which return `Maybe`. There is the `viaNonEmpty` function for this. And you can use it like `viaNonEmpty last l`. - + `viaNonEmpty head l` is `safeHead l` + `tail` is `drop 1`. It's almost never a good idea to use `tail` from `Prelude`. 3. Add `import qualified Relude.Unsafe as Unsafe` and replace function with qualified usage. 3. If you use `fromJust` or `!!` you should use them from `import qualified Relude.Unsafe as Unsafe`. @@ -309,3 +336,7 @@ + Use `toText/toLText/toString` functions to convert to `Text/LazyText/String` types. + Use `encodeUtf8/decodeUtf8` to convert to/from `ByteString`. 6. Run `hlint` using `.hlint.yaml` file from `relude` package to cleanup code and imports. + +### Acknowledgement + +Icons made by [Freepik](http://www.freepik.com) from [www.flaticon.com](https://www.flaticon.com/) is licensed by [CC 3.0 BY](http://creativecommons.org/licenses/by/3.0/). diff --git a/relude.cabal b/relude.cabal --- a/relude.cabal +++ b/relude.cabal @@ -1,5 +1,6 @@ +cabal-version: 1.24 name: relude -version: 0.1.1 +version: 0.2.0 synopsis: Custom prelude from Kowainik description: == Goals @@ -53,7 +54,6 @@ category: Prelude stability: stable build-type: Simple -cabal-version: 1.24 tested-with: GHC == 8.0.2 , GHC == 8.2.2 , GHC == 8.4.3 @@ -93,8 +93,8 @@ Relude.Lifted.File Relude.Lifted.IORef Relude.List + Relude.List.NonEmpty Relude.List.Reexport - Relude.List.Safe Relude.Monad Relude.Monad.Either Relude.Monad.Maybe @@ -109,13 +109,19 @@ -- not exported by default Relude.Extra.Bifunctor + Relude.Extra.CallStack Relude.Extra.Enum Relude.Extra.Group Relude.Extra.Map + Relude.Extra.Newtype Relude.Unsafe - - ghc-options: -Wall -fwarn-implicit-prelude + ghc-options: -Wall + -Wcompat + -Widentities + -Wincomplete-uni-patterns + -Wincomplete-record-updates + -fwarn-implicit-prelude build-depends: base >= 4.8 && < 5 , bytestring @@ -141,18 +147,26 @@ other-modules: Test.Relude.Property - build-depends: base >= 4.8 && < 5 + build-depends: base >= 4.8 && < 5 , relude , bytestring , text , utf8-string - , hedgehog + , hedgehog >= 0.6 , tasty , tasty-hedgehog - ghc-options: -Wall -threaded + ghc-options: -Wall + -threaded + -Wincomplete-uni-patterns + -Wincomplete-record-updates + -Wcompat + -Widentities + -Wredundant-constraints + default-language: Haskell2010 default-extensions: NoImplicitPrelude + TypeApplications test-suite relude-doctest type: exitcode-stdio-1.0 @@ -168,17 +182,25 @@ benchmark relude-benchmark type: exitcode-stdio-1.0 - default-language: Haskell2010 - ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N hs-source-dirs: benchmark main-is: Main.hs - build-depends: base < 5 + + build-depends: base >= 4.8 && < 5 , relude , containers , gauge , unordered-containers - if impl(ghc == 7.10.3) - build-depends: semigroups >= 0.18 + ghc-options: -Wall + -threaded + -rtsopts + -with-rtsopts=-N + -Wincomplete-uni-patterns + -Wincomplete-record-updates + -Wcompat + -Widentities + -Wredundant-constraints + + default-language: Haskell2010 default-extensions: NoImplicitPrelude ScopedTypeVariables diff --git a/src/Relude.hs b/src/Relude.hs --- a/src/Relude.hs +++ b/src/Relude.hs @@ -1,15 +1,15 @@ {-# LANGUAGE Trustworthy #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik -{- | Main module that reexports all functionality allowed to use -without importing any other modules. Just add next lines to your -module to replace default 'Prelude' with better one. +The main module that reexports all functionality. It's allowed to use it without +importing any other modules. If you want to use @relude@ per-module basis then +just add next lines to your module to replace default 'Prelude': @ \{\-\# LANGUAGE NoImplicitPrelude \#\-\} @@ -17,33 +17,47 @@ __import__ "Relude" @ -This documentation section contains description of internal module structure to +Alternatively, you can replace @base@ package in your dependencies with +@[base-noprelude](http://hackage.haskell.org/package/base-noprelude)@ and add +the following 'Prelude' module to your package to use @relude@ by default in +every module instead of 'Prelude': + +@ +__module__ Prelude (__module__ "Relude") __where__ +__import__ "Relude" +@ + +This documentation section contains the description of internal module structure to help navigate between modules, search for interesting functionalities and -understand where you need to put your new changes. +understand where you need to put your new changes (if you're a contributor). Functions and types are distributed across multiple modules and grouped by -meaning or __theme__. Name of the module should give you hints regarding what -this module contains. Some /themes/ contain a great amount of both reexported -functions and functions of our own. To make it easier to understand these huge -chunks of functions, all reexported stuff is moved into separate module with -name @Relude.SomeTheme.Reexport@ and our own functions and types are in -@Relude.SomeTheme.SomeName@. For example, see modules -"Relude.Container.Class" and "Relude.Container.Reexport". +meaning or __category__. Name of the module should give you hints regarding what +this module contains. Some /categories/ contain a significant amount of both reexported +functions and functions of our own. To make it easier to understand these enormous +chunks of functions, all reexported stuff is moved into the separate module with +name @Relude.SomeCategory.Reexport@ and our own functions and types are in +@Relude.SomeCategory.SomeName@. For example, see modules +"Relude.Foldable.Fold" and "Relude.Foldable.Reexport". -Below is a short description of what you can find under different modules: +Below is a short description of what you can find under different modules, +imported by default from "Relude": * __"Relude.Applicative"__: reexports from "Control.Applicative" and some general-purpose applicative combinators. * __"Relude.Base"__: different general types and type classes from @base@ package ('Int', 'Num', 'Generic', etc.) not exported by other modules. * __"Relude.Bool"__: 'Bool' data type with different predicates and combinators. +* __"Relude.Container"__: 'One' typeclass for creating data structures from + singleton lement and reexports of types from packages @containers@ and + @unordered-containers@. * __"Relude.Debug"__: @trace@-like debugging functions with compile-time - warnings (so you don't forget to remove them) + warnings (so you don't forget to remove them). * __"Relude.DeepSeq"__: reexports from "Control.DeepSeq" module and functions to evaluate expressions to weak-head normal form or normal form. -* __"Relude.Exception"__: reexports "Control.Exception.Safe" from - @safe-exceptions@ package, 'bug' as better 'error', 'Exc' pattern synonym for - convenient pattern-matching on exceptions. +* __"Relude.Exception"__: reexports "Control.Exception", introduces 'bug' + function as better 'error' and 'Exc' pattern synonym for convenient + pattern-matching on exceptions. * __"Relude.Foldable"__: reexports functions for 'Foldable' and 'Traversable'. * __"Relude.Function"__: almost everything from "Data.Function" module. * __"Relude.Functor"__: reexports from "Data.Functor", "Data.Bifunctor", @@ -52,14 +66,28 @@ files, 'IORef's, 'MVar's, etc. * __"Relude.List"__: big chunk of "Data.List", 'NonEmpty' type and functions for this type ('head', 'tail', 'last', 'init'). -* __"Relude.Monad"__: monad transormers, combinators for 'Maybe' and 'Either'. +* __"Relude.Monad"__: reexports from "Data.Maybe" and "Data.Either" modules, + monad transormers, various combinators. * __"Relude.Monoid"__: reexports from "Data.Monoid" and "Data.Semigroup". * __"Relude.Nub"__: better versions of @nub@ function for list. * __"Relude.Print"__: polymorphic 'putStrLn' function and functions to print 'Text'. * __"Relude.String"__: reexports from @text@ and @bytestring@ packages with conversion functions between different textual types. -* __"Relude.Unsafe"__: unsafe functions (produce 'error'). - Not exported by "Relude" module by default. + +And these modules are not exported by default, but you can easily bring them to +every module in your package by modifying your "Prelude" file: + +* __"Relude.Extra.Bifunctor"__: additional combinators for 'Bifunctor'. +* __"Relude.Extra.CallStack"__: useful functions to extract information from + 'CallStack'. +* __"Relude.Extra.Enum"__: extra utilities for types that implement 'Bounded' + and 'Enum' constraints. +* __"Relude.Extra.Group"__: grouping functions, polymorphic on return @Map@ type. +* __"Relude.Extra.Map"__: typeclass for @Map@-like data structures. +* __"Relude.Extra.Newtype"__: generic functions that automatically work for any + @newtype@. +* __"Relude.Unsafe"__: unsafe partial functions (produce 'error') for lists and + 'Maybe'. -} module Relude diff --git a/src/Relude/Applicative.hs b/src/Relude/Applicative.hs --- a/src/Relude/Applicative.hs +++ b/src/Relude/Applicative.hs @@ -1,15 +1,16 @@ {-# LANGUAGE Safe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Convenient utils to work with 'Applicative'. There were more functions in this module --- (see ) --- but only convenient ans most used are left. +Convenient utils to work with 'Applicative'. There were more functions in this module +(see ) +but only convenient ans most used are left. +-} module Relude.Applicative ( module Control.Applicative diff --git a/src/Relude/Base.hs b/src/Relude/Base.hs --- a/src/Relude/Base.hs +++ b/src/Relude/Base.hs @@ -1,16 +1,16 @@ -{-# LANGUAGE BangPatterns #-} -{-# LANGUAGE CPP #-} -{-# LANGUAGE Unsafe #-} +{-# LANGUAGE CPP #-} +{-# LANGUAGE Unsafe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Reexports from @GHC.*@ modules of --- package. +Reexports from @Data.*@ and @GHC.*@ modules of + package. +-} module Relude.Base ( -- * Base types @@ -51,8 +51,6 @@ , module GHC.OverloadedLabels , module GHC.ExecutionStack , module GHC.Stack - - , ($!) ) where -- Base types @@ -76,12 +74,13 @@ import Data.Typeable (Typeable) import Data.Void (Void, absurd, vacuous) -import GHC.Base (String, asTypeOf, maxInt, minInt, ord, seq) +import GHC.Base (String, asTypeOf, maxInt, minInt, ord, seq, ($!)) import GHC.Enum (Bounded (..), Enum (..), boundedEnumFrom, boundedEnumFromThen) import GHC.Float (Double (..), Float (..), Floating (acos, acosh, asin, asinh, atan, atanh, cos, cosh, exp, logBase, pi, sin, sinh, sqrt, tan, tanh, (**))) import GHC.Generics (Generic) import GHC.Num (Integer, Num (..), subtract) -import GHC.Real hiding (showSigned, (%)) +import GHC.Real (Fractional (..), Integral (..), Ratio, Rational, Real (..), RealFrac (..), + denominator, even, fromIntegral, gcd, lcm, numerator, odd, realToFrac, (^), (^^)) import GHC.Show (Show) #if MIN_VERSION_base(4,10,0) @@ -94,20 +93,3 @@ import GHC.OverloadedLabels (IsLabel (..)) import GHC.Stack (CallStack, HasCallStack, callStack, currentCallStack, getCallStack, prettyCallStack, prettySrcLoc, withFrozenCallStack) - --- $setup --- >>> import Relude.Function (const, ($)) - --- | Stricter version of 'Data.Function.$' operator. --- Default Prelude defines this at the toplevel module, so we do as well. --- --- >>> const 3 $ Prelude.undefined --- 3 --- >>> const 3 $! Prelude.undefined --- *** Exception: Prelude.undefined --- CallStack (from HasCallStack): --- error, called at libraries/base/GHC/Err.hs:79:14 in base:GHC.Err --- ... -($!) :: (a -> b) -> a -> b -f $! x = let !vx = x in f vx -infixr 0 $! diff --git a/src/Relude/Bool.hs b/src/Relude/Bool.hs --- a/src/Relude/Bool.hs +++ b/src/Relude/Bool.hs @@ -1,7 +1,15 @@ {-# LANGUAGE Safe #-} --- | Convenient commonly used and very helpful functions to work with --- 'Bool' and also with monads. +{- | +Copyright: (c) 2016 Stephen Diehl + (c) 20016-2018 Serokell + (c) 2018 Kowainik +License: MIT +Maintainer: Kowainik + +Convenient commonly used and very helpful functions to work with 'Bool' and also +with monads. +-} module Relude.Bool ( module Relude.Bool.Guard diff --git a/src/Relude/Bool/Guard.hs b/src/Relude/Bool/Guard.hs --- a/src/Relude/Bool/Guard.hs +++ b/src/Relude/Bool/Guard.hs @@ -1,11 +1,12 @@ -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | This module contains monadic predicates. +Monadic boolean combinators. +-} module Relude.Bool.Guard ( guardM diff --git a/src/Relude/Bool/Reexport.hs b/src/Relude/Bool/Reexport.hs --- a/src/Relude/Bool/Reexport.hs +++ b/src/Relude/Bool/Reexport.hs @@ -1,11 +1,12 @@ -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | This module reexports functions to work with 'Bool' type. +Reexports functions to work with 'Bool' type. +-} module Relude.Bool.Reexport ( module Control.Monad diff --git a/src/Relude/Container.hs b/src/Relude/Container.hs --- a/src/Relude/Container.hs +++ b/src/Relude/Container.hs @@ -1,11 +1,12 @@ -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | This module exports all container-related stuff. +This module exports all container-related stuff. +-} module Relude.Container ( module Relude.Container.One diff --git a/src/Relude/Container/One.hs b/src/Relude/Container/One.hs --- a/src/Relude/Container/One.hs +++ b/src/Relude/Container/One.hs @@ -2,14 +2,14 @@ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TypeFamilies #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik -{- | Typeclass for creating structures from singleton element. +Typeclass for creating structures from singleton element. -} module Relude.Container.One @@ -42,9 +42,7 @@ -- >>> import Relude.String (Text) -- >>> import qualified Data.HashMap.Strict as HashMap -{- | Type class for types that can be created from one element. @singleton@ -is lone name for this function. Constructions of different type differ: -@:[]@ for lists, two arguments for Maps. Also some data types are monomorphic. +{- | Typeclass for data types that can be created from one element. >>> one True :: [Bool] [True] @@ -54,6 +52,7 @@ fromList [(3,"hello")] -} class One x where + -- | Type of single element of the structure. type OneItem x -- | Create a list, map, 'Text', etc from a single element. one :: OneItem x -> x diff --git a/src/Relude/Container/Reexport.hs b/src/Relude/Container/Reexport.hs --- a/src/Relude/Container/Reexport.hs +++ b/src/Relude/Container/Reexport.hs @@ -1,11 +1,13 @@ -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | This module reexports all container related stuff from 'Prelude'. +Reexports all container-related stuff from @base@, @containers@ and +@unordered-containers@ packages. +-} module Relude.Container.Reexport ( module Data.Hashable diff --git a/src/Relude/Debug.hs b/src/Relude/Debug.hs --- a/src/Relude/Debug.hs +++ b/src/Relude/Debug.hs @@ -10,16 +10,17 @@ {-# LANGUAGE TypeInType #-} #endif -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Functions for debugging. If you left these functions in your code --- then warning is generated to remind you about left usages. Also some --- functions (and data types) are convenient for prototyping. +Functions for debugging. If you left these functions in your code then a warning +is generated to remind you about left usages. Also some functions (and data +types) are convenient for prototyping. +-} module Relude.Debug ( Undefined (..) @@ -33,18 +34,15 @@ , undefined ) where -import Control.Monad (Monad, return) import Data.Data (Data) -import Data.Text (Text, unpack) -import Data.Typeable (Typeable) import GHC.Exts (RuntimeRep, TYPE) -import GHC.Generics (Generic) import System.IO.Unsafe (unsafePerformIO) -import Relude.Base (HasCallStack) - import Relude.Applicative (pass) +import Relude.Base (Generic, HasCallStack, Typeable) +import Relude.Monad.Reexport (Monad (..)) import Relude.Print (Print, putStrLn) +import Relude.String (Text, toString) import qualified Prelude as P @@ -58,7 +56,7 @@ -- | 'P.error' that takes 'Text' as an argument. error :: forall (r :: RuntimeRep) . forall (a :: TYPE r) . HasCallStack => Text -> a -error s = P.error (unpack s) +error s = P.error (toString s) -- | Version of 'Debug.Trace.traceShow' that leaves warning. {-# WARNING traceShow "'traceShow' remains in code" #-} @@ -78,7 +76,7 @@ -- | Version of 'Debug.Trace.traceM' that leaves warning and takes 'Text'. {-# WARNING traceM "'traceM' remains in code" #-} traceM :: (Monad m) => Text -> m () -traceM s = trace (unpack s) pass +traceM s = trace (toString s) pass -- | Version of 'Debug.Trace.traceId' that leaves warning and takes 'Text'. {-# WARNING traceId "'traceId' remains in code" #-} diff --git a/src/Relude/DeepSeq.hs b/src/Relude/DeepSeq.hs --- a/src/Relude/DeepSeq.hs +++ b/src/Relude/DeepSeq.hs @@ -1,13 +1,14 @@ -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | This module contains useful functions to evaluate expressions to weak-head --- normal form or just normal form. Useful to force traces or @error@ inside --- monadic computation or to remove space leaks. +This module contains useful functions to evaluate expressions to weak-head +normal form or just normal form. Useful to force traces or @error@ inside +monadic computation or to remove space leaks. +-} module Relude.DeepSeq ( module Control.DeepSeq diff --git a/src/Relude/Exception.hs b/src/Relude/Exception.hs --- a/src/Relude/Exception.hs +++ b/src/Relude/Exception.hs @@ -3,15 +3,16 @@ {-# LANGUAGE Safe #-} {-# LANGUAGE ViewPatterns #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Re-exports most useful functionality from 'safe-exceptions'. Also --- provides some functions to work with exceptions over 'MonadError'. +Re-exports most useful functionality from 'safe-exceptions'. Also +provides some functions to work with exceptions over 'MonadError'. +-} module Relude.Exception ( module Control.Exception @@ -53,6 +54,7 @@ writing something like this: @ +isNonCriticalExc :: SomeException -> Bool isNonCriticalExc e | Just (_ :: NodeAttackedError) <- fromException e = True | Just DialogUnexpected{} <- fromException e = True @@ -62,6 +64,7 @@ you can use 'Exc' pattern synonym: @ +isNonCriticalExc :: SomeException -> Bool isNonCriticalExc = \case Exc (_ :: NodeAttackedError) -> True -- matching all exceptions of type 'NodeAttackedError' Exc DialogUnexpected{} -> True diff --git a/src/Relude/Extra/Bifunctor.hs b/src/Relude/Extra/Bifunctor.hs --- a/src/Relude/Extra/Bifunctor.hs +++ b/src/Relude/Extra/Bifunctor.hs @@ -1,3 +1,20 @@ +{- | +Copyright: (c) 2018 Kowainik +License: MIT +Maintainer: Kowainik + +Useful combinators for bifunctors inside functors. This set of functions is +useful when you want to work with types like these ones: + +@ +foo :: IO (Either a b) +bar :: IO (a, b) + +baz :: Maybe (Either a b) +qux :: Maybe (a, b) +@ +-} + module Relude.Extra.Bifunctor ( bimapF , firstF @@ -6,11 +23,26 @@ import Relude +{- | Fmaps functions for nested bifunctor. Short for @fmap (bimap f g)@. + +>>> bimapF not length $ Just (False, ['a', 'b']) +Just (True,2) +-} bimapF :: (Functor f, Bifunctor p) => (a -> c) -> (b -> d) -> f (p a b) -> f (p c d) bimapF f g = fmap (bimap f g) +{- | Short for @fmap . first@. + +>>> firstF not $ Just (False, ['a', 'b']) +Just (True,"ab") +-} firstF :: (Functor f, Bifunctor p) => (a -> c) -> f (p a b) -> f (p c b) firstF = fmap . first +{- | Short for @fmap . second@. + +>>> secondF length $ Just (False, ['a', 'b']) +Just (False,2) +-} secondF :: (Functor f, Bifunctor p) => (b -> d) -> f (p a b) -> f (p a d) secondF = fmap . second diff --git a/src/Relude/Extra/CallStack.hs b/src/Relude/Extra/CallStack.hs new file mode 100644 --- /dev/null +++ b/src/Relude/Extra/CallStack.hs @@ -0,0 +1,47 @@ +{- | +Copyright: (c) 2018 Kowainik +License: MIT +Maintainer: Kowainik + +Contains useful functions to work with GHC callstack. +-} + +module Relude.Extra.CallStack + ( ownName + , callerName + ) where + +import Relude + +{- | This function returns the name of its caller function, but it requires +that the caller function has 'HasCallStack' constraint. Otherwise, it returns +@""@. + +>>> foo :: HasCallStack => String; foo = ownName +>>> foo +"foo" +>>> bar :: HasCallStack => String; bar = foo +>>> bar +"foo" +-} +ownName :: HasCallStack => String +ownName = case getCallStack callStack of + _:caller:_ -> fst caller + _ -> "" + +{- | This function returns the name of its caller of the caller function, but it +requires that the caller function and caller of the caller function have +'HasCallStack' constraint. Otherwise, it returns @""@. It's useful for +logging: + +>>> log :: HasCallStack => String -> IO (); log s = putStrLn $ callerName ++ ":" ++ s +>>> greeting :: HasCallStack => IO (); greeting = log "Starting..." >> putStrLn "Hello!" >> log "Ending..." +>>> greeting +greeting:Starting... +Hello! +greeting:Ending... +-} +callerName :: HasCallStack => String +callerName = case getCallStack callStack of + _:_:caller:_ -> fst caller + _ -> "" diff --git a/src/Relude/Extra/Enum.hs b/src/Relude/Extra/Enum.hs --- a/src/Relude/Extra/Enum.hs +++ b/src/Relude/Extra/Enum.hs @@ -1,10 +1,19 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} +{- | +Copyright: (c) 2018 Kowainik +License: MIT +Maintainer: Kowainik + +Mini @bounded-enum@ framework inside @relude@. +-} + module Relude.Extra.Enum ( universe , inverseMap , next + , prec , safeToEnum ) where @@ -26,8 +35,15 @@ universe :: (Bounded a, Enum a) => [a] universe = [minBound .. maxBound] -{- | Creates a function that is the inverse of a given function @f@. +{- | @inverseMap f@ creates a function that is the inverse of a given function +@f@. It does so by constructing 'M.Map' for every value @f a@. The +implementation makes sure that the 'M.Map' is constructed only once and then +shared for every call. +The complexity of reversed mapping though is \(\mathcal{O}(\log n)\). + +Usually you want to use 'inverseMap' to inverse 'show' function. + >>> data Color = Red | Green | Blue deriving (Show, Enum, Bounded) >>> parse = inverseMap show :: String -> Maybe Color >>> parse "Red" @@ -35,17 +51,15 @@ >>> parse "Black" Nothing -} -inverseMap :: forall a k. (Bounded a, Enum a, Ord k) - => (a -> k) - -> k - -> Maybe a -inverseMap f = \x -> M.lookup x dict - where - dict :: M.Map k a - dict = M.fromList $ zip (map f univ) univ +inverseMap :: forall a k . (Bounded a, Enum a, Ord k) + => (a -> k) -> (k -> Maybe a) +inverseMap f = \k -> M.lookup k dict + where + dict :: M.Map k a + dict = M.fromList $ zip (map f univ) univ - univ :: [a] - univ = universe + univ :: [a] + univ = universe {- | Like 'succ', but doesn't fail on 'maxBound'. Instead it returns 'minBound'. @@ -55,12 +69,25 @@ False >>> succ True *** Exception: Prelude.Enum.Bool.succ: bad argument - -} next :: (Eq a, Bounded a, Enum a) => a -> a next e | e == maxBound = minBound | otherwise = succ e + +{- | Like 'pred', but doesn't fail on 'minBound'. Instead it returns 'maxBound'. + +>>> prec False +True +>>> prec True +False +>>> pred False +*** Exception: Prelude.Enum.Bool.pred: bad argument +-} +prec :: (Eq a, Bounded a, Enum a) => a -> a +prec e + | e == minBound = maxBound + | otherwise = pred e {- | Returns 'Nothing' if given 'Int' outside range. diff --git a/src/Relude/Extra/Group.hs b/src/Relude/Extra/Group.hs --- a/src/Relude/Extra/Group.hs +++ b/src/Relude/Extra/Group.hs @@ -1,10 +1,12 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-} -{- -Copyright: (c) 2017-2018 Serokelll - (c) 2018 Kowainik -License: MIT +{- | +Copyright: (c) 2018 Kowainik +License: MIT +Maintainer: Kowainik + +Polymorphic grouping functions. -} module Relude.Extra.Group diff --git a/src/Relude/Extra/Map.hs b/src/Relude/Extra/Map.hs --- a/src/Relude/Extra/Map.hs +++ b/src/Relude/Extra/Map.hs @@ -1,7 +1,12 @@ {-# LANGUAGE TypeFamilies #-} -{- | Contains implememtation of polymorhic type classes for things like 'Set' -and 'Map'. +{- | +Copyright: (c) 2018 Kowainik +License: MIT +Maintainer: Kowainik + +Contains implementation of polymorhic type classes for data types 'Set' and +'Map'. -} module Relude.Extra.Map @@ -38,7 +43,7 @@ -- Static Map ---------------------------------------------------------------------------- -{- | Read-only map or set. Contains polymorhic functions which work for both +{- | Read-only map or set. Contains polymorphic functions which work for both sets and maps. -} class StaticMap t where diff --git a/src/Relude/Extra/Newtype.hs b/src/Relude/Extra/Newtype.hs new file mode 100644 --- /dev/null +++ b/src/Relude/Extra/Newtype.hs @@ -0,0 +1,54 @@ +{-# LANGUAGE ScopedTypeVariables #-} + +{- | +Copyright: (c) 2018 Kowainik +License: MIT +Maintainer: Kowainik + +Functions to ease work with newtypes. +-} + +module Relude.Extra.Newtype + ( un + , wrap + , under + ) where + +import Relude + +-- $setup +-- >>> :set -XTypeApplications + +{- | Unwraps value from @newtype@. + +>>> newtype Size = Size Int deriving Show +>>> un @Int (Size 5) +5 +>>> un (Size 5) == length ['a', 'x', 'b'] +False +-} +un :: forall b a . Coercible a b => a -> b +un = coerce + +{- | Wraps value to @newtype@. Behaves exactly as 'un' but has more meaningnful +name in case you need to convert some value to @newtype@. + +>>> newtype Flag = Flag Bool deriving (Show, Eq) +>>> wrap False == Flag True +False +-} +wrap :: forall b a . Coercible a b => a -> b +wrap = coerce + +{- | Applies function to the content of @newtype@. This function is not supposed +to be used on @newtype@s that are created with the help of smart constructors. + +>>> newtype Foo = Foo Bool deriving Show +>>> under not (Foo True) +Foo False +>>> newtype Bar = Bar String deriving Show +>>> under (filter (== 'a')) (Bar "abacaba") +Bar "aaaa" +-} +under :: forall b a . Coercible a b => (b -> b) -> a -> a +under = coerce diff --git a/src/Relude/Foldable.hs b/src/Relude/Foldable.hs --- a/src/Relude/Foldable.hs +++ b/src/Relude/Foldable.hs @@ -1,4 +1,10 @@ --- | This module exports all 'Foldable' and 'Traversable' related stuff. +{- | +Copyright: (c) 2018 Kowainik +License: MIT +Maintainer: Kowainik + +This module exports all 'Foldable' and 'Traversable' related stuff. +-} module Relude.Foldable ( module Relude.Foldable.Fold diff --git a/src/Relude/Foldable/Fold.hs b/src/Relude/Foldable/Fold.hs --- a/src/Relude/Foldable/Fold.hs +++ b/src/Relude/Foldable/Fold.hs @@ -7,13 +7,20 @@ {-# OPTIONS_GHC -fno-warn-unticked-promoted-constructors #-} --- | Fixes and additions to 'Foldable'. +{- | +Copyright: (c) 2016 Stephen Diehl + (c) 20016-2018 Serokell + (c) 2018 Kowainik +License: MIT +Maintainer: Kowainik +Fixes and additions to 'Foldable'. +-} + module Relude.Foldable.Fold ( flipfoldl' , foldMapA , foldMapM - , safeHead , sum , product @@ -24,6 +31,10 @@ , anyM , andM , orM + + -- * Internals + , DisallowElem + , ElemErrorMessage ) where import GHC.TypeLits (ErrorMessage (..), TypeError) @@ -35,41 +46,47 @@ import Relude.Foldable.Reexport (Foldable (..)) import Relude.Function (flip, (.)) import Relude.Functor ((<$>)) -import Relude.Monad.Reexport (Maybe (..), Monad (..)) +import Relude.Monad.Reexport (Monad (..)) import Relude.Monoid (Monoid (..)) import qualified Data.Foldable as F -- $setup -- >>> :set -XOverloadedStrings --- >>> import Relude.Base (String, Rational, even, (/)) +-- >>> import Relude.Base (Int, String, Rational, even, (/)) -- >>> import Relude.Bool (when) +-- >>> import Relude.List (replicate) -- >>> import Relude.Monad (Maybe (..), (>=>)) -- >>> import Relude.Print (print, putTextLn) -- >>> import Relude.String (Text, readMaybe) -- >>> import qualified Data.HashMap.Strict as HashMap -safeHead :: Foldable f => f a -> Maybe a -safeHead = foldr (\x _ -> Just x) Nothing -{-# INLINE safeHead #-} - {- | Similar to 'foldl'' but takes a function with its arguments flipped. >>> flipfoldl' (/) 5 [2,3] :: Rational 15 % 2 - -} flipfoldl' :: Foldable f => (a -> b -> b) -> b -> f a -> b flipfoldl' f = foldl' (flip f) {-# INLINE flipfoldl' #-} -foldMapA :: (Monoid b, Applicative m, Foldable f) => (a -> m b) -> f a -> m b +{- | Polymorphic version of @concatMapA@ function. + +>>> foldMapA @[Int] (Just . replicate 3) [1..3] +Just [1,1,1,2,2,2,3,3,3] +-} +foldMapA :: forall b m f a . (Monoid b, Applicative m, Foldable f) => (a -> m b) -> f a -> m b foldMapA f = foldr step (pure mempty) where step a mb = mappend <$> f a <*> mb {-# INLINE foldMapA #-} -foldMapM :: (Monoid b, Monad m, Foldable f) => (a -> m b) -> f a -> m b +{- | Polymorphic version of @concatMapM@ function. + +>>> foldMapM @[Int] (Just . replicate 3) [1..3] +Just [1,1,1,2,2,2,3,3,3] +-} +foldMapM :: forall b m f a . (Monoid b, Monad m, Foldable f) => (a -> m b) -> f a -> m b foldMapM f xs = foldr step return xs mempty where step x r z = f x >>= \y -> r $! z `mappend` y diff --git a/src/Relude/Foldable/Reexport.hs b/src/Relude/Foldable/Reexport.hs --- a/src/Relude/Foldable/Reexport.hs +++ b/src/Relude/Foldable/Reexport.hs @@ -1,3 +1,11 @@ +{- | +Copyright: (c) 2018 Kowainik +License: MIT +Maintainer: Kowainik + +Reexports "Data.Foldable" and "Data.Traversable". +-} + module Relude.Foldable.Reexport ( module Data.Foldable , module Data.Traversable diff --git a/src/Relude/Function.hs b/src/Relude/Function.hs --- a/src/Relude/Function.hs +++ b/src/Relude/Function.hs @@ -1,11 +1,12 @@ -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | This module reexports very basic and primitive functions and function combinators. +This module reexports very basic and primitive functions and function combinators. +-} module Relude.Function ( module Data.Function diff --git a/src/Relude/Functor.hs b/src/Relude/Functor.hs --- a/src/Relude/Functor.hs +++ b/src/Relude/Functor.hs @@ -1,6 +1,14 @@ {-# LANGUAGE Safe #-} --- | Convenient functions to work with 'Functor'. +{- | +Copyright: (c) 2016 Stephen Diehl + (c) 20016-2018 Serokell + (c) 2018 Kowainik +License: MIT +Maintainer: Kowainik + +Convenient functions to work with 'Functor'. +-} module Relude.Functor ( module Relude.Functor.Fmap diff --git a/src/Relude/Functor/Fmap.hs b/src/Relude/Functor/Fmap.hs --- a/src/Relude/Functor/Fmap.hs +++ b/src/Relude/Functor/Fmap.hs @@ -1,20 +1,33 @@ +{-# LANGUAGE CPP #-} {-# LANGUAGE Safe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | This module contains useful functions to work with 'Functor' type class. +This module contains useful functions to work with 'Functor' type class. +-} module Relude.Functor.Fmap ( (<<$>>) + , (<&>) ) where import Relude.Function ((.)) import Relude.Functor.Reexport (Functor (..)) + +#if MIN_VERSION_base(4,11,0) +import Data.Functor ((<&>)) +#else +import Data.Functor ((<$>)) +-- | Flipped version of '<$>'. +infixl 1 <&> +(<&>) :: Functor f => f a -> (a -> b) -> f b +as <&> f = f <$> as +#endif -- $setup -- >>> import Relude.Base (negate) diff --git a/src/Relude/Functor/Reexport.hs b/src/Relude/Functor/Reexport.hs --- a/src/Relude/Functor/Reexport.hs +++ b/src/Relude/Functor/Reexport.hs @@ -1,13 +1,14 @@ {-# LANGUAGE Safe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | This module reexports functionality regarding 'Functor' type class. +Reexports functionality regarding 'Functor' and 'Bifunctor' typeclasses. +-} module Relude.Functor.Reexport ( module Control.Arrow diff --git a/src/Relude/Lifted.hs b/src/Relude/Lifted.hs --- a/src/Relude/Lifted.hs +++ b/src/Relude/Lifted.hs @@ -1,13 +1,14 @@ {-# LANGUAGE Safe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Lifted versions of base functions. +Lifted versions of base functions. +-} module Relude.Lifted ( module Relude.Lifted.Concurrent diff --git a/src/Relude/Lifted/Concurrent.hs b/src/Relude/Lifted/Concurrent.hs --- a/src/Relude/Lifted/Concurrent.hs +++ b/src/Relude/Lifted/Concurrent.hs @@ -1,13 +1,14 @@ {-# LANGUAGE Safe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Concurrency useful and common functions. +Lifted 'MVar' and 'STM' functions. +-} module Relude.Lifted.Concurrent ( -- * MVar diff --git a/src/Relude/Lifted/Exit.hs b/src/Relude/Lifted/Exit.hs --- a/src/Relude/Lifted/Exit.hs +++ b/src/Relude/Lifted/Exit.hs @@ -1,13 +1,14 @@ {-# LANGUAGE Safe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Lifted versions of functions that work with exit processes. +Lifted versions of functions that work with exit processes. +-} module Relude.Lifted.Exit ( exitWith diff --git a/src/Relude/Lifted/File.hs b/src/Relude/Lifted/File.hs --- a/src/Relude/Lifted/File.hs +++ b/src/Relude/Lifted/File.hs @@ -1,14 +1,15 @@ {-# LANGUAGE Safe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Lifted versions of functions working with files and common IO. --- All functions are specialized to 'Data.Text.Text'. +Lifted versions of functions working with files and common IO. +All functions are specialized to 'Data.Text.Text'. +-} module Relude.Lifted.File ( appendFile diff --git a/src/Relude/Lifted/IORef.hs b/src/Relude/Lifted/IORef.hs --- a/src/Relude/Lifted/IORef.hs +++ b/src/Relude/Lifted/IORef.hs @@ -1,13 +1,14 @@ {-# LANGUAGE Safe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Lifted reexports from 'Data.IORef' module. +Lifted reexports from 'Data.IORef' module. +-} module Relude.Lifted.IORef ( IORef diff --git a/src/Relude/List.hs b/src/Relude/List.hs --- a/src/Relude/List.hs +++ b/src/Relude/List.hs @@ -1,18 +1,19 @@ -{- +{-# LANGUAGE Safe #-} + +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} - -{-# LANGUAGE Safe #-} +License: MIT +Maintainer: Kowainik --- | Utility functions to work with lists. +Utility functions to work with lists. +-} module Relude.List - ( module Relude.List.Reexport - , module Relude.List.Safe + ( module Relude.List.NonEmpty + , module Relude.List.Reexport ) where +import Relude.List.NonEmpty import Relude.List.Reexport -import Relude.List.Safe diff --git a/src/Relude/List/NonEmpty.hs b/src/Relude/List/NonEmpty.hs new file mode 100644 --- /dev/null +++ b/src/Relude/List/NonEmpty.hs @@ -0,0 +1,75 @@ +{-# LANGUAGE Safe #-} + +{- | +Copyright: (c) 2016 Stephen Diehl + (c) 20016-2018 Serokell + (c) 2018 Kowainik +License: MIT +Maintainer: Kowainik + +This module contains safe functions to work with list type in terms of 'NonEmpty'. +-} + +module Relude.List.NonEmpty + ( viaNonEmpty + , uncons + , whenNotNull + , whenNotNullM + ) where + +import Relude.Applicative (Applicative, pass) +import Relude.Function ((.)) +import Relude.Functor (fmap) +import Relude.List.Reexport (NonEmpty (..), nonEmpty) +import Relude.Monad (Maybe (..), Monad (..)) + +-- $setup +-- >>> import Relude.Applicative (pure) +-- >>> import Relude.Base ((==)) +-- >>> import Relude.Bool (Bool (..), not) +-- >>> import Relude.Foldable (length) +-- >>> import Relude.Function (($)) +-- >>> import Relude.List.Reexport (head) +-- >>> import Relude.Print (print) + +{- | For safe work with lists using functinons for 'NonEmpty'. + +>>> viaNonEmpty head [1] +Just 1 +>>> viaNonEmpty head [] +Nothing +-} +viaNonEmpty :: (NonEmpty a -> b) -> [a] -> Maybe b +viaNonEmpty f = fmap f . nonEmpty +{-# INLINE viaNonEmpty #-} + +{- | Destructuring list into its head and tail if possible. This function is total. + +>>> uncons [] +Nothing +>>> uncons [1..5] +Just (1,[2,3,4,5]) +>>> uncons (5 : [1..5]) >>= \(f, l) -> pure $ f == length l +Just True + +-} +uncons :: [a] -> Maybe (a, [a]) +uncons [] = Nothing +uncons (x:xs) = Just (x, xs) + +{- | Performs given action over 'NonEmpty' list if given list is non empty. + +>>> whenNotNull [] $ \(b :| _) -> print (not b) +>>> whenNotNull [False,True] $ \(b :| _) -> print (not b) +True + +-} +whenNotNull :: Applicative f => [a] -> (NonEmpty a -> f ()) -> f () +whenNotNull [] _ = pass +whenNotNull (x:xs) f = f (x :| xs) +{-# INLINE whenNotNull #-} + +-- | Monadic version of 'whenNotNull'. +whenNotNullM :: Monad m => m [a] -> (NonEmpty a -> m ()) -> m () +whenNotNullM ml f = ml >>= \l -> whenNotNull l f +{-# INLINE whenNotNullM #-} diff --git a/src/Relude/List/Reexport.hs b/src/Relude/List/Reexport.hs --- a/src/Relude/List/Reexport.hs +++ b/src/Relude/List/Reexport.hs @@ -1,13 +1,14 @@ {-# LANGUAGE Trustworthy #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | This module reexports functinons to work with list, 'NonEmpty' and String types. +Reexports most of the "Data.List" and "Data.List.NonEmpty". +-} module Relude.List.Reexport ( module Data.List @@ -21,5 +22,4 @@ scanl, scanr, sort, sortBy, sortOn, splitAt, subsequences, tails, take, takeWhile, transpose, unfoldr, unzip, unzip3, zip, zip3, zipWith, (++)) import Data.List.NonEmpty (NonEmpty (..), head, init, last, nonEmpty, tail) - import GHC.Exts (sortWith) diff --git a/src/Relude/List/Safe.hs b/src/Relude/List/Safe.hs deleted file mode 100644 --- a/src/Relude/List/Safe.hs +++ /dev/null @@ -1,75 +0,0 @@ -{-# LANGUAGE Safe #-} - -{- -Copyright: (c) 2016 Stephen Diehl - (c) 20016-2018 Serokell - (c) 2018 Kowainik -License: MIT --} - --- | This module contains safe functions to work with list type (mostly with 'NonEmpty'). - -module Relude.List.Safe - ( viaNonEmpty - , uncons - , whenNotNull - , whenNotNullM - ) where - -import Relude.Applicative (Applicative, pass) -import Relude.Function ((.)) -import Relude.Functor (fmap) -import Relude.List.Reexport (NonEmpty (..), nonEmpty) -import Relude.Monad (Maybe (..), Monad (..)) - --- $setup --- >>> import Relude.Applicative (pure) --- >>> import Relude.Base ((==)) --- >>> import Relude.Bool (Bool (..), not) --- >>> import Relude.Foldable (length) --- >>> import Relude.Function (($)) --- >>> import Relude.List.Reexport (head) --- >>> import Relude.Print (print) - -{- | For safe work with lists using functinons for 'NonEmpty'. - ->>> viaNonEmpty head [1] -Just 1 ->>> viaNonEmpty head [] -Nothing - --} -viaNonEmpty :: (NonEmpty a -> b) -> [a] -> Maybe b -viaNonEmpty f = fmap f . nonEmpty -{-# INLINE viaNonEmpty #-} - -{- | Destructuring list into its head and tail if possible. This function is total. - ->>> uncons [] -Nothing ->>> uncons [1..5] -Just (1,[2,3,4,5]) ->>> uncons (5 : [1..5]) >>= \(f, l) -> pure $ f == length l -Just True - --} -uncons :: [a] -> Maybe (a, [a]) -uncons [] = Nothing -uncons (x:xs) = Just (x, xs) - -{- | Performs given action over 'NonEmpty' list if given list is non empty. - ->>> whenNotNull [] $ \(b :| _) -> print (not b) ->>> whenNotNull [False,True] $ \(b :| _) -> print (not b) -True - --} -whenNotNull :: Applicative f => [a] -> (NonEmpty a -> f ()) -> f () -whenNotNull [] _ = pass -whenNotNull (x:xs) f = f (x :| xs) -{-# INLINE whenNotNull #-} - --- | Monadic version of 'whenNotNull'. -whenNotNullM :: Monad m => m [a] -> (NonEmpty a -> m ()) -> m () -whenNotNullM ml f = ml >>= \l -> whenNotNull l f -{-# INLINE whenNotNullM #-} diff --git a/src/Relude/Monad.hs b/src/Relude/Monad.hs --- a/src/Relude/Monad.hs +++ b/src/Relude/Monad.hs @@ -1,13 +1,14 @@ {-# LANGUAGE Safe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Reexporting useful monadic stuff. +Reexporting useful monadic stuff. +-} module Relude.Monad ( module Relude.Monad.Either diff --git a/src/Relude/Monad/Either.hs b/src/Relude/Monad/Either.hs --- a/src/Relude/Monad/Either.hs +++ b/src/Relude/Monad/Either.hs @@ -1,15 +1,17 @@ +{-# LANGUAGE CPP #-} {-# LANGUAGE Safe #-} {-# OPTIONS_GHC -fno-warn-orphans #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Utilites to work with @Either@ data type. +Utilites to work with @Either@ data type. +-} module Relude.Monad.Either ( fromLeft @@ -38,12 +40,9 @@ import Relude.Monad.Reexport (Either (..), MonadFail (..), either) import Relude.String (IsString, fromString) --- $setup --- >>> import Relude.Bool (Bool (..)) - -instance IsString str => MonadFail (Either str) where - fail = Left . fromString - +#if MIN_VERSION_base(4,10,0) +import Data.Either (fromLeft, fromRight) +#else -- | Extracts value from 'Left' or return given default value. -- -- >>> fromLeft 0 (Left 3) @@ -63,6 +62,13 @@ fromRight :: b -> Either a b -> b fromRight b (Left _) = b fromRight _ (Right b) = b +#endif + +-- $setup +-- >>> import Relude.Bool (Bool (..)) + +instance IsString str => MonadFail (Either str) where + fail = Left . fromString -- | Maps left part of 'Either' to 'Maybe'. -- diff --git a/src/Relude/Monad/Maybe.hs b/src/Relude/Monad/Maybe.hs --- a/src/Relude/Monad/Maybe.hs +++ b/src/Relude/Monad/Maybe.hs @@ -1,13 +1,14 @@ {-# LANGUAGE Safe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Utility functions to work with 'Data.Maybe' data type as monad. +Utility functions to work with 'Data.Maybe' data type as monad. +-} module Relude.Monad.Maybe ( (?:) diff --git a/src/Relude/Monad/Reexport.hs b/src/Relude/Monad/Reexport.hs --- a/src/Relude/Monad/Reexport.hs +++ b/src/Relude/Monad/Reexport.hs @@ -1,13 +1,14 @@ {-# LANGUAGE Safe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | This module reexports functions to work with monads. +Reexports functions to work with monads. +-} module Relude.Monad.Reexport ( -- * Reexport transformers @@ -31,7 +32,8 @@ -- Monad transformers import Control.Monad.Except (ExceptT (..), runExceptT) -import Control.Monad.Reader (MonadReader, Reader, ReaderT (..), ask, asks, local, reader, runReader) +import Control.Monad.Reader (MonadReader, Reader, ReaderT (..), ask, asks, local, reader, runReader, + withReader, withReaderT) import Control.Monad.State.Strict (MonadState, State, StateT (..), evalState, evalStateT, execState, execStateT, get, gets, modify, modify', put, runState, state, withState) diff --git a/src/Relude/Monad/Trans.hs b/src/Relude/Monad/Trans.hs --- a/src/Relude/Monad/Trans.hs +++ b/src/Relude/Monad/Trans.hs @@ -1,13 +1,14 @@ {-# LANGUAGE Safe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Monad transformers utilities. +Monad transformers utilities. +-} module Relude.Monad.Trans ( -- * Convenient functions to work with 'Reader' monad diff --git a/src/Relude/Monoid.hs b/src/Relude/Monoid.hs --- a/src/Relude/Monoid.hs +++ b/src/Relude/Monoid.hs @@ -1,11 +1,12 @@ -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | This module reexports functions to work with monoids plus adds extra useful functions. +Reexports functions to work with monoids plus adds extra useful functions. +-} module Relude.Monoid ( module Data.Monoid diff --git a/src/Relude/Nub.hs b/src/Relude/Nub.hs --- a/src/Relude/Nub.hs +++ b/src/Relude/Nub.hs @@ -1,11 +1,11 @@ -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik -{-| Functions to remove duplicates from a list. +Functions to remove duplicates from a list. = Performance To check the performance there was done a bunch of benchmarks. diff --git a/src/Relude/Print.hs b/src/Relude/Print.hs --- a/src/Relude/Print.hs +++ b/src/Relude/Print.hs @@ -3,14 +3,15 @@ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE Trustworthy #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Generalization of 'Prelude.putStr' and 'Prelude.putStrLn' functions. +Generalization of 'Prelude.putStr' and 'Prelude.putStrLn' functions. +-} module Relude.Print ( Print (..) diff --git a/src/Relude/String.hs b/src/Relude/String.hs --- a/src/Relude/String.hs +++ b/src/Relude/String.hs @@ -1,11 +1,12 @@ -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | Type classes for convertion between different string representations. +Type classes for convertion between different string representations. +-} module Relude.String ( module Relude.String.Conversion diff --git a/src/Relude/String/Conversion.hs b/src/Relude/String/Conversion.hs --- a/src/Relude/String/Conversion.hs +++ b/src/Relude/String/Conversion.hs @@ -5,18 +5,19 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE TypeSynonymInstances #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | This module implements type class which allow to have conversion to and --- from 'Text', 'String' and 'ByteString' types (including both strict and lazy --- versions). Usually you need to export 'Text' modules qualified and use --- 'T.pack' \/ 'T.unpack' functions to convert to\/from 'Text'. Now you can --- just use 'toText' \/ 'toString' functions. +This module implements type class which allow to have conversion to and from +'Text', 'String' and 'ByteString' types (including both strict and lazy +versions). Usually you need to export 'Text' modules qualified and use 'T.pack' +\/ 'T.unpack' functions to convert to\/from 'Text'. Now you can just use +'toText' \/ 'toString' functions. +-} module Relude.String.Conversion ( -- * Convenient type aliases diff --git a/src/Relude/String/Reexport.hs b/src/Relude/String/Reexport.hs --- a/src/Relude/String/Reexport.hs +++ b/src/Relude/String/Reexport.hs @@ -1,11 +1,12 @@ -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik --- | This module reexports functions to work with 'Text' and 'ByteString' types. +Reexports functions to work with 'Text' and 'ByteString' types. +-} module Relude.String.Reexport ( -- * String diff --git a/src/Relude/Unsafe.hs b/src/Relude/Unsafe.hs --- a/src/Relude/Unsafe.hs +++ b/src/Relude/Unsafe.hs @@ -1,16 +1,15 @@ {-# LANGUAGE Unsafe #-} -{- +{- | Copyright: (c) 2016 Stephen Diehl (c) 20016-2018 Serokell (c) 2018 Kowainik -License: MIT --} +License: MIT +Maintainer: Kowainik -{- | Unsafe functions to work with lists and 'Maybe'. -Sometimes unavoidable but better don't use them. This module -is intended to be imported qualified and it's not even included -in default prelude exports. +Unsafe functions to work with lists and 'Maybe'. Sometimes unavoidable but it's +better not to use them. This module is intended to be imported qualified and +it's not even included in default prelude exports. @ import qualified Relude.Unsafe as Unsafe @@ -18,17 +17,12 @@ foo :: [a] -> a foo = Unsafe.head @ - -} module Relude.Unsafe - ( head - , tail - , init - , last + ( module Data.List + , module Data.Maybe , at - , (!!) - , fromJust ) where import Data.List (head, init, last, tail, (!!)) diff --git a/test/Test/Relude/Property.hs b/test/Test/Relude/Property.hs --- a/test/Test/Relude/Property.hs +++ b/test/Test/Relude/Property.hs @@ -6,27 +6,26 @@ -} module Test.Relude.Property - ( hedgehogTestTree - ) where + ( hedgehogTestTree + ) where import Relude import Data.List (nub) -import Hedgehog (Gen, MonadGen, Property, assert, forAll, property, (===)) +import Hedgehog (Gen, Property, assert, forAll, property, (===)) import Test.Tasty (TestTree, testGroup) import Test.Tasty.Hedgehog -import qualified Data.ByteString as B -import qualified Data.ByteString.Lazy as LB -import qualified Data.Text as T -import qualified Data.Text.Lazy as LT import qualified Hedgehog.Gen as Gen import qualified Hedgehog.Range as Range -import qualified Relude as U hedgehogTestTree :: TestTree hedgehogTestTree = testGroup "Tests" [utfProps, listProps, boolMProps] +---------------------------------------------------------------------------- +-- utf8 conversion +---------------------------------------------------------------------------- + utfProps :: TestTree utfProps = testGroup "utf8 conversion property tests" [ testProperty "String to ByteString invertible" prop_StringToBytes @@ -34,100 +33,94 @@ , testProperty "ByteString to Text or String invertible" prop_BytesTo ] -unicode' :: MonadGen m => m U.Char -unicode' = do - a <- Gen.unicode - if elem a ['\65534', '\65535'] - then unicode' - else return a - -utf8String :: Gen U.String -utf8String = Gen.string (Range.linear 0 10000) unicode' +utf8String :: Gen String +utf8String = Gen.string (Range.linear 0 1000) Gen.unicode -utf8Text :: Gen T.Text -utf8Text = Gen.text (Range.linear 0 10000) unicode' +utf8Text :: Gen Text +utf8Text = Gen.text (Range.linear 0 1000) Gen.unicode -utf8Bytes :: Gen B.ByteString -utf8Bytes = Gen.utf8 (Range.linear 0 10000) unicode' +utf8Bytes :: Gen ByteString +utf8Bytes = Gen.utf8 (Range.linear 0 1000) Gen.unicode -- "\65534" fails, but this is from BU.toString -- > import qualified Data.ByteString.UTF8 as BU -- > BU.toString (BU.fromString "\65534") == "\65533" -- > True - prop_StringToBytes :: Property prop_StringToBytes = property $ do str <- forAll utf8String - assert $ str == (decodeUtf8 (encodeUtf8 str :: B.ByteString)) - && str == (decodeUtf8 (encodeUtf8 str :: LB.ByteString)) + assert $ str == decodeUtf8 @_ @ByteString (encodeUtf8 str) + && str == decodeUtf8 @_ @LByteString (encodeUtf8 str) prop_TextToBytes :: Property prop_TextToBytes = property $ do txt <- forAll utf8Text - assert $ txt == (decodeUtf8 (encodeUtf8 txt :: B.ByteString)) - && txt == (decodeUtf8 (encodeUtf8 txt :: LB.ByteString)) + assert $ txt == decodeUtf8 @_ @ByteString (encodeUtf8 txt) + && txt == decodeUtf8 @_ @LByteString (encodeUtf8 txt) -- "\239\191\190" fails, but this is the same as "\65534" :: String prop_BytesTo :: Property prop_BytesTo = property $ do utf <- forAll utf8Bytes - assert $ utf == (encodeUtf8 (decodeUtf8 utf :: U.String)) - && utf == (encodeUtf8 (decodeUtf8 utf :: T.Text)) - && utf == (encodeUtf8 (decodeUtf8 utf :: LT.Text)) + assert $ utf == encodeUtf8 @String (decodeUtf8 utf) + && utf == encodeUtf8 @Text (decodeUtf8 utf) + && utf == encodeUtf8 @LText (decodeUtf8 utf) +---------------------------------------------------------------------------- -- ordNub +---------------------------------------------------------------------------- listProps :: TestTree listProps = testGroup "list function property tests" - [ testProperty "Hedgehog ordNub xs == nub xs" prop_ordNubCorrect - , testProperty "Hedgehog hashNub xs == nub xs" prop_hashNubCorrect - , testProperty "Hedgehog sortNub xs == sort $ nub xs" prop_sortNubCorrect - , testProperty "Hedgehog sort $ unstableNub xs == sort $ nub xs" prop_unstableNubCorrect + [ testProperty "ordNub xs == nub xs" prop_ordNubCorrect + , testProperty "hashNub xs == nub xs" prop_hashNubCorrect + , testProperty "sortNub xs == sort (nub xs)" prop_sortNubCorrect + , testProperty "sort (unstableNub xs) == sort (nub xs)" prop_unstableNubCorrect ] -genIntList :: Gen [U.Int] -genIntList = Gen.list (Range.linear 0 10000) Gen.enumBounded +genIntList :: Gen [Int] +genIntList = Gen.list (Range.linear 0 1000) Gen.enumBounded prop_ordNubCorrect :: Property prop_ordNubCorrect = property $ do xs <- forAll genIntList - U.ordNub xs === nub xs + ordNub xs === nub xs prop_hashNubCorrect :: Property prop_hashNubCorrect = property $ do xs <- forAll genIntList - U.hashNub xs === nub xs + hashNub xs === ordNub xs prop_sortNubCorrect :: Property prop_sortNubCorrect = property $ do xs <- forAll genIntList - U.sortNub xs === (U.sort $ nub xs) + sortNub xs === sort (ordNub xs) prop_unstableNubCorrect :: Property prop_unstableNubCorrect = property $ do xs <- forAll genIntList - (U.sort $ U.unstableNub xs) === (U.sort $ nub xs) - + sort (unstableNub xs) === sortNub xs +---------------------------------------------------------------------------- -- logicM --- this section needs a little more thought +---------------------------------------------------------------------------- -genBoolList :: Gen [U.Bool] +genBoolList :: Gen [Bool] genBoolList = Gen.list (Range.linear 0 1000) Gen.bool boolMProps :: TestTree boolMProps = testGroup "lifted logic function property tests" - [ testProperty "Hedgehog andM" prop_andM - , testProperty "Hedgehog orM" prop_orM + [ testProperty "andM" prop_andM + , testProperty "orM" prop_orM ] prop_andM :: Property prop_andM = property $ do bs <- forAll genBoolList - U.andM (return <$> bs) === ((return $ U.and bs) :: U.Maybe U.Bool) + andM (pure <$> bs) === pure @Maybe (and bs) prop_orM :: Property prop_orM = property $ do bs <- forAll genBoolList - U.orM (return <$> bs) === ((return $ U.or bs) :: U.Maybe U.Bool) + orM (pure <$> bs) === pure @Maybe (or bs)