Hoogle Search

Within LTS Haskell 24.52 (ghc-9.10.3)

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

Exact lookup

1. DecimalL :: Decimal -> LogicalTypeLong

   avro	Data.Avro.Schema.Schema

   An arbitrary-precision signed decimal number. See Decimal.

2. type family GAll (n :: Nat) (c :: k -> Constraint) (repbf :: Type -> Type)

   barbies	Barbies.Internal

   No documentation available.

3. type GAllRepB (b :: k -> Type -> Type) = TagSelf0 b

   barbies	Barbies.Internal

   The representation used for the generic computation of the AllB c b constraints.

4. type GAllRepT (t :: k -> Type -> kg -> Type) = TagSelf1 t

   barbies	Barbies.Internal

   The representation used for the generic computation of the AllT c t constraints. .

5. newtype Generically a

   barbies	Barbies.Internal

   A datatype whose instances are defined generically, using the Generic representation. Generically1 is a higher-kinded version of Generically that uses Generic1. Generic instances can be derived via Generically A using -XDerivingVia.

   {-# LANGUAGE DeriveGeneric      #-}
   {-# LANGUAGE DerivingStrategies #-}
   {-# LANGUAGE DerivingVia        #-}
   
   import GHC.Generics (Generic)
   
   data V4 a = V4 a a a a
   deriving stock Generic
   
   deriving (Semigroup, Monoid)
   via Generically (V4 a)
   

   This corresponds to Semigroup and Monoid instances defined by pointwise lifting:

   instance Semigroup a => Semigroup (V4 a) where
   (<>) :: V4 a -> V4 a -> V4 a
   V4 a1 b1 c1 d1 <> V4 a2 b2 c2 d2 =
   V4 (a1 <> a2) (b1 <> b2) (c1 <> c2) (d1 <> d2)
   
   instance Monoid a => Monoid (V4 a) where
   mempty :: V4 a
   mempty = V4 mempty mempty mempty mempty
   

   Historically this required modifying the type class to include generic method definitions (-XDefaultSignatures) and deriving it with the anyclass strategy (-XDeriveAnyClass). Having a /via type/ like Generically decouples the instance from the type class.

6. Generically :: a -> Generically a

   barbies	Barbies.Internal

   No documentation available.

7. newtype Generically1 (f :: k -> Type) (a :: k)

   barbies	Barbies.Internal

   A type whose instances are defined generically, using the Generic1 representation. Generically1 is a higher-kinded version of Generically that uses Generic. Generic instances can be derived for type constructors via Generically1 F using -XDerivingVia.

   {-# LANGUAGE DeriveGeneric      #-}
   {-# LANGUAGE DerivingStrategies #-}
   {-# LANGUAGE DerivingVia        #-}
   
   import GHC.Generics (Generic)
   
   data V4 a = V4 a a a a
   deriving stock (Functor, Generic1)
   
   deriving Applicative
   via Generically1 V4
   

   This corresponds to Applicative instances defined by pointwise lifting:

   instance Applicative V4 where
   pure :: a -> V4 a
   pure a = V4 a a a a
   
   liftA2 :: (a -> b -> c) -> (V4 a -> V4 b -> V4 c)
   liftA2 (·) (V4 a1 b1 c1 d1) (V4 a2 b2 c2 d2) =
   V4 (a1 · a2) (b1 · b2) (c1 · c2) (d1 · d2)
   

   Historically this required modifying the type class to include generic method definitions (-XDefaultSignatures) and deriving it with the anyclass strategy (-XDeriveAnyClass). Having a /via type/ like Generically1 decouples the instance from the type class.

8. BlockedOnForeignCall :: BlockReason

   base-prelude	BasePrelude

   currently in a foreign call

9. atomically :: STM a -> IO a

   base-prelude	BasePrelude

   Perform a series of STM actions atomically. Using atomically inside an unsafePerformIO or unsafeInterleaveIO subverts some of guarantees that STM provides. It makes it possible to run a transaction inside of another transaction, depending on when the thunk is evaluated. If a nested transaction is attempted, an exception is thrown by the runtime. It is possible to safely use atomically inside unsafePerformIO or unsafeInterleaveIO, but the typechecker does not rule out programs that may attempt nested transactions, meaning that the programmer must take special care to prevent these. However, there are functions for creating transactional variables that can always be safely called in unsafePerformIO. See: newTVarIO, newTChanIO, newBroadcastTChanIO, newTQueueIO, newTBQueueIO, and newTMVarIO. Using unsafePerformIO inside of atomically is also dangerous but for different reasons. See unsafeIOToSTM for more on this.

10. ComparatorQuantifierAll :: ComparatorQuantifier

    beam-core	Database.Beam.Backend.SQL.AST

    No documentation available.

Page 703 of many | Previous | Next