| Copyright | (c) 2023 GYELD GMBH |
|---|---|
| License | Apache 2.0 |
| Maintainer | [email protected] |
| Stability | develop |
| Safe Haskell | Safe-Inferred |
| Language | GHC2021 |
GeniusYield.Imports
Contents
Description
Synopsis
- coerce ∷ ∀ {k ∷ RuntimeRep} (a ∷ TYPE k) (b ∷ TYPE k). Coercible a b ⇒ a → b
- guard ∷ Alternative f ⇒ Bool → f ()
- join ∷ Monad m ⇒ m (m a) → m a
- class IsString a where
- fromString ∷ String → a
- liftA2 ∷ Applicative f ⇒ (a → b → c) → f a → f b → f c
- toList ∷ Foldable t ⇒ t a → [a]
- foldl' ∷ Foldable t ⇒ (b → a → b) → b → t a → b
- class Generic a
- data Natural
- type Type = TYPE LiftedRep
- data Constraint
- data CallStack
- forM_ ∷ (Foldable t, Monad m) ⇒ t a → (a → m b) → m ()
- data Set a
- data Map k a
- ap ∷ Monad m ⇒ m (a → b) → m a → m b
- when ∷ Applicative f ⇒ Bool → f () → f ()
- void ∷ Functor f ⇒ f a → f ()
- on ∷ (b → b → c) → (a → b) → a → a → c
- fromMaybe ∷ a → Maybe a → a
- isJust ∷ Maybe a → Bool
- isAlphaNum ∷ Char → Bool
- data Proxy (t ∷ k) = Proxy
- sortBy ∷ (a → a → Ordering) → [a] → [a]
- find ∷ Foldable t ⇒ (a → Bool) → t a → Maybe a
- newtype Const a (b ∷ k) = Const {
- getConst ∷ a
- class (Typeable e, Show e) ⇒ Exception e
- catch ∷ Exception e ⇒ IO a → (e → IO a) → IO a
- throwIO ∷ Exception e ⇒ e → IO a
- newtype Identity a = Identity {
- runIdentity ∷ a
- foldM ∷ (Foldable t, Monad m) ⇒ (b → a → m b) → b → t a → m b
- unless ∷ Applicative f ⇒ Bool → f () → f ()
- absurd ∷ Void → a
- data Void
- data Text
- forM ∷ (Traversable t, Monad m) ⇒ t a → (a → m b) → m (t b)
- class Contravariant (f ∷ Type → Type) where
- class ToJSON a where
- toJSON ∷ a → Value
- toEncoding ∷ a → Encoding
- toJSONList ∷ [a] → Value
- toEncodingList ∷ [a] → Encoding
- class FromJSON a where
- second ∷ Bifunctor p ⇒ (b → c) → p a b → p a c
- bimap ∷ Bifunctor p ⇒ (a → b) → (c → d) → p a c → p b d
- first ∷ Bifunctor p ⇒ (a → b) → p a c → p b c
- class PrintfArg a where
- formatArg ∷ a → FieldFormatter
- parseFormat ∷ a → ModifierParser
- printf ∷ PrintfType r ⇒ String → r
- minimumBy ∷ Foldable t ⇒ (a → a → Ordering) → t a → a
- maximumBy ∷ Foldable t ⇒ (a → a → Ordering) → t a → a
- fromRight ∷ b → Either a b → b
- (>>>) ∷ ∀ {k} cat (a ∷ k) (b ∷ k) (c ∷ k). Category cat ⇒ cat a b → cat b c → cat a c
- data (a ∷ k) :~: (b ∷ k) where
- isHexDigit ∷ Char → Bool
- (&) ∷ a → (a → b) → b
- (<&>) ∷ Functor f ⇒ f a → (a → b) → f b
- type HasCallStack = ?callStack ∷ CallStack
- encodeUtf8 ∷ Text → ByteString
- rightToMaybe ∷ Either a b → Maybe b
- itoList ∷ FoldableWithIndex i f ⇒ f a → [(i, a)]
- ifor_ ∷ (FoldableWithIndex i t, Applicative f) ⇒ t a → (i → a → f b) → f ()
- data Some (tag ∷ k → Type) where
- withSome ∷ Some tag → (∀ (a ∷ k). tag a → b) → b
- mapMaybe ∷ Filterable f ⇒ (a → Maybe b) → f a → f b
- catMaybes ∷ Filterable f ⇒ f (Maybe a) → f a
- wither ∷ (Witherable t, Applicative f) ⇒ (a → f (Maybe b)) → t a → f (t b)
- iwither ∷ (WitherableWithIndex i t, Applicative f) ⇒ (i → a → f (Maybe b)) → t a → f (t b)
- pattern TODO ∷ () ⇒ HasCallStack ⇒ a
- findFirst ∷ Foldable f ⇒ (a → Maybe b) → f a → Maybe b
- decodeUtf8Lenient ∷ ByteString → Text
- lazyDecodeUtf8Lenient ∷ ByteString → Text
- hush ∷ Either e a → Maybe a
- hoistMaybe ∷ Applicative m ⇒ Maybe b → MaybeT m b
Documentation
coerce ∷ ∀ {k ∷ RuntimeRep} (a ∷ TYPE k) (b ∷ TYPE k). Coercible a b ⇒ a → b Source #
The function coerce allows you to safely convert between values of
types that have the same representation with no run-time overhead. In the
simplest case you can use it instead of a newtype constructor, to go from
the newtype's concrete type to the abstract type. But it also works in
more complicated settings, e.g. converting a list of newtypes to a list of
concrete types.
This function is runtime-representation polymorphic, but the
RuntimeRep type argument is marked as Inferred, meaning
that it is not available for visible type application. This means
the typechecker will accept coerce @Int @Age 42.
guard ∷ Alternative f ⇒ Bool → f () Source #
Conditional failure of Alternative computations. Defined by
guard True =pure() guard False =empty
Examples
Common uses of guard include conditionally signaling an error in
an error monad and conditionally rejecting the current choice in an
Alternative-based parser.
As an example of signaling an error in the error monad Maybe,
consider a safe division function safeDiv x y that returns
Nothing when the denominator y is zero and Just (x `div`
y)
>>>safeDiv 4 0Nothing
>>>safeDiv 4 2Just 2
A definition of safeDiv using guards, but not guard:
safeDiv :: Int -> Int -> Maybe Int
safeDiv x y | y /= 0 = Just (x `div` y)
| otherwise = Nothing
A definition of safeDiv using guard and Monad do-notation:
safeDiv :: Int -> Int -> Maybe Int safeDiv x y = do guard (y /= 0) return (x `div` y)
join ∷ Monad m ⇒ m (m a) → m a Source #
The join function is the conventional monad join operator. It
is used to remove one level of monadic structure, projecting its
bound argument into the outer level.
'join bssdo expression
do bs <- bss bs
Examples
A common use of join is to run an IO computation returned from
an STM transaction, since STM transactions
can't perform IO directly. Recall that
atomically :: STM a -> IO a
is used to run STM transactions atomically. So, by
specializing the types of atomically and join to
atomically:: STM (IO b) -> IO (IO b)join:: IO (IO b) -> IO b
we can compose them as
join.atomically:: STM (IO b) -> IO b
class IsString a where Source #
Class for string-like datastructures; used by the overloaded string extension (-XOverloadedStrings in GHC).
Methods
fromString ∷ String → a Source #
Instances
liftA2 ∷ Applicative f ⇒ (a → b → c) → f a → f b → f c Source #
Lift a binary function to actions.
Some functors support an implementation of liftA2 that is more
efficient than the default one. In particular, if fmap is an
expensive operation, it is likely better to use liftA2 than to
fmap over the structure and then use <*>.
This became a typeclass method in 4.10.0.0. Prior to that, it was
a function defined in terms of <*> and fmap.
Example
>>>liftA2 (,) (Just 3) (Just 5)Just (3,5)
toList ∷ Foldable t ⇒ t a → [a] Source #
List of elements of a structure, from left to right. If the entire list is intended to be reduced via a fold, just fold the structure directly bypassing the list.
Examples
Basic usage:
>>>toList Nothing[]
>>>toList (Just 42)[42]
>>>toList (Left "foo")[]
>>>toList (Node (Leaf 5) 17 (Node Empty 12 (Leaf 8)))[5,17,12,8]
For lists, toList is the identity:
>>>toList [1, 2, 3][1,2,3]
Since: base-4.8.0.0
foldl' ∷ Foldable t ⇒ (b → a → b) → b → t a → b Source #
Left-associative fold of a structure but with strict application of the operator.
This ensures that each step of the fold is forced to Weak Head Normal
Form before being applied, avoiding the collection of thunks that would
otherwise occur. This is often what you want to strictly reduce a
finite structure to a single strict result (e.g. sum).
For a general Foldable structure this should be semantically identical
to,
foldl' f z =foldl'f z .toList
Since: base-4.6.0.0
Representable types of kind *.
This class is derivable in GHC with the DeriveGeneric flag on.
A Generic instance must satisfy the following laws:
from.to≡idto.from≡id
Instances
Natural number
Invariant: numbers <= 0xffffffffffffffff use the NS constructor
Instances
data Constraint Source #
The kind of constraints, like Show a
CallStacks are a lightweight method of obtaining a
partial call-stack at any point in the program.
A function can request its call-site with the HasCallStack constraint.
For example, we can define
putStrLnWithCallStack :: HasCallStack => String -> IO ()
as a variant of putStrLn that will get its call-site and print it,
along with the string given as argument. We can access the
call-stack inside putStrLnWithCallStack with callStack.
>>>:{putStrLnWithCallStack :: HasCallStack => String -> IO () putStrLnWithCallStack msg = do putStrLn msg putStrLn (prettyCallStack callStack) :}
Thus, if we call putStrLnWithCallStack we will get a formatted call-stack
alongside our string.
>>>putStrLnWithCallStack "hello"hello CallStack (from HasCallStack): putStrLnWithCallStack, called at <interactive>:... in interactive:Ghci...
GHC solves HasCallStack constraints in three steps:
- If there is a
CallStackin scope -- i.e. the enclosing function has aHasCallStackconstraint -- GHC will append the new call-site to the existingCallStack. - If there is no
CallStackin scope -- e.g. in the GHCi session above -- and the enclosing definition does not have an explicit type signature, GHC will infer aHasCallStackconstraint for the enclosing definition (subject to the monomorphism restriction). - If there is no
CallStackin scope and the enclosing definition has an explicit type signature, GHC will solve theHasCallStackconstraint for the singletonCallStackcontaining just the current call-site.
CallStacks do not interact with the RTS and do not require compilation
with -prof. On the other hand, as they are built up explicitly via the
HasCallStack constraints, they will generally not contain as much
information as the simulated call-stacks maintained by the RTS.
A CallStack is a [(String, SrcLoc)]. The String is the name of
function that was called, the SrcLoc is the call-site. The list is
ordered with the most recently called function at the head.
NOTE: The intrepid user may notice that HasCallStack is just an
alias for an implicit parameter ?callStack :: CallStack. This is an
implementation detail and should not be considered part of the
CallStack API, we may decide to change the implementation in the
future.
Since: base-4.8.1.0
Instances
| IsList CallStack | Be aware that 'fromList . toList = id' only for unfrozen Since: base-4.9.0.0 |
| Show CallStack | Since: base-4.9.0.0 |
| NFData CallStack | Since: deepseq-1.4.2.0 |
Defined in Control.DeepSeq | |
| NoThunks CallStack | Since CallStacks can't retain application data, we don't want to check them for thunks at all |
| type Item CallStack | |
| type Code CallStack | |
| type DatatypeInfoOf CallStack | |
Defined in Generics.SOP.Instances type DatatypeInfoOf CallStack = 'ADT "GHC.Stack.Types" "CallStack" '['Constructor "EmptyCallStack", 'Constructor "PushCallStack", 'Constructor "FreezeCallStack"] '['[] ∷ [StrictnessInfo], '['StrictnessInfo 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy, 'StrictnessInfo 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy, 'StrictnessInfo 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy], '['StrictnessInfo 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy]] | |
A set of values a.
Instances
| ToJSON1 Set | |
Defined in Data.Aeson.Types.ToJSON Methods liftToJSON ∷ (a → Value) → ([a] → Value) → Set a → Value Source # liftToJSONList ∷ (a → Value) → ([a] → Value) → [Set a] → Value Source # liftToEncoding ∷ (a → Encoding) → ([a] → Encoding) → Set a → Encoding Source # liftToEncodingList ∷ (a → Encoding) → ([a] → Encoding) → [Set a] → Encoding Source # | |
| Foldable Set | Folds in order of increasing key. |
Defined in Data.Set.Internal Methods fold ∷ Monoid m ⇒ Set m → m Source # foldMap ∷ Monoid m ⇒ (a → m) → Set a → m Source # foldMap' ∷ Monoid m ⇒ (a → m) → Set a → m Source # foldr ∷ (a → b → b) → b → Set a → b Source # foldr' ∷ (a → b → b) → b → Set a → b Source # foldl ∷ (b → a → b) → b → Set a → b Source # foldl' ∷ (b → a → b) → b → Set a → b Source # foldr1 ∷ (a → a → a) → Set a → a Source # foldl1 ∷ (a → a → a) → Set a → a Source # elem ∷ Eq a ⇒ a → Set a → Bool Source # maximum ∷ Ord a ⇒ Set a → a Source # minimum ∷ Ord a ⇒ Set a → a Source # | |
| Eq1 Set | Since: containers-0.5.9 |
| Ord1 Set | Since: containers-0.5.9 |
Defined in Data.Set.Internal | |
| Show1 Set | Since: containers-0.5.9 |
| Hashable1 Set | Since: hashable-1.3.4.0 |
Defined in Data.Hashable.Class | |
| Ord k ⇒ Indexable k (Set k) | |
Defined in Cardano.Ledger.Alonzo.Tx | |
| Structured k ⇒ Structured (Set k) | |
Defined in Distribution.Utils.Structured | |
| (Ord a, FromJSON a) ⇒ FromJSON (Set a) | |
| ToJSON a ⇒ ToJSON (Set a) | |
| (Data a, Ord a) ⇒ Data (Set a) | |
Defined in Data.Set.Internal Methods gfoldl ∷ (∀ d b. Data d ⇒ c (d → b) → d → c b) → (∀ g. g → c g) → Set a → c (Set a) Source # gunfold ∷ (∀ b r. Data b ⇒ c (b → r) → c r) → (∀ r. r → c r) → Constr → c (Set a) Source # toConstr ∷ Set a → Constr Source # dataTypeOf ∷ Set a → DataType Source # dataCast1 ∷ Typeable t ⇒ (∀ d. Data d ⇒ c (t d)) → Maybe (c (Set a)) Source # dataCast2 ∷ Typeable t ⇒ (∀ d e. (Data d, Data e) ⇒ c (t d e)) → Maybe (c (Set a)) Source # gmapT ∷ (∀ b. Data b ⇒ b → b) → Set a → Set a Source # gmapQl ∷ (r → r' → r) → r → (∀ d. Data d ⇒ d → r') → Set a → r Source # gmapQr ∷ ∀ r r'. (r' → r → r) → r → (∀ d. Data d ⇒ d → r') → Set a → r Source # gmapQ ∷ (∀ d. Data d ⇒ d → u) → Set a → [u] Source # gmapQi ∷ Int → (∀ d. Data d ⇒ d → u) → Set a → u Source # gmapM ∷ Monad m ⇒ (∀ d. Data d ⇒ d → m d) → Set a → m (Set a) Source # gmapMp ∷ MonadPlus m ⇒ (∀ d. Data d ⇒ d → m d) → Set a → m (Set a) Source # gmapMo ∷ MonadPlus m ⇒ (∀ d. Data d ⇒ d → m d) → Set a → m (Set a) Source # | |
| Ord a ⇒ Monoid (Set a) | |
| Ord a ⇒ Semigroup (Set a) | Since: containers-0.5.7 |
| Ord a ⇒ IsList (Set a) | Since: containers-0.5.6.2 |
| (Read a, Ord a) ⇒ Read (Set a) | |
| Show a ⇒ Show (Set a) | |
| (Ord a, FromCBOR a) ⇒ FromCBOR (Set a) | |
| (Ord a, ToCBOR a) ⇒ ToCBOR (Set a) | |
| (Ord a, DecCBOR a) ⇒ DecCBOR (Set a) | |
| (Ord a, EncCBOR a) ⇒ EncCBOR (Set a) | |
| NFData a ⇒ NFData (Set a) | |
Defined in Data.Set.Internal | |
| Eq a ⇒ Eq (Set a) | |
| Ord a ⇒ Ord (Set a) | |
| Hashable v ⇒ Hashable (Set v) | Since: hashable-1.3.4.0 |
| Ord k ⇒ At (Set k) | |
| Ord a ⇒ Contains (Set a) | |
| Ord k ⇒ Ixed (Set k) | |
Defined in Control.Lens.At | |
| Ord a ⇒ Wrapped (Set a) | |
| Ord element ⇒ IsSet (Set element) | |
Defined in Data.Containers Methods insertSet ∷ Element (Set element) → Set element → Set element Source # deleteSet ∷ Element (Set element) → Set element → Set element Source # singletonSet ∷ Element (Set element) → Set element Source # setFromList ∷ [Element (Set element)] → Set element Source # setToList ∷ Set element → [Element (Set element)] Source # filterSet ∷ (Element (Set element) → Bool) → Set element → Set element Source # | |
| Ord element ⇒ SetContainer (Set element) | |
Defined in Data.Containers Associated Types type ContainerKey (Set element) Source # Methods member ∷ ContainerKey (Set element) → Set element → Bool Source # notMember ∷ ContainerKey (Set element) → Set element → Bool Source # union ∷ Set element → Set element → Set element Source # unions ∷ (MonoFoldable mono, Element mono ~ Set element) ⇒ mono → Set element Source # difference ∷ Set element → Set element → Set element Source # intersection ∷ Set element → Set element → Set element Source # | |
| Ord v ⇒ GrowingAppend (Set v) | |
Defined in Data.MonoTraversable | |
| Ord e ⇒ MonoFoldable (Set e) | |
Defined in Data.MonoTraversable Methods ofoldMap ∷ Monoid m ⇒ (Element (Set e) → m) → Set e → m Source # ofoldr ∷ (Element (Set e) → b → b) → b → Set e → b Source # ofoldl' ∷ (a → Element (Set e) → a) → a → Set e → a Source # otoList ∷ Set e → [Element (Set e)] Source # oall ∷ (Element (Set e) → Bool) → Set e → Bool Source # oany ∷ (Element (Set e) → Bool) → Set e → Bool Source # olength ∷ Set e → Int Source # olength64 ∷ Set e → Int64 Source # ocompareLength ∷ Integral i ⇒ Set e → i → Ordering Source # otraverse_ ∷ Applicative f ⇒ (Element (Set e) → f b) → Set e → f () Source # ofor_ ∷ Applicative f ⇒ Set e → (Element (Set e) → f b) → f () Source # omapM_ ∷ Applicative m ⇒ (Element (Set e) → m ()) → Set e → m () Source # oforM_ ∷ Applicative m ⇒ Set e → (Element (Set e) → m ()) → m () Source # ofoldlM ∷ Monad m ⇒ (a → Element (Set e) → m a) → a → Set e → m a Source # ofoldMap1Ex ∷ Semigroup m ⇒ (Element (Set e) → m) → Set e → m Source # ofoldr1Ex ∷ (Element (Set e) → Element (Set e) → Element (Set e)) → Set e → Element (Set e) Source # ofoldl1Ex' ∷ (Element (Set e) → Element (Set e) → Element (Set e)) → Set e → Element (Set e) Source # headEx ∷ Set e → Element (Set e) Source # lastEx ∷ Set e → Element (Set e) Source # unsafeHead ∷ Set e → Element (Set e) Source # unsafeLast ∷ Set e → Element (Set e) Source # maximumByEx ∷ (Element (Set e) → Element (Set e) → Ordering) → Set e → Element (Set e) Source # minimumByEx ∷ (Element (Set e) → Element (Set e) → Ordering) → Set e → Element (Set e) Source # | |
| MonoPointed (Set a) | |
| Ord a ⇒ MonoidNull (Set a) | |
| Ord a ⇒ PositiveMonoid (Set a) | |
Defined in Data.Monoid.Null | |
| NoThunks a ⇒ NoThunks (Set a) | |
| Ord k ⇒ At (Set k) | |
| Ord a ⇒ Contains (Set a) | |
| Ord k ⇒ Ixed (Set k) | |
| (Ord a, Serialise a) ⇒ Serialise (Set a) | Since: serialise-0.2.0.0 |
| ToParamSchema a ⇒ ToParamSchema (Set a) | |
Defined in Data.Swagger.Internal.ParamSchema Methods toParamSchema ∷ ∀ (t ∷ SwaggerKind Type). Proxy (Set a) → ParamSchema t Source # | |
| ToSchema a ⇒ ToSchema (Set a) | |
Defined in Data.Swagger.Internal.Schema Methods declareNamedSchema ∷ Proxy (Set a) → Declare (Definitions Schema) NamedSchema Source # | |
| (t ~ Set a', Ord a) ⇒ Rewrapped (Set a) t | Use |
Defined in Control.Lens.Wrapped | |
| type Item (Set a) | |
Defined in Data.Set.Internal | |
| type Index (Set a) | |
Defined in Control.Lens.At | |
| type IxValue (Set k) | |
Defined in Control.Lens.At | |
| type Unwrapped (Set a) | |
Defined in Control.Lens.Wrapped | |
| type ContainerKey (Set element) | |
Defined in Data.Containers | |
| type Element (Set e) | |
Defined in Data.MonoTraversable | |
| type Index (Set a) | |
Defined in Optics.At.Core | |
| type IxKind (Set k) | |
Defined in Optics.At.Core | |
| type IxValue (Set k) | |
Defined in Optics.At.Core | |
A Map from keys k to values a.
The Semigroup operation for Map is union, which prefers
values from the left operand. If m1 maps a key k to a value
a1, and m2 maps the same key to a different value a2, then
their union m1 <> m2 maps k to a1.
Instances
| Bifoldable Map | Since: containers-0.6.3.1 |
| Eq2 Map | Since: containers-0.5.9 |
| Ord2 Map | Since: containers-0.5.9 |
Defined in Data.Map.Internal | |
| Show2 Map | Since: containers-0.5.9 |
| Hashable2 Map | Since: hashable-1.3.4.0 |
| BiPolyMap Map | |
Defined in Data.Containers Associated Types type BPMKeyConstraint Map key Source # Methods mapKeysWith ∷ (BPMKeyConstraint Map k1, BPMKeyConstraint Map k2) ⇒ (v → v → v) → (k1 → k2) → Map k1 v → Map k2 v Source # | |
| FoldableWithIndex k (Map k) | |
| FunctorWithIndex k (Map k) | |
| TraversableWithIndex k (Map k) | |
| FilterableWithIndex k (Map k) | |
| WitherableWithIndex k (Map k) | |
| Ord k ⇒ Indexable k (Map k v) | |
Defined in Cardano.Ledger.Alonzo.Tx | |
| (FromJSONKey k, Ord k) ⇒ FromJSON1 (Map k) | |
| ToJSONKey k ⇒ ToJSON1 (Map k) | |
Defined in Data.Aeson.Types.ToJSON Methods liftToJSON ∷ (a → Value) → ([a] → Value) → Map k a → Value Source # liftToJSONList ∷ (a → Value) → ([a] → Value) → [Map k a] → Value Source # liftToEncoding ∷ (a → Encoding) → ([a] → Encoding) → Map k a → Encoding Source # liftToEncodingList ∷ (a → Encoding) → ([a] → Encoding) → [Map k a] → Encoding Source # | |
| Foldable (Map k) | Folds in order of increasing key. |
Defined in Data.Map.Internal Methods fold ∷ Monoid m ⇒ Map k m → m Source # foldMap ∷ Monoid m ⇒ (a → m) → Map k a → m Source # foldMap' ∷ Monoid m ⇒ (a → m) → Map k a → m Source # foldr ∷ (a → b → b) → b → Map k a → b Source # foldr' ∷ (a → b → b) → b → Map k a → b Source # foldl ∷ (b → a → b) → b → Map k a → b Source # foldl' ∷ (b → a → b) → b → Map k a → b Source # foldr1 ∷ (a → a → a) → Map k a → a Source # foldl1 ∷ (a → a → a) → Map k a → a Source # toList ∷ Map k a → [a] Source # null ∷ Map k a → Bool Source # length ∷ Map k a → Int Source # elem ∷ Eq a ⇒ a → Map k a → Bool Source # maximum ∷ Ord a ⇒ Map k a → a Source # minimum ∷ Ord a ⇒ Map k a → a Source # | |
| Eq k ⇒ Eq1 (Map k) | Since: containers-0.5.9 |
| Ord k ⇒ Ord1 (Map k) | Since: containers-0.5.9 |
Defined in Data.Map.Internal | |
| (Ord k, Read k) ⇒ Read1 (Map k) | Since: containers-0.5.9 |
Defined in Data.Map.Internal | |
| Show k ⇒ Show1 (Map k) | Since: containers-0.5.9 |
| Traversable (Map k) | Traverses in order of increasing key. |
| Functor (Map k) | |
| Hashable k ⇒ Hashable1 (Map k) | Since: hashable-1.3.4.0 |
Defined in Data.Hashable.Class | |
| Ord key ⇒ PolyMap (Map key) | This instance uses the functions from Data.Map.Strict. |
Defined in Data.Containers | |
| Filterable (Map k) | |
| Witherable (Map k) | |
Defined in Witherable Methods wither ∷ Applicative f ⇒ (a → f (Maybe b)) → Map k a → f (Map k b) Source # witherM ∷ Monad m ⇒ (a → m (Maybe b)) → Map k a → m (Map k b) Source # filterA ∷ Applicative f ⇒ (a → f Bool) → Map k a → f (Map k a) Source # witherMap ∷ Applicative m ⇒ (Map k b → r) → (a → m (Maybe b)) → Map k a → m r Source # | |
| Embed (PoolDistr c) (Map (KeyHash 'StakePool c) (IndividualPoolStake c)) | We can Embed a Newtype around a Map (or other Iterable type) and then use it in a set expression. |
| HasExp (PoolDistr c) (Map (KeyHash 'StakePool c) (IndividualPoolStake c)) | |
Defined in Cardano.Ledger.PoolDistr | |
| (Structured k, Structured v) ⇒ Structured (Map k v) | |
Defined in Distribution.Utils.Structured | |
| (FromJSONKey k, Ord k, FromJSON v) ⇒ FromJSON (Map k v) | |
| (ToJSON v, ToJSONKey k) ⇒ ToJSON (Map k v) | |
| (Data k, Data a, Ord k) ⇒ Data (Map k a) | |
Defined in Data.Map.Internal Methods gfoldl ∷ (∀ d b. Data d ⇒ c (d → b) → d → c b) → (∀ g. g → c g) → Map k a → c (Map k a) Source # gunfold ∷ (∀ b r. Data b ⇒ c (b → r) → c r) → (∀ r. r → c r) → Constr → c (Map k a) Source # toConstr ∷ Map k a → Constr Source # dataTypeOf ∷ Map k a → DataType Source # dataCast1 ∷ Typeable t ⇒ (∀ d. Data d ⇒ c (t d)) → Maybe (c (Map k a)) Source # dataCast2 ∷ Typeable t ⇒ (∀ d e. (Data d, Data e) ⇒ c (t d e)) → Maybe (c (Map k a)) Source # gmapT ∷ (∀ b. Data b ⇒ b → b) → Map k a → Map k a Source # gmapQl ∷ (r → r' → r) → r → (∀ d. Data d ⇒ d → r') → Map k a → r Source # gmapQr ∷ ∀ r r'. (r' → r → r) → r → (∀ d. Data d ⇒ d → r') → Map k a → r Source # gmapQ ∷ (∀ d. Data d ⇒ d → u) → Map k a → [u] Source # gmapQi ∷ Int → (∀ d. Data d ⇒ d → u) → Map k a → u Source # gmapM ∷ Monad m ⇒ (∀ d. Data d ⇒ d → m d) → Map k a → m (Map k a) Source # gmapMp ∷ MonadPlus m ⇒ (∀ d. Data d ⇒ d → m d) → Map k a → m (Map k a) Source # gmapMo ∷ MonadPlus m ⇒ (∀ d. Data d ⇒ d → m d) → Map k a → m (Map k a) Source # | |
| Ord k ⇒ Monoid (Map k v) | |
| Ord k ⇒ Semigroup (Map k v) | |
| Ord k ⇒ IsList (Map k v) | Since: containers-0.5.6.2 |
| (Ord k, Read k, Read e) ⇒ Read (Map k e) | |
| (Show k, Show a) ⇒ Show (Map k a) | |
| (Ord k, FromCBOR k, FromCBOR v) ⇒ FromCBOR (Map k v) | |
| (Ord k, ToCBOR k, ToCBOR v) ⇒ ToCBOR (Map k v) | |
| (Ord k, DecCBOR k, DecCBOR v) ⇒ DecCBOR (Map k v) | |
| (Ord k, DecCBOR k, DecCBOR v) ⇒ DecShareCBOR (Map k v) | |
| (Ord k, EncCBOR k, EncCBOR v) ⇒ EncCBOR (Map k v) | |
| (FromField a, FromField b, Ord a) ⇒ FromNamedRecord (Map a b) | |
Defined in Data.Csv.Conversion Methods parseNamedRecord ∷ NamedRecord → Parser (Map a b) Source # | |
| (ToField a, ToField b, Ord a) ⇒ ToNamedRecord (Map a b) | |
Defined in Data.Csv.Conversion Methods toNamedRecord ∷ Map a b → NamedRecord Source # | |
| (NFData k, NFData a) ⇒ NFData (Map k a) | |
Defined in Data.Map.Internal | |
| (Eq k, Eq a) ⇒ Eq (Map k a) | |
| (Ord k, Ord v) ⇒ Ord (Map k v) | |
Defined in Data.Map.Internal | |
| (Hashable k, Hashable v) ⇒ Hashable (Map k v) | Since: hashable-1.3.4.0 |
| (Ord k, FromFormKey k, FromHttpApiData v) ⇒ FromForm (Map k [v]) | |
| (ToFormKey k, ToHttpApiData v) ⇒ ToForm (Map k [v]) | |
| Ord k ⇒ At (Map k a) | |
| Ord k ⇒ Ixed (Map k a) | |
Defined in Control.Lens.At | |
| Ord k ⇒ Wrapped (Map k a) | |
| Ord k ⇒ HasKeysSet (Map k v) | |
| Ord key ⇒ IsMap (Map key value) | This instance uses the functions from Data.Map.Strict. |
Defined in Data.Containers Methods lookup ∷ ContainerKey (Map key value) → Map key value → Maybe (MapValue (Map key value)) Source # insertMap ∷ ContainerKey (Map key value) → MapValue (Map key value) → Map key value → Map key value Source # deleteMap ∷ ContainerKey (Map key value) → Map key value → Map key value Source # singletonMap ∷ ContainerKey (Map key value) → MapValue (Map key value) → Map key value Source # mapFromList ∷ [(ContainerKey (Map key value), MapValue (Map key value))] → Map key value Source # mapToList ∷ Map key value → [(ContainerKey (Map key value), MapValue (Map key value))] Source # findWithDefault ∷ MapValue (Map key value) → ContainerKey (Map key value) → Map key value → MapValue (Map key value) Source # insertWith ∷ (MapValue (Map key value) → MapValue (Map key value) → MapValue (Map key value)) → ContainerKey (Map key value) → MapValue (Map key value) → Map key value → Map key value Source # insertWithKey ∷ (ContainerKey (Map key value) → MapValue (Map key value) → MapValue (Map key value) → MapValue (Map key value)) → ContainerKey (Map key value) → MapValue (Map key value) → Map key value → Map key value Source # insertLookupWithKey ∷ (ContainerKey (Map key value) → MapValue (Map key value) → MapValue (Map key value) → MapValue (Map key value)) → ContainerKey (Map key value) → MapValue (Map key value) → Map key value → (Maybe (MapValue (Map key value)), Map key value) Source # adjustMap ∷ (MapValue (Map key value) → MapValue (Map key value)) → ContainerKey (Map key value) → Map key value → Map key value Source # adjustWithKey ∷ (ContainerKey (Map key value) → MapValue (Map key value) → MapValue (Map key value)) → ContainerKey (Map key value) → Map key value → Map key value Source # updateMap ∷ (MapValue (Map key value) → Maybe (MapValue (Map key value))) → ContainerKey (Map key value) → Map key value → Map key value Source # updateWithKey ∷ (ContainerKey (Map key value) → MapValue (Map key value) → Maybe (MapValue (Map key value))) → ContainerKey (Map key value) → Map key value → Map key value Source # updateLookupWithKey ∷ (ContainerKey (Map key value) → MapValue (Map key value) → Maybe (MapValue (Map key value))) → ContainerKey (Map key value) → Map key value → (Maybe (MapValue (Map key value)), Map key value) Source # alterMap ∷ (Maybe (MapValue (Map key value)) → Maybe (MapValue (Map key value))) → ContainerKey (Map key value) → Map key value → Map key value Source # unionWith ∷ (MapValue (Map key value) → MapValue (Map key value) → MapValue (Map key value)) → Map key value → Map key value → Map key value Source # unionWithKey ∷ (ContainerKey (Map key value) → MapValue (Map key value) → MapValue (Map key value) → MapValue (Map key value)) → Map key value → Map key value → Map key value Source # unionsWith ∷ (MapValue (Map key value) → MapValue (Map key value) → MapValue (Map key value)) → [Map key value] → Map key value Source # mapWithKey ∷ (ContainerKey (Map key value) → MapValue (Map key value) → MapValue (Map key value)) → Map key value → Map key value Source # omapKeysWith ∷ (MapValue (Map key value) → MapValue (Map key value) → MapValue (Map key value)) → (ContainerKey (Map key value) → ContainerKey (Map key value)) → Map key value → Map key value Source # filterMap ∷ (MapValue (Map key value) → Bool) → Map key value → Map key value Source # | |
| Ord k ⇒ SetContainer (Map k v) | This instance uses the functions from Data.Map.Strict. |
Defined in Data.Containers Associated Types type ContainerKey (Map k v) Source # Methods member ∷ ContainerKey (Map k v) → Map k v → Bool Source # notMember ∷ ContainerKey (Map k v) → Map k v → Bool Source # union ∷ Map k v → Map k v → Map k v Source # unions ∷ (MonoFoldable mono, Element mono ~ Map k v) ⇒ mono → Map k v Source # difference ∷ Map k v → Map k v → Map k v Source # | |
| Ord k ⇒ GrowingAppend (Map k v) | |
Defined in Data.MonoTraversable | |
| MonoFoldable (Map k v) | |
Defined in Data.MonoTraversable Methods ofoldMap ∷ Monoid m ⇒ (Element (Map k v) → m) → Map k v → m Source # ofoldr ∷ (Element (Map k v) → b → b) → b → Map k v → b Source # ofoldl' ∷ (a → Element (Map k v) → a) → a → Map k v → a Source # otoList ∷ Map k v → [Element (Map k v)] Source # oall ∷ (Element (Map k v) → Bool) → Map k v → Bool Source # oany ∷ (Element (Map k v) → Bool) → Map k v → Bool Source # onull ∷ Map k v → Bool Source # olength ∷ Map k v → Int Source # olength64 ∷ Map k v → Int64 Source # ocompareLength ∷ Integral i ⇒ Map k v → i → Ordering Source # otraverse_ ∷ Applicative f ⇒ (Element (Map k v) → f b) → Map k v → f () Source # ofor_ ∷ Applicative f ⇒ Map k v → (Element (Map k v) → f b) → f () Source # omapM_ ∷ Applicative m ⇒ (Element (Map k v) → m ()) → Map k v → m () Source # oforM_ ∷ Applicative m ⇒ Map k v → (Element (Map k v) → m ()) → m () Source # ofoldlM ∷ Monad m ⇒ (a → Element (Map k v) → m a) → a → Map k v → m a Source # ofoldMap1Ex ∷ Semigroup m ⇒ (Element (Map k v) → m) → Map k v → m Source # ofoldr1Ex ∷ (Element (Map k v) → Element (Map k v) → Element (Map k v)) → Map k v → Element (Map k v) Source # ofoldl1Ex' ∷ (Element (Map k v) → Element (Map k v) → Element (Map k v)) → Map k v → Element (Map k v) Source # headEx ∷ Map k v → Element (Map k v) Source # lastEx ∷ Map k v → Element (Map k v) Source # unsafeHead ∷ Map k v → Element (Map k v) Source # unsafeLast ∷ Map k v → Element (Map k v) Source # maximumByEx ∷ (Element (Map k v) → Element (Map k v) → Ordering) → Map k v → Element (Map k v) Source # minimumByEx ∷ (Element (Map k v) → Element (Map k v) → Ordering) → Map k v → Element (Map k v) Source # | |
| MonoFunctor (Map k v) | |
| MonoTraversable (Map k v) | |
| Ord k ⇒ MonoidNull (Map k v) | |
| Ord k ⇒ PositiveMonoid (Map k v) | |
Defined in Data.Monoid.Null | |
| (NoThunks k, NoThunks v) ⇒ NoThunks (Map k v) | |
| Ord k ⇒ At (Map k a) | |
| Ord k ⇒ Ixed (Map k a) | |
| (Ord k, Serialise k, Serialise v) ⇒ Serialise (Map k v) | Since: serialise-0.2.0.0 |
| (ToJSONKey k, ToSchema k, ToSchema v) ⇒ ToSchema (Map k v) | |
Defined in Data.Swagger.Internal.Schema Methods declareNamedSchema ∷ Proxy (Map k v) → Declare (Definitions Schema) NamedSchema Source # | |
| (t ~ Map k' a', Ord k) ⇒ Rewrapped (Map k a) t | Use |
Defined in Control.Lens.Wrapped | |
| Ord k ⇒ Rewrapped (Map k a) (MonoidalMap k a) | |
Defined in Data.Map.Monoidal | |
| Ord k ⇒ Rewrapped (MonoidalMap k a) (Map k a) | |
Defined in Data.Map.Monoidal | |
| Newtype (MonoidalMap k a) (Map k a) | |
Defined in Data.Map.Monoidal | |
| type BPMKeyConstraint Map key | |
Defined in Data.Containers | |
| type Item (Map k v) | |
Defined in Data.Map.Internal | |
| type Share (Map k v) | |
| type Index (Map k a) | |
Defined in Control.Lens.At | |
| type IxValue (Map k a) | |
Defined in Control.Lens.At | |
| type Unwrapped (Map k a) | |
Defined in Control.Lens.Wrapped | |
| type ContainerKey (Map k v) | |
Defined in Data.Containers | |
| type KeySet (Map k v) | |
Defined in Data.Containers | |
| type MapValue (Map key value) | |
Defined in Data.Containers | |
| type Element (Map k v) | |
Defined in Data.MonoTraversable | |
| type Index (Map k a) | |
Defined in Optics.At.Core | |
| type IxKind (Map k a) | |
Defined in Optics.At.Core | |
| type IxValue (Map k a) | |
Defined in Optics.At.Core | |
when ∷ Applicative f ⇒ Bool → f () → f () Source #
Conditional execution of Applicative expressions. For example,
when debug (putStrLn "Debugging")
will output the string Debugging if the Boolean value debug
is True, and otherwise do nothing.
void ∷ Functor f ⇒ f a → f () Source #
void valueIO action.
Examples
Replace the contents of a Maybe Int
>>>void NothingNothing>>>void (Just 3)Just ()
Replace the contents of an Either Int IntEither Int ()
>>>void (Left 8675309)Left 8675309>>>void (Right 8675309)Right ()
Replace every element of a list with unit:
>>>void [1,2,3][(),(),()]
Replace the second element of a pair with unit:
>>>void (1,2)(1,())
Discard the result of an IO action:
>>>mapM print [1,2]1 2 [(),()]>>>void $ mapM print [1,2]1 2
fromMaybe ∷ a → Maybe a → a Source #
The fromMaybe function takes a default value and a Maybe
value. If the Maybe is Nothing, it returns the default value;
otherwise, it returns the value contained in the Maybe.
Examples
Basic usage:
>>>fromMaybe "" (Just "Hello, World!")"Hello, World!"
>>>fromMaybe "" Nothing""
Read an integer from a string using readMaybe. If we fail to
parse an integer, we want to return 0 by default:
>>>import Text.Read ( readMaybe )>>>fromMaybe 0 (readMaybe "5")5>>>fromMaybe 0 (readMaybe "")0
isAlphaNum ∷ Char → Bool Source #
Selects alphabetic or numeric Unicode characters.
Note that numeric digits outside the ASCII range, as well as numeric
characters which aren't digits, are selected by this function but not by
isDigit. Such characters may be part of identifiers but are not used by
the printer and reader to represent numbers.
Proxy is a type that holds no data, but has a phantom parameter of
arbitrary type (or even kind). Its use is to provide type information, even
though there is no value available of that type (or it may be too costly to
create one).
Historically, Proxy :: Proxy aundefined :: a
>>>Proxy :: Proxy (Void, Int -> Int)Proxy
Proxy can even hold types of higher kinds,
>>>Proxy :: Proxy EitherProxy
>>>Proxy :: Proxy FunctorProxy
>>>Proxy :: Proxy complicatedStructureProxy
Constructors
| Proxy |
Instances
newtype Const a (b ∷ k) Source #
The Const functor.
Instances
class (Typeable e, Show e) ⇒ Exception e Source #
Any type that you wish to throw or catch as an exception must be an
instance of the Exception class. The simplest case is a new exception
type directly below the root:
data MyException = ThisException | ThatException
deriving Show
instance Exception MyExceptionThe default method definitions in the Exception class do what we need
in this case. You can now throw and catch ThisException and
ThatException as exceptions:
*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
Caught ThisException
In more complicated examples, you may wish to define a whole hierarchy of exceptions:
---------------------------------------------------------------------
-- Make the root exception type for all the exceptions in a compiler
data SomeCompilerException = forall e . Exception e => SomeCompilerException e
instance Show SomeCompilerException where
show (SomeCompilerException e) = show e
instance Exception SomeCompilerException
compilerExceptionToException :: Exception e => e -> SomeException
compilerExceptionToException = toException . SomeCompilerException
compilerExceptionFromException :: Exception e => SomeException -> Maybe e
compilerExceptionFromException x = do
SomeCompilerException a <- fromException x
cast a
---------------------------------------------------------------------
-- Make a subhierarchy for exceptions in the frontend of the compiler
data SomeFrontendException = forall e . Exception e => SomeFrontendException e
instance Show SomeFrontendException where
show (SomeFrontendException e) = show e
instance Exception SomeFrontendException where
toException = compilerExceptionToException
fromException = compilerExceptionFromException
frontendExceptionToException :: Exception e => e -> SomeException
frontendExceptionToException = toException . SomeFrontendException
frontendExceptionFromException :: Exception e => SomeException -> Maybe e
frontendExceptionFromException x = do
SomeFrontendException a <- fromException x
cast a
---------------------------------------------------------------------
-- Make an exception type for a particular frontend compiler exception
data MismatchedParentheses = MismatchedParentheses
deriving Show
instance Exception MismatchedParentheses where
toException = frontendExceptionToException
fromException = frontendExceptionFromExceptionWe can now catch a MismatchedParentheses exception as
MismatchedParentheses, SomeFrontendException or
SomeCompilerException, but not other types, e.g. IOException:
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: IOException))
*** Exception: MismatchedParentheses
Instances
Arguments
| ∷ Exception e | |
| ⇒ IO a | The computation to run |
| → (e → IO a) | Handler to invoke if an exception is raised |
| → IO a |
This is the simplest of the exception-catching functions. It takes a single argument, runs it, and if an exception is raised the "handler" is executed, with the value of the exception passed as an argument. Otherwise, the result is returned as normal. For example:
catch (readFile f)
(\e -> do let err = show (e :: IOException)
hPutStr stderr ("Warning: Couldn't open " ++ f ++ ": " ++ err)
return "")Note that we have to give a type signature to e, or the program
will not typecheck as the type is ambiguous. While it is possible
to catch exceptions of any type, see the section "Catching all
exceptions" (in Control.Exception) for an explanation of the problems with doing so.
For catching exceptions in pure (non-IO) expressions, see the
function evaluate.
Note that due to Haskell's unspecified evaluation order, an
expression may throw one of several possible exceptions: consider
the expression (error "urk") + (1 `div` 0). Does
the expression throw
ErrorCall "urk", or DivideByZero?
The answer is "it might throw either"; the choice is
non-deterministic. If you are catching any type of exception then you
might catch either. If you are calling catch with type
IO Int -> (ArithException -> IO Int) -> IO Int then the handler may
get run with DivideByZero as an argument, or an ErrorCall "urk"
exception may be propagated further up. If you call it again, you
might get the opposite behaviour. This is ok, because catch is an
IO computation.
throwIO ∷ Exception e ⇒ e → IO a Source #
A variant of throw that can only be used within the IO monad.
Although throwIO has a type that is an instance of the type of throw, the
two functions are subtly different:
throw e `seq` x ===> throw e throwIO e `seq` x ===> x
The first example will cause the exception e to be raised,
whereas the second one won't. In fact, throwIO will only cause
an exception to be raised when it is used within the IO monad.
The throwIO variant should be used in preference to throw to
raise an exception within the IO monad because it guarantees
ordering with respect to other IO operations, whereas throw
does not.
Identity functor and monad. (a non-strict monad)
Since: base-4.8.0.0
Constructors
| Identity | |
Fields
| |
Instances
foldM ∷ (Foldable t, Monad m) ⇒ (b → a → m b) → b → t a → m b Source #
The foldM function is analogous to foldl, except that its result is
encapsulated in a monad. Note that foldM works from left-to-right over
the list arguments. This could be an issue where ( and the `folded
function' are not commutative.>>)
foldM f a1 [x1, x2, ..., xm] == do a2 <- f a1 x1 a3 <- f a2 x2 ... f am xm
If right-to-left evaluation is required, the input list should be reversed.
Since Void values logically don't exist, this witnesses the
logical reasoning tool of "ex falso quodlibet".
>>>let x :: Either Void Int; x = Right 5>>>:{case x of Right r -> r Left l -> absurd l :} 5
Since: base-4.8.0.0
Uninhabited data type
Since: base-4.8.0.0
Instances
A space efficient, packed, unboxed Unicode text type.
Instances
forM ∷ (Traversable t, Monad m) ⇒ t a → (a → m b) → m (t b) Source #
class Contravariant (f ∷ Type → Type) where Source #
The class of contravariant functors.
Whereas in Haskell, one can think of a Functor as containing or producing
values, a contravariant functor is a functor that can be thought of as
consuming values.
As an example, consider the type of predicate functions a -> Bool. One
such predicate might be negative x = x < 0, which
classifies integers as to whether they are negative. However, given this
predicate, we can re-use it in other situations, providing we have a way to
map values to integers. For instance, we can use the negative predicate
on a person's bank balance to work out if they are currently overdrawn:
newtype Predicate a = Predicate { getPredicate :: a -> Bool }
instance Contravariant Predicate where
contramap :: (a' -> a) -> (Predicate a -> Predicate a')
contramap f (Predicate p) = Predicate (p . f)
| `- First, map the input...
`----- then apply the predicate.
overdrawn :: Predicate Person
overdrawn = contramap personBankBalance negative
Any instance should be subject to the following laws:
Note, that the second law follows from the free theorem of the type of
contramap and the first law, so you need only check that the former
condition holds.
Minimal complete definition
Instances
A type that can be converted to JSON.
Instances in general must specify toJSON and should (but don't need
to) specify toEncoding.
An example type and instance:
-- Allow ourselves to writeTextliterals. {-# LANGUAGE OverloadedStrings #-} data Coord = Coord { x :: Double, y :: Double } instanceToJSONCoord wheretoJSON(Coord x y) =object["x".=x, "y".=y]toEncoding(Coord x y) =pairs("x".=x<>"y".=y)
Instead of manually writing your ToJSON instance, there are two options
to do it automatically:
- Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so it will probably be more efficient than the following option.
- The compiler can provide a default generic implementation for
toJSON.
To use the second, simply add a deriving clause to your
datatype and declare a GenericToJSON instance. If you require nothing other than
defaultOptions, it is sufficient to write (and this is the only
alternative where the default toJSON implementation is sufficient):
{-# LANGUAGE DeriveGeneric #-}
import GHC.Generics
data Coord = Coord { x :: Double, y :: Double } deriving Generic
instance ToJSON Coord where
toEncoding = genericToEncoding defaultOptions
or more conveniently using the DerivingVia extension
deriving viaGenericallyCoord instanceToJSONCoord
If on the other hand you wish to customize the generic decoding, you have to implement both methods:
customOptions =defaultOptions{fieldLabelModifier=maptoUpper} instanceToJSONCoord wheretoJSON=genericToJSONcustomOptionstoEncoding=genericToEncodingcustomOptions
Previous versions of this library only had the toJSON method. Adding
toEncoding had two reasons:
toEncodingis more efficient for the common case that the output oftoJSONis directly serialized to aByteString. Further, expressing either method in terms of the other would be non-optimal.- The choice of defaults allows a smooth transition for existing users:
Existing instances that do not define
toEncodingstill compile and have the correct semantics. This is ensured by making the default implementation oftoEncodingusetoJSON. This produces correct results, but since it performs an intermediate conversion to aValue, it will be less efficient than directly emitting anEncoding. (this also means that specifying nothing more thaninstance ToJSON Coordwould be sufficient as a generically decoding instance, but there probably exists no good reason to not specifytoEncodingin new instances.)
Minimal complete definition
Nothing
Methods
Convert a Haskell value to a JSON-friendly intermediate type.
toEncoding ∷ a → Encoding Source #
Encode a Haskell value as JSON.
The default implementation of this method creates an
intermediate Value using toJSON. This provides
source-level compatibility for people upgrading from older
versions of this library, but obviously offers no performance
advantage.
To benefit from direct encoding, you must provide an
implementation for this method. The easiest way to do so is by
having your types implement Generic using the DeriveGeneric
extension, and then have GHC generate a method body as follows.
instanceToJSONCoord wheretoEncoding=genericToEncodingdefaultOptions
toJSONList ∷ [a] → Value Source #
toEncodingList ∷ [a] → Encoding Source #
Instances
class FromJSON a where Source #
A type that can be converted from JSON, with the possibility of failure.
In many cases, you can get the compiler to generate parsing code for you (see below). To begin, let's cover writing an instance by hand.
There are various reasons a conversion could fail. For example, an
Object could be missing a required key, an Array could be of
the wrong size, or a value could be of an incompatible type.
The basic ways to signal a failed conversion are as follows:
failyields a custom error message: it is the recommended way of reporting a failure;empty(ormzero) is uninformative: use it when the error is meant to be caught by some(;<|>)typeMismatchcan be used to report a failure when the encountered value is not of the expected JSON type;unexpectedis an appropriate alternative when more than one type may be expected, or to keep the expected type implicit.
prependFailure (or modifyFailure) add more information to a parser's
error messages.
An example type and instance using typeMismatch and prependFailure:
-- Allow ourselves to writeTextliterals. {-# LANGUAGE OverloadedStrings #-} data Coord = Coord { x :: Double, y :: Double } instanceFromJSONCoord whereparseJSON(Objectv) = Coord<$>v.:"x"<*>v.:"y" -- We do not expect a non-Objectvalue here. -- We could useemptyto fail, buttypeMismatch-- gives a much more informative error message.parseJSONinvalid =prependFailure"parsing Coord failed, " (typeMismatch"Object" invalid)
For this common case of only being concerned with a single
type of JSON value, the functions withObject, withScientific, etc.
are provided. Their use is to be preferred when possible, since
they are more terse. Using withObject, we can rewrite the above instance
(assuming the same language extension and data type) as:
instanceFromJSONCoord whereparseJSON=withObject"Coord" $ \v -> Coord<$>v.:"x"<*>v.:"y"
Instead of manually writing your FromJSON instance, there are two options
to do it automatically:
- Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so it will probably be more efficient than the following option.
- The compiler can provide a default generic implementation for
parseJSON.
To use the second, simply add a deriving clause to your
datatype and declare a GenericFromJSON instance for your datatype without giving
a definition for parseJSON.
For example, the previous example can be simplified to just:
{-# LANGUAGE DeriveGeneric #-}
import GHC.Generics
data Coord = Coord { x :: Double, y :: Double } deriving Generic
instance FromJSON Coord
or using the DerivingVia extension
deriving viaGenericallyCoord instanceFromJSONCoord
The default implementation will be equivalent to
parseJSON = ; if you need different
options, you can customize the generic decoding by defining:genericParseJSON defaultOptions
customOptions =defaultOptions{fieldLabelModifier=maptoUpper} instanceFromJSONCoord whereparseJSON=genericParseJSONcustomOptions
Minimal complete definition
Nothing
Instances
class PrintfArg a where Source #
Typeclass of printf-formattable values. The formatArg method
takes a value and a field format descriptor and either fails due
to a bad descriptor or produces a ShowS as the result. The
default parseFormat expects no modifiers: this is the normal
case. Minimal instance: formatArg.
Minimal complete definition
Methods
formatArg ∷ a → FieldFormatter Source #
Since: base-4.7.0.0
parseFormat ∷ a → ModifierParser Source #
Since: base-4.7.0.0
Instances
| PrintfArg BalancingError # | |
Defined in GeniusYield.Transaction.Common Methods | |
| PrintfArg GYAddress # | This instance is using for logging
|
Defined in GeniusYield.Types.Address Methods | |
| PrintfArg GYAddressBech32 # | |
Defined in GeniusYield.Types.Address Methods | |
| PrintfArg GYStakeAddress # | This instance is using for logging
|
Defined in GeniusYield.Types.Address Methods | |
| PrintfArg GYStakeAddressBech32 # | |
Defined in GeniusYield.Types.Address | |
| PrintfArg GYPaymentCredential # | |
Defined in GeniusYield.Types.Credential | |
| PrintfArg GYStakeCredential # | |
Defined in GeniusYield.Types.Credential | |
| PrintfArg GYPaymentSigningKey # |
|
Defined in GeniusYield.Types.Key | |
| PrintfArg GYPaymentVerificationKey # |
|
Defined in GeniusYield.Types.Key | |
| PrintfArg GYStakeSigningKey # |
|
Defined in GeniusYield.Types.Key | |
| PrintfArg GYStakeVerificationKey # |
|
Defined in GeniusYield.Types.Key | |
| PrintfArg GYLogNamespace # |
|
Defined in GeniusYield.Types.Logging Methods | |
| PrintfArg GYNatural # | |
Defined in GeniusYield.Types.Natural Methods | |
| PrintfArg GYPaymentKeyHash # |
|
Defined in GeniusYield.Types.PaymentKeyHash | |
| PrintfArg GYPubKeyHash # |
|
Defined in GeniusYield.Types.PubKeyHash Methods | |
| PrintfArg GYRational # |
|
Defined in GeniusYield.Types.Rational Methods | |
| PrintfArg GYScriptHash # |
|
Defined in GeniusYield.Types.Script Methods | |
| PrintfArg GYValidatorHash # |
|
Defined in GeniusYield.Types.Script Methods | |
| PrintfArg GYSlot # | |
Defined in GeniusYield.Types.Slot | |
| PrintfArg GYStakeKeyHash # |
|
Defined in GeniusYield.Types.StakeKeyHash Methods | |
| PrintfArg GYTime # |
|
Defined in GeniusYield.Types.Time | |
| PrintfArg GYTx # | |
Defined in GeniusYield.Types.Tx | |
| PrintfArg GYTxId # |
|
Defined in GeniusYield.Types.Tx | |
| PrintfArg GYTxWitness # | |
Defined in GeniusYield.Types.Tx Methods | |
| PrintfArg GYTxOutRef # | |
Defined in GeniusYield.Types.TxOutRef Methods | |
| PrintfArg GYTxOutRefCbor # | |
Defined in GeniusYield.Types.TxOutRef Methods | |
| PrintfArg GYUTxOs # | |
Defined in GeniusYield.Types.UTxO | |
| PrintfArg GYAssetClass # |
|
Defined in GeniusYield.Types.Value Methods | |
| PrintfArg GYValue # |
|
Defined in GeniusYield.Types.Value | |
| PrintfArg Int16 | Since: base-2.1 |
Defined in Text.Printf | |
| PrintfArg Int32 | Since: base-2.1 |
Defined in Text.Printf | |
| PrintfArg Int64 | Since: base-2.1 |
Defined in Text.Printf | |
| PrintfArg Int8 | Since: base-2.1 |
Defined in Text.Printf | |
| PrintfArg Word16 | Since: base-2.1 |
Defined in Text.Printf | |
| PrintfArg Word32 | Since: base-2.1 |
Defined in Text.Printf | |
| PrintfArg Word64 | Since: base-2.1 |
Defined in Text.Printf | |
| PrintfArg Word8 | Since: base-2.1 |
Defined in Text.Printf | |
| PrintfArg ShortText | Since: text-short-0.1.2 |
Defined in Data.Text.Short.Internal Methods | |
| PrintfArg Integer | Since: base-2.1 |
Defined in Text.Printf | |
| PrintfArg Natural | Since: base-4.8.0.0 |
Defined in Text.Printf | |
| PrintfArg Char | Since: base-2.1 |
Defined in Text.Printf | |
| PrintfArg Double | Since: base-2.1 |
Defined in Text.Printf | |
| PrintfArg Float | Since: base-2.1 |
Defined in Text.Printf | |
| PrintfArg Int | Since: base-2.1 |
Defined in Text.Printf | |
| PrintfArg Word | Since: base-2.1 |
Defined in Text.Printf | |
| IsChar c ⇒ PrintfArg [c] | Since: base-2.1 |
Defined in Text.Printf | |
printf ∷ PrintfType r ⇒ String → r Source #
Format a variable number of arguments with the C-style formatting string.
>>>printf "%s, %d, %.4f" "hello" 123 pihello, 123, 3.1416
The return value is either String or ( (which
should be IO a)(, but Haskell's type system
makes this hard).IO ())
The format string consists of ordinary characters and
conversion specifications, which specify how to format
one of the arguments to printf in the output string. A
format specification is introduced by the % character;
this character can be self-escaped into the format string
using %%. A format specification ends with a
format character that provides the primary information about
how to format the value. The rest of the conversion
specification is optional. In order, one may have flag
characters, a width specifier, a precision specifier, and
type-specific modifier characters.
Unlike C printf(3), the formatting of this printf
is driven by the argument type; formatting is type specific. The
types formatted by printf "out of the box" are:
printf is also extensible to support other types: see below.
A conversion specification begins with the
character %, followed by zero or more of the following flags:
- left adjust (default is right adjust) + always use a sign (+ or -) for signed conversions space leading space for positive numbers in signed conversions 0 pad with zeros rather than spaces # use an \"alternate form\": see below
When both flags are given, - overrides 0 and + overrides space.
A negative width specifier in a * conversion is treated as
positive but implies the left adjust flag.
The "alternate form" for unsigned radix conversions is
as in C printf(3):
%o prefix with a leading 0 if needed %x prefix with a leading 0x if nonzero %X prefix with a leading 0X if nonzero %b prefix with a leading 0b if nonzero %[eEfFgG] ensure that the number contains a decimal point
Any flags are followed optionally by a field width:
num field width * as num, but taken from argument list
The field width is a minimum, not a maximum: it will be expanded as needed to avoid mutilating a value.
Any field width is followed optionally by a precision:
.num precision . same as .0 .* as num, but taken from argument list
Negative precision is taken as 0. The meaning of the precision depends on the conversion type.
Integral minimum number of digits to show RealFloat number of digits after the decimal point String maximum number of characters
The precision for Integral types is accomplished by zero-padding. If both precision and zero-pad are given for an Integral field, the zero-pad is ignored.
Any precision is followed optionally for Integral types by a width modifier; the only use of this modifier being to set the implicit size of the operand for conversion of a negative operand to unsigned:
hh Int8 h Int16 l Int32 ll Int64 L Int64
The specification ends with a format character:
c character Integral d decimal Integral o octal Integral x hexadecimal Integral X hexadecimal Integral b binary Integral u unsigned decimal Integral f floating point RealFloat F floating point RealFloat g general format float RealFloat G general format float RealFloat e exponent format float RealFloat E exponent format float RealFloat s string String v default format any type
The "%v" specifier is provided for all built-in types, and should be provided for user-defined type formatters as well. It picks a "best" representation for the given type. For the built-in types the "%v" specifier is converted as follows:
c Char u other unsigned Integral d other signed Integral g RealFloat s String
Mismatch between the argument types and the format string, as well as any other syntactic or semantic errors in the format string, will cause an exception to be thrown at runtime.
Note that the formatting for RealFloat types is
currently a bit different from that of C printf(3),
conforming instead to showEFloat,
showFFloat and showGFloat (and their
alternate versions showFFloatAlt and
showGFloatAlt). This is hard to fix: the fixed
versions would format in a backward-incompatible way.
In any case the Haskell behavior is generally more
sensible than the C behavior. A brief summary of some
key differences:
- Haskell
printfnever uses the default "6-digit" precision used by C printf. - Haskell
printftreats the "precision" specifier as indicating the number of digits after the decimal point. - Haskell
printfprints the exponent of e-format numbers without a gratuitous plus sign, and with the minimum possible number of digits. - Haskell
printfwill place a zero after a decimal point when possible.
minimumBy ∷ Foldable t ⇒ (a → a → Ordering) → t a → a Source #
The least element of a non-empty structure with respect to the given comparison function.
Examples
Basic usage:
>>>minimumBy (compare `on` length) ["Hello", "World", "!", "Longest", "bar"]"!"
WARNING: This function is partial for possibly-empty structures like lists.
maximumBy ∷ Foldable t ⇒ (a → a → Ordering) → t a → a Source #
The largest element of a non-empty structure with respect to the given comparison function.
Examples
Basic usage:
>>>maximumBy (compare `on` length) ["Hello", "World", "!", "Longest", "bar"]"Longest"
WARNING: This function is partial for possibly-empty structures like lists.
fromRight ∷ b → Either a b → b Source #
Return the contents of a Right-value or a default value otherwise.
Examples
Basic usage:
>>>fromRight 1 (Right 3)3>>>fromRight 1 (Left "foo")1
Since: base-4.10.0.0
(>>>) ∷ ∀ {k} cat (a ∷ k) (b ∷ k) (c ∷ k). Category cat ⇒ cat a b → cat b c → cat a c infixr 1 Source #
Left-to-right composition
data (a ∷ k) :~: (b ∷ k) where infix 4 Source #
Propositional equality. If a :~: b is inhabited by some terminating
value, then the type a is the same as the type b. To use this equality
in practice, pattern-match on the a :~: b to get out the Refl constructor;
in the body of the pattern-match, the compiler knows that a ~ b.
Since: base-4.7.0.0
Instances
| Category ((:~:) ∷ k → k → Type) | Since: base-4.7.0.0 |
| TestEquality ((:~:) a ∷ k → Type) | Since: base-4.7.0.0 |
Defined in Data.Type.Equality | |
| GNFData ((:~:) a ∷ k → Type) | Since: some-1.0.3 |
Defined in Data.GADT.DeepSeq | |
| GCompare ((:~:) a ∷ k → Type) | |
| GEq ((:~:) a ∷ k → Type) | |
| GRead ((:~:) a ∷ k → Type) | |
Defined in Data.GADT.Internal | |
| GShow ((:~:) a ∷ k → Type) | |
Defined in Data.GADT.Internal | |
| NFData2 ((:~:) ∷ Type → Type → Type) | Since: deepseq-1.4.3.0 |
Defined in Control.DeepSeq | |
| NFData1 ((:~:) a) | Since: deepseq-1.4.3.0 |
Defined in Control.DeepSeq | |
| (a ~ b, Data a) ⇒ Data (a :~: b) | Since: base-4.7.0.0 |
Defined in Data.Data Methods gfoldl ∷ (∀ d b0. Data d ⇒ c (d → b0) → d → c b0) → (∀ g. g → c g) → (a :~: b) → c (a :~: b) Source # gunfold ∷ (∀ b0 r. Data b0 ⇒ c (b0 → r) → c r) → (∀ r. r → c r) → Constr → c (a :~: b) Source # toConstr ∷ (a :~: b) → Constr Source # dataTypeOf ∷ (a :~: b) → DataType Source # dataCast1 ∷ Typeable t ⇒ (∀ d. Data d ⇒ c (t d)) → Maybe (c (a :~: b)) Source # dataCast2 ∷ Typeable t ⇒ (∀ d e. (Data d, Data e) ⇒ c (t d e)) → Maybe (c (a :~: b)) Source # gmapT ∷ (∀ b0. Data b0 ⇒ b0 → b0) → (a :~: b) → a :~: b Source # gmapQl ∷ (r → r' → r) → r → (∀ d. Data d ⇒ d → r') → (a :~: b) → r Source # gmapQr ∷ ∀ r r'. (r' → r → r) → r → (∀ d. Data d ⇒ d → r') → (a :~: b) → r Source # gmapQ ∷ (∀ d. Data d ⇒ d → u) → (a :~: b) → [u] Source # gmapQi ∷ Int → (∀ d. Data d ⇒ d → u) → (a :~: b) → u Source # gmapM ∷ Monad m ⇒ (∀ d. Data d ⇒ d → m d) → (a :~: b) → m (a :~: b) Source # gmapMp ∷ MonadPlus m ⇒ (∀ d. Data d ⇒ d → m d) → (a :~: b) → m (a :~: b) Source # gmapMo ∷ MonadPlus m ⇒ (∀ d. Data d ⇒ d → m d) → (a :~: b) → m (a :~: b) Source # | |
| a ~ b ⇒ Bounded (a :~: b) | Since: base-4.7.0.0 |
| a ~ b ⇒ Enum (a :~: b) | Since: base-4.7.0.0 |
Defined in Data.Type.Equality Methods succ ∷ (a :~: b) → a :~: b Source # pred ∷ (a :~: b) → a :~: b Source # toEnum ∷ Int → a :~: b Source # fromEnum ∷ (a :~: b) → Int Source # enumFrom ∷ (a :~: b) → [a :~: b] Source # enumFromThen ∷ (a :~: b) → (a :~: b) → [a :~: b] Source # enumFromTo ∷ (a :~: b) → (a :~: b) → [a :~: b] Source # enumFromThenTo ∷ (a :~: b) → (a :~: b) → (a :~: b) → [a :~: b] Source # | |
| a ~ b ⇒ Read (a :~: b) | Since: base-4.7.0.0 |
| Show (a :~: b) | Since: base-4.7.0.0 |
| NFData (a :~: b) | Since: deepseq-1.4.3.0 |
Defined in Control.DeepSeq | |
| Eq (a :~: b) | Since: base-4.7.0.0 |
| Ord (a :~: b) | Since: base-4.7.0.0 |
Defined in Data.Type.Equality | |
isHexDigit ∷ Char → Bool Source #
Selects ASCII hexadecimal digits,
i.e. '0'..'9', 'a'..'f', 'A'..'F'.
type HasCallStack = ?callStack ∷ CallStack Source #
Request a CallStack.
NOTE: The implicit parameter ?callStack :: CallStack is an
implementation detail and should not be considered part of the
CallStack API, we may decide to change the implementation in the
future.
Since: base-4.9.0.0
encodeUtf8 ∷ Text → ByteString Source #
Encode text using UTF-8 encoding.
rightToMaybe ∷ Either a b → Maybe b Source #
Maybe get the Right side of an Either.
rightToMaybe≡either(constNothing)Just
Using Control.Lens:
rightToMaybe≡ preview _RightrightToMaybex ≡ x^?_Right
>>>rightToMaybe (Left 12)Nothing
>>>rightToMaybe (Right 12)Just 12
itoList ∷ FoldableWithIndex i f ⇒ f a → [(i, a)] Source #
ifor_ ∷ (FoldableWithIndex i t, Applicative f) ⇒ t a → (i → a → f b) → f () Source #
Traverse elements with access to the index i, discarding the results (with the arguments flipped).
ifor_≡flipitraverse_
When you don't need access to the index then for_ is more flexible in what it accepts.
for_a ≡ifor_a.const
data Some (tag ∷ k → Type) where Source #
Existential. This is type is useful to hide GADTs' parameters.
>>>data Tag :: Type -> Type where TagInt :: Tag Int; TagBool :: Tag Bool>>>instance GShow Tag where gshowsPrec _ TagInt = showString "TagInt"; gshowsPrec _ TagBool = showString "TagBool">>>classify s = case s of "TagInt" -> [mkGReadResult TagInt]; "TagBool" -> [mkGReadResult TagBool]; _ -> []>>>instance GRead Tag where greadsPrec _ s = [ (r, rest) | (con, rest) <- lex s, r <- classify con ]
You can either use PatternSynonyms (available with GHC >= 8.0)
>>>let x = Some TagInt>>>xSome TagInt
>>>case x of { Some TagInt -> "I"; Some TagBool -> "B" } :: String"I"
or you can use functions
>>>let y = mkSome TagBool>>>ySome TagBool
>>>withSome y $ \y' -> case y' of { TagInt -> "I"; TagBool -> "B" } :: String"B"
The implementation of mapSome is safe.
>>>let f :: Tag a -> Tag a; f TagInt = TagInt; f TagBool = TagBool>>>mapSome f ySome TagBool
but you can also use:
>>>withSome y (mkSome . f)Some TagBool
>>>read "Some TagBool" :: Some TagSome TagBool
>>>read "mkSome TagInt" :: Some TagSome TagInt
Instances
| Applicative m ⇒ Monoid (Some m) | |
| Applicative m ⇒ Semigroup (Some m) | |
| GRead f ⇒ Read (Some f) | |
| GShow tag ⇒ Show (Some tag) | |
| GNFData tag ⇒ NFData (Some tag) | |
Defined in Data.Some.Newtype | |
| GEq tag ⇒ Eq (Some tag) | |
| GCompare tag ⇒ Ord (Some tag) | |
wither ∷ (Witherable t, Applicative f) ⇒ (a → f (Maybe b)) → t a → f (t b) Source #
iwither ∷ (WitherableWithIndex i t, Applicative f) ⇒ (i → a → f (Maybe b)) → t a → f (t b) Source #
pattern TODO ∷ () ⇒ HasCallStack ⇒ a #
decodeUtf8Lenient ∷ ByteString → Text #
Decode a strict ByteString containing UTF-8 encoded text.
lazyDecodeUtf8Lenient ∷ ByteString → Text #
Decode a lazy ByteString containing UTF-8 encoded text.
Any invalid input bytes will be replaced with the Unicode replacement character U+FFFD.
hoistMaybe ∷ Applicative m ⇒ Maybe b → MaybeT m b #
Orphan instances
| (TypeError ('Text "Forbidden FromJSON ByteString instance") ∷ Constraint) ⇒ FromJSON ByteString # | |
Methods parseJSON ∷ Value → Parser ByteString Source # parseJSONList ∷ Value → Parser [ByteString] Source # | |
| (TypeError ('Text "Forbidden ToJSON ByteString instance") ∷ Constraint) ⇒ ToJSON ByteString # | |
Methods toJSON ∷ ByteString → Value Source # toEncoding ∷ ByteString → Encoding Source # toJSONList ∷ [ByteString] → Value Source # toEncodingList ∷ [ByteString] → Encoding Source # | |