packages feed

himari 1.0.1.0 → 1.0.2.0

raw patch · 14 files changed

+188/−17 lines, 14 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Himari.Env: instance Control.Monad.IO.Class.MonadIO (Himari.Env.Himari env)
- Himari.Prelude.Aeson: class KeyValue e kv | kv -> e
- Himari.Prelude.Aeson: data Options
- Himari.Prelude.Aeson: defaultOptions :: Options
- Himari.Prelude.Aeson: object :: [Pair] -> Value
- Himari.Prelude.Aeson: pairs :: Series -> Encoding
- Himari.Prelude.Generics: Infix :: Associativity -> Int -> Fixity
- Himari.Prelude.Generics: Prefix :: Fixity
- Himari.Prelude.Generics: data Fixity
- Himari.Prelude.Type: class MonadThrow m => MonadCatch (m :: Type -> Type)
- Himari.Prelude.Type: class MonadCatch m => MonadMask (m :: Type -> Type)
- Himari.Prelude.Type: class Monad m => MonadThrow (m :: Type -> Type)
+ Himari.Env: instance GHC.Internal.Control.Monad.IO.Class.MonadIO (Himari.Env.Himari env)
+ Himari.Prelude: data Solo a
+ Himari.Prelude: getSolo :: Solo a -> a
+ Himari.Prelude: pattern Solo :: a -> Solo a
+ Himari.Prelude: swap :: (a, b) -> (b, a)
+ Himari.Prelude.Aeson: allNullaryToStringTag :: Options -> Bool
+ Himari.Prelude.Aeson: allowOmittedFields :: Options -> Bool
+ Himari.Prelude.Aeson: constructorTagModifier :: Options -> String -> String
+ Himari.Prelude.Aeson: fieldLabelModifier :: Options -> String -> String
+ Himari.Prelude.Aeson: omitNothingFields :: Options -> Bool
+ Himari.Prelude.Aeson: rejectUnknownFields :: Options -> Bool
+ Himari.Prelude.Aeson: sumEncoding :: Options -> SumEncoding
+ Himari.Prelude.Aeson: tagSingleConstructors :: Options -> Bool
+ Himari.Prelude.Aeson: unwrapUnaryRecords :: Options -> Bool
+ Himari.Prelude.Arrow: (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
+ Himari.Prelude.Arrow: (***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c')
+ Himari.Prelude.Arrow: (+++) :: ArrowChoice a => a b c -> a b' c' -> a (Either b b') (Either c c')
+ Himari.Prelude.Arrow: (<+>) :: ArrowPlus a => a b c -> a b c -> a b c
+ Himari.Prelude.Arrow: (<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
+ Himari.Prelude.Arrow: (<<^) :: Arrow a => a c d -> (b -> c) -> a b d
+ Himari.Prelude.Arrow: (>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
+ Himari.Prelude.Arrow: (>>^) :: Arrow a => a b c -> (c -> d) -> a b d
+ Himari.Prelude.Arrow: (^<<) :: Arrow a => (c -> d) -> a b c -> a b d
+ Himari.Prelude.Arrow: (^>>) :: Arrow a => (b -> c) -> a c d -> a b d
+ Himari.Prelude.Arrow: (|||) :: ArrowChoice a => a b d -> a c d -> a (Either b c) d
+ Himari.Prelude.Arrow: ArrowMonad :: a () b -> ArrowMonad (a :: Type -> Type -> Type) b
+ Himari.Prelude.Arrow: Kleisli :: (a -> m b) -> Kleisli (m :: Type -> Type) a b
+ Himari.Prelude.Arrow: [runKleisli] :: Kleisli (m :: Type -> Type) a b -> a -> m b
+ Himari.Prelude.Arrow: app :: ArrowApply a => a (a b c, b) c
+ Himari.Prelude.Arrow: arr :: Arrow a => (b -> c) -> a b c
+ Himari.Prelude.Arrow: class Category a => Arrow (a :: Type -> Type -> Type)
+ Himari.Prelude.Arrow: class Arrow a => ArrowApply (a :: Type -> Type -> Type)
+ Himari.Prelude.Arrow: class Arrow a => ArrowChoice (a :: Type -> Type -> Type)
+ Himari.Prelude.Arrow: class Arrow a => ArrowLoop (a :: Type -> Type -> Type)
+ Himari.Prelude.Arrow: class ArrowZero a => ArrowPlus (a :: Type -> Type -> Type)
+ Himari.Prelude.Arrow: class Arrow a => ArrowZero (a :: Type -> Type -> Type)
+ Himari.Prelude.Arrow: infixr 1 >>>
+ Himari.Prelude.Arrow: infixr 2 +++
+ Himari.Prelude.Arrow: infixr 3 &&&
+ Himari.Prelude.Arrow: infixr 5 <+>
+ Himari.Prelude.Arrow: left :: ArrowChoice a => a b c -> a (Either b d) (Either c d)
+ Himari.Prelude.Arrow: leftApp :: ArrowApply a => a b c -> a (Either b d) (Either c d)
+ Himari.Prelude.Arrow: loop :: ArrowLoop a => a (b, d) (c, d) -> a b c
+ Himari.Prelude.Arrow: newtype ArrowMonad (a :: Type -> Type -> Type) b
+ Himari.Prelude.Arrow: newtype Kleisli (m :: Type -> Type) a b
+ Himari.Prelude.Arrow: returnA :: Arrow a => a b b
+ Himari.Prelude.Arrow: right :: ArrowChoice a => a b c -> a (Either d b) (Either d c)
+ Himari.Prelude.Arrow: zeroArrow :: ArrowZero a => a b c
+ Himari.Prelude.Catch: ExitCaseAbort :: ExitCase a
+ Himari.Prelude.Catch: ExitCaseException :: SomeException -> ExitCase a
+ Himari.Prelude.Catch: ExitCaseSuccess :: a -> ExitCase a
+ Himari.Prelude.Catch: SomeException :: e -> SomeException
+ Himari.Prelude.Catch: backtraceDesired :: Exception e => e -> Bool
+ Himari.Prelude.Catch: catchAll :: (HasCallStack, MonadCatch m) => m a -> (SomeException -> m a) -> m a
+ Himari.Prelude.Catch: catchIOError :: (HasCallStack, MonadCatch m) => m a -> (IOError -> m a) -> m a
+ Himari.Prelude.Catch: catchIf :: (HasCallStack, MonadCatch m, Exception e) => (e -> Bool) -> m a -> (e -> m a) -> m a
+ Himari.Prelude.Catch: class (Typeable e, Show e) => Exception e
+ Himari.Prelude.Catch: class MonadThrow m => MonadCatch (m :: Type -> Type)
+ Himari.Prelude.Catch: class MonadCatch m => MonadMask (m :: Type -> Type)
+ Himari.Prelude.Catch: class Monad m => MonadThrow (m :: Type -> Type)
+ Himari.Prelude.Catch: data ExitCase a
+ Himari.Prelude.Catch: data SomeException
+ Himari.Prelude.Catch: displayException :: Exception e => e -> String
+ Himari.Prelude.Catch: fromException :: Exception e => SomeException -> Maybe e
+ Himari.Prelude.Catch: generalBracket :: (MonadMask m, HasCallStack) => m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)
+ Himari.Prelude.Catch: handleAll :: (HasCallStack, MonadCatch m) => (SomeException -> m a) -> m a -> m a
+ Himari.Prelude.Catch: handleIOError :: (HasCallStack, MonadCatch m) => (IOError -> m a) -> m a -> m a
+ Himari.Prelude.Catch: handleIf :: (HasCallStack, MonadCatch m, Exception e) => (e -> Bool) -> (e -> m a) -> m a -> m a
+ Himari.Prelude.Catch: onError :: (HasCallStack, MonadMask m) => m a -> m b -> m a
+ Himari.Prelude.Catch: throwM :: (MonadThrow m, HasCallStack, Exception e) => e -> m a
+ Himari.Prelude.Catch: toException :: Exception e => e -> SomeException
+ Himari.Prelude.Data: AlgConstr :: ConIndex -> ConstrRep
+ Himari.Prelude.Data: AlgRep :: [Constr] -> DataRep
+ Himari.Prelude.Data: CharConstr :: Char -> ConstrRep
+ Himari.Prelude.Data: CharRep :: DataRep
+ Himari.Prelude.Data: FloatConstr :: Rational -> ConstrRep
+ Himari.Prelude.Data: FloatRep :: DataRep
+ Himari.Prelude.Data: IntConstr :: Integer -> ConstrRep
+ Himari.Prelude.Data: IntRep :: DataRep
+ Himari.Prelude.Data: NoRep :: DataRep
+ Himari.Prelude.Data: Proxy :: Proxy (t :: k)
+ Himari.Prelude.Data: [HRefl] :: forall {k1} (a :: k1). a :~~: a
+ Himari.Prelude.Data: [Refl] :: forall {k} (a :: k). a :~: a
+ Himari.Prelude.Data: cast :: (Typeable a, Typeable b) => a -> Maybe b
+ Himari.Prelude.Data: class Typeable a => Data a
+ Himari.Prelude.Data: class Typeable (a :: k)
+ Himari.Prelude.Data: constrFields :: Constr -> [String]
+ Himari.Prelude.Data: constrFixity :: Constr -> Fixity
+ Himari.Prelude.Data: constrIndex :: Constr -> ConIndex
+ Himari.Prelude.Data: constrRep :: Constr -> ConstrRep
+ Himari.Prelude.Data: constrType :: Constr -> DataType
+ Himari.Prelude.Data: data (a :: k1) :~~: (b :: k2)
+ Himari.Prelude.Data: data Constr
+ Himari.Prelude.Data: data ConstrRep
+ Himari.Prelude.Data: data DataRep
+ Himari.Prelude.Data: data DataType
+ Himari.Prelude.Data: data Proxy (t :: k)
+ Himari.Prelude.Data: data TyCon
+ Himari.Prelude.Data: dataCast1 :: (Data a, Typeable t) => (forall d. Data d => c (t d)) -> Maybe (c a)
+ Himari.Prelude.Data: dataCast2 :: (Data a, Typeable t) => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a)
+ Himari.Prelude.Data: dataTypeConstrs :: DataType -> [Constr]
+ Himari.Prelude.Data: dataTypeName :: DataType -> String
+ Himari.Prelude.Data: dataTypeOf :: Data a => a -> DataType
+ Himari.Prelude.Data: dataTypeRep :: DataType -> DataRep
+ Himari.Prelude.Data: decT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => Either ((a :~: b) -> Void) (a :~: b)
+ Himari.Prelude.Data: eqT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => Maybe (a :~: b)
+ Himari.Prelude.Data: fromConstr :: Data a => Constr -> a
+ Himari.Prelude.Data: fromConstrB :: Data a => (forall d. Data d => d) -> Constr -> a
+ Himari.Prelude.Data: fromConstrM :: (Monad m, Data a) => (forall d. Data d => m d) -> Constr -> m a
+ Himari.Prelude.Data: funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep
+ Himari.Prelude.Data: gcast :: forall {k} (a :: k) (b :: k) c. (Typeable a, Typeable b) => c a -> Maybe (c b)
+ Himari.Prelude.Data: gcast1 :: forall {k1} {k2} c (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))
+ Himari.Prelude.Data: gcast2 :: forall {k1} {k2} {k3} c (t :: k2 -> k3 -> k1) (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3). (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b))
+ Himari.Prelude.Data: gfoldl :: Data a => (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. () => g -> c g) -> a -> c a
+ Himari.Prelude.Data: gmapM :: (Data a, Monad m) => (forall d. Data d => d -> m d) -> a -> m a
+ Himari.Prelude.Data: gmapMo :: (Data a, MonadPlus m) => (forall d. Data d => d -> m d) -> a -> m a
+ Himari.Prelude.Data: gmapMp :: (Data a, MonadPlus m) => (forall d. Data d => d -> m d) -> a -> m a
+ Himari.Prelude.Data: gmapQ :: Data a => (forall d. Data d => d -> u) -> a -> [u]
+ Himari.Prelude.Data: gmapQi :: Data a => Int -> (forall d. Data d => d -> u) -> a -> u
+ Himari.Prelude.Data: gmapQl :: Data a => (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
+ Himari.Prelude.Data: gmapQr :: forall r r'. Data a => (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
+ Himari.Prelude.Data: gmapT :: Data a => (forall b. Data b => b -> b) -> a -> a
+ Himari.Prelude.Data: gunfold :: Data a => (forall b r. Data b => c (b -> r) -> c r) -> (forall r. () => r -> c r) -> Constr -> c a
+ Himari.Prelude.Data: hdecT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => Either ((a :~~: b) -> Void) (a :~~: b)
+ Himari.Prelude.Data: heqT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => Maybe (a :~~: b)
+ Himari.Prelude.Data: indexConstr :: DataType -> ConIndex -> Constr
+ Himari.Prelude.Data: infix 4 :~~:
+ Himari.Prelude.Data: isAlgType :: DataType -> Bool
+ Himari.Prelude.Data: isNorepType :: DataType -> Bool
+ Himari.Prelude.Data: maxConstrIndex :: DataType -> ConIndex
+ Himari.Prelude.Data: mkCharConstr :: DataType -> Char -> Constr
+ Himari.Prelude.Data: mkCharType :: String -> DataType
+ Himari.Prelude.Data: mkConstr :: DataType -> String -> [String] -> Fixity -> Constr
+ Himari.Prelude.Data: mkConstrTag :: DataType -> String -> Int -> [String] -> Fixity -> Constr
+ Himari.Prelude.Data: mkDataType :: String -> [Constr] -> DataType
+ Himari.Prelude.Data: mkFloatType :: String -> DataType
+ Himari.Prelude.Data: mkFunTy :: TypeRep -> TypeRep -> TypeRep
+ Himari.Prelude.Data: mkIntType :: String -> DataType
+ Himari.Prelude.Data: mkIntegralConstr :: (Integral a, Show a) => DataType -> a -> Constr
+ Himari.Prelude.Data: mkNoRepType :: String -> DataType
+ Himari.Prelude.Data: mkRealConstr :: (Real a, Show a) => DataType -> a -> Constr
+ Himari.Prelude.Data: readConstr :: DataType -> String -> Maybe Constr
+ Himari.Prelude.Data: repConstr :: DataType -> ConstrRep -> Constr
+ Himari.Prelude.Data: rnfTyCon :: TyCon -> ()
+ Himari.Prelude.Data: rnfTypeRep :: TypeRep -> ()
+ Himari.Prelude.Data: showConstr :: Constr -> String
+ Himari.Prelude.Data: showsTypeRep :: TypeRep -> ShowS
+ Himari.Prelude.Data: splitTyConApp :: TypeRep -> (TyCon, [TypeRep])
+ Himari.Prelude.Data: toConstr :: Data a => a -> Constr
+ Himari.Prelude.Data: trLiftedRep :: TypeRep LiftedRep
+ Himari.Prelude.Data: tyConFingerprint :: TyCon -> Fingerprint
+ Himari.Prelude.Data: tyConModule :: TyCon -> String
+ Himari.Prelude.Data: tyConName :: TyCon -> String
+ Himari.Prelude.Data: tyConPackage :: TyCon -> String
+ Himari.Prelude.Data: tyconModule :: String -> String
+ Himari.Prelude.Data: tyconUQname :: String -> String
+ Himari.Prelude.Data: type ConIndex = Int
+ Himari.Prelude.Data: type TypeRep = SomeTypeRep
+ Himari.Prelude.Data: typeOf :: Typeable a => a -> TypeRep
+ Himari.Prelude.Data: typeOf1 :: Typeable t => t a -> TypeRep
+ Himari.Prelude.Data: typeOf2 :: Typeable t => t a b -> TypeRep
+ Himari.Prelude.Data: typeOf3 :: Typeable t => t a b c -> TypeRep
+ Himari.Prelude.Data: typeOf4 :: Typeable t => t a b c d -> TypeRep
+ Himari.Prelude.Data: typeOf5 :: Typeable t => t a b c d e -> TypeRep
+ Himari.Prelude.Data: typeOf6 :: Typeable t => t a b c d e f -> TypeRep
+ Himari.Prelude.Data: typeOf7 :: Typeable t => t a b c d e f g -> TypeRep
+ Himari.Prelude.Data: typeRep :: forall {k} proxy (a :: k). Typeable a => proxy a -> TypeRep
+ Himari.Prelude.Data: typeRepArgs :: TypeRep -> [TypeRep]
+ Himari.Prelude.Data: typeRepFingerprint :: TypeRep -> Fingerprint
+ Himari.Prelude.Data: typeRepTyCon :: TypeRep -> TyCon
+ Himari.Prelude.Monoid: (<>) :: Semigroup a => a -> a -> a
+ Himari.Prelude.Monoid: All :: Bool -> All
+ Himari.Prelude.Monoid: Alt :: f a -> Alt (f :: k -> Type) (a :: k)
+ Himari.Prelude.Monoid: Any :: Bool -> Any
+ Himari.Prelude.Monoid: Ap :: f a -> Ap (f :: k -> Type) (a :: k)
+ Himari.Prelude.Monoid: Arg :: a -> b -> Arg a b
+ Himari.Prelude.Monoid: Dual :: a -> Dual a
+ Himari.Prelude.Monoid: Endo :: (a -> a) -> Endo a
+ Himari.Prelude.Monoid: Max :: a -> Max a
+ Himari.Prelude.Monoid: Min :: a -> Min a
+ Himari.Prelude.Monoid: Product :: a -> Product a
+ Himari.Prelude.Monoid: Sum :: a -> Sum a
+ Himari.Prelude.Monoid: WrapMonoid :: m -> WrappedMonoid m
+ Himari.Prelude.Monoid: [appEndo] :: Endo a -> a -> a
+ Himari.Prelude.Monoid: [getAll] :: All -> Bool
+ Himari.Prelude.Monoid: [getAlt] :: Alt (f :: k -> Type) (a :: k) -> f a
+ Himari.Prelude.Monoid: [getAny] :: Any -> Bool
+ Himari.Prelude.Monoid: [getAp] :: Ap (f :: k -> Type) (a :: k) -> f a
+ Himari.Prelude.Monoid: [getDual] :: Dual a -> a
+ Himari.Prelude.Monoid: [getMax] :: Max a -> a
+ Himari.Prelude.Monoid: [getMin] :: Min a -> a
+ Himari.Prelude.Monoid: [getProduct] :: Product a -> a
+ Himari.Prelude.Monoid: [getSum] :: Sum a -> a
+ Himari.Prelude.Monoid: [unwrapMonoid] :: WrappedMonoid m -> m
+ Himari.Prelude.Monoid: class Semigroup a => Monoid a
+ Himari.Prelude.Monoid: class Semigroup a
+ Himari.Prelude.Monoid: cycle1 :: Semigroup m => m -> m
+ Himari.Prelude.Monoid: data Arg a b
+ Himari.Prelude.Monoid: diff :: Semigroup m => m -> Endo m
+ Himari.Prelude.Monoid: infixr 6 <>
+ Himari.Prelude.Monoid: mappend :: Monoid a => a -> a -> a
+ Himari.Prelude.Monoid: mconcat :: Monoid a => [a] -> a
+ Himari.Prelude.Monoid: mempty :: Monoid a => a
+ Himari.Prelude.Monoid: mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
+ Himari.Prelude.Monoid: newtype All
+ Himari.Prelude.Monoid: newtype Alt (f :: k -> Type) (a :: k)
+ Himari.Prelude.Monoid: newtype Any
+ Himari.Prelude.Monoid: newtype Ap (f :: k -> Type) (a :: k)
+ Himari.Prelude.Monoid: newtype Dual a
+ Himari.Prelude.Monoid: newtype Endo a
+ Himari.Prelude.Monoid: newtype Max a
+ Himari.Prelude.Monoid: newtype Min a
+ Himari.Prelude.Monoid: newtype Product a
+ Himari.Prelude.Monoid: newtype Sum a
+ Himari.Prelude.Monoid: newtype WrappedMonoid m
+ Himari.Prelude.Monoid: sconcat :: Semigroup a => NonEmpty a -> a
+ Himari.Prelude.Monoid: stimes :: (Semigroup a, Integral b) => b -> a -> a
+ Himari.Prelude.Monoid: stimesIdempotent :: Integral b => b -> a -> a
+ Himari.Prelude.Monoid: stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
+ Himari.Prelude.Monoid: stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
+ Himari.Prelude.Monoid: type ArgMax a b = Max Arg a b
+ Himari.Prelude.Monoid: type ArgMin a b = Min Arg a b
+ Himari.Prelude.TypeLevel: [Coercion] :: forall {k} (a :: k) (b :: k). Coercible a b => Coercion a b
+ Himari.Prelude.TypeLevel: [HRefl] :: forall {k1} (a :: k1). a :~~: a
+ Himari.Prelude.TypeLevel: [Refl] :: forall {k} (a :: k). a :~: a
+ Himari.Prelude.TypeLevel: apply :: forall {k1} {k2} (f :: k1 -> k2) (g :: k1 -> k2) (a :: k1) (b :: k1). (f :~: g) -> (a :~: b) -> f a :~: g b
+ Himari.Prelude.TypeLevel: castWith :: (a :~: b) -> a -> b
+ Himari.Prelude.TypeLevel: class a ~# b => (a :: k0) ~~ (b :: k1)
+ Himari.Prelude.TypeLevel: class TestCoercion (f :: k -> Type)
+ Himari.Prelude.TypeLevel: class TestEquality (f :: k -> Type)
+ Himari.Prelude.TypeLevel: coerceWith :: Coercion a b -> a -> b
+ Himari.Prelude.TypeLevel: data (a :: k1) :~~: (b :: k2)
+ Himari.Prelude.TypeLevel: data Coercion (a :: k) (b :: k)
+ Himari.Prelude.TypeLevel: gcastWith :: forall {k} (a :: k) (b :: k) r. (a :~: b) -> (a ~ b => r) -> r
+ Himari.Prelude.TypeLevel: gcoerceWith :: forall {k} (a :: k) (b :: k) r. Coercion a b -> (Coercible a b => r) -> r
+ Himari.Prelude.TypeLevel: infix 4 ~~
+ Himari.Prelude.TypeLevel: inner :: forall {k1} {k2} (f :: k1 -> k2) (a :: k1) (g :: k1 -> k2) (b :: k1). (f a :~: g b) -> a :~: b
+ Himari.Prelude.TypeLevel: repr :: forall {k} (a :: k) (b :: k). (a :~: b) -> Coercion a b
+ Himari.Prelude.TypeLevel: testCoercion :: forall (a :: k) (b :: k). TestCoercion f => f a -> f b -> Maybe (Coercion a b)
+ Himari.Prelude.TypeLevel: testEquality :: forall (a :: k) (b :: k). TestEquality f => f a -> f b -> Maybe (a :~: b)
+ Himari.Prelude.TypeLevel: type family (a :: k) == (b :: k) :: Bool
- Himari.Prelude.Category: infixr 1 <<<
+ Himari.Prelude.Category: infixr 1 >>>
- Himari.Prelude.Generics: data ( (f :: k -> Type) :*: (g :: k -> Type) ) (p :: k)
+ Himari.Prelude.Generics: data ( (f :: k -> Type) :+: (g :: k -> Type) ) (p :: k)

Files

CHANGELOG.md view
@@ -7,6 +7,34 @@  ## [Unreleased] +## [1.0.2.0] - 2026-01-07++### Added++- `Himari.Prelude.Arrow`: `Control.Arrow` re-exports (hiding conflicting symbols)+- `Himari.Prelude.Catch`: `Control.Monad.Catch` re-exports (hiding UnliftIO conflicts)+- `Himari.Prelude.Data`: `Data.Data` re-exports (hiding GHC.Generics conflicts)+- `Himari.Prelude.Monoid`: `Data.Monoid`/`Data.Semigroup` re-exports (hiding conflicts)+- `Himari.Prelude.TypeLevel`: type-level programming (`Data.Type.Coercion`, `Data.Type.Equality`)+- `Himari.Prelude.FunctorSpec`: test module for functor-related exports+- `Control.Arrow` re-export in `Himari.Prelude` (via `Himari.Prelude.Arrow`)+- `Data.Coerce` re-export in `Himari.Prelude` for safe type coercion+- `Data.Complex` re-export in `Himari.Prelude` for complex number support+- `Data.Data` re-export in `Himari.Prelude` (via `Himari.Prelude.Data`) for generic programming+- `Data.Fixed` re-export in `Himari.Prelude` for fixed-point arithmetic+- `Data.Functor.Compose` re-export in `Himari.Prelude` for functor composition+- `Data.Int` re-export in `Himari.Prelude` for sized integer types+- `Data.Kind` re-export in `Himari.Prelude` for kind-level types (`Type`, `Constraint`)+- `Data.Monoid`/`Data.Semigroup` re-export in `Himari.Prelude` (via `Himari.Prelude.Monoid`)+- `Data.Proxy` re-export in `Himari.Prelude` for type-level proxy values+- `Data.Type.Coercion`/`Data.Type.Equality` re-export (via `Himari.Prelude.TypeLevel`)+- `Numeric.Natural` re-export in `Himari.Prelude` for non-negative integers++### Changed++- `Himari.Prelude.Aeson`: Hide overly general symbols+- `Himari.Prelude.Catch`: Hide `Handler` to avoid conflicts+ ## [1.0.1.0] - 2026-01-06  ### Added
fourmolu.yaml view
@@ -21,16 +21,21 @@   - module Himari.Prelude exports "base" Control.Monad   - module Himari.Prelude exports "base" Control.Monad.ST   - module Himari.Prelude exports "base" Data.Bifoldable-  - module Himari.Prelude exports "base" Data.Bifunctor   - module Himari.Prelude exports "base" Data.Bitraversable   - module Himari.Prelude exports "base" Data.Bool+  - module Himari.Prelude exports "base" Data.Coerce+  - module Himari.Prelude exports "base" Data.Complex   - module Himari.Prelude exports "base" Data.Either   - module Himari.Prelude exports "base" Data.Eq+  - module Himari.Prelude exports "base" Data.Fixed   - module Himari.Prelude exports "base" Data.Foldable   - module Himari.Prelude exports "base" Data.Function+  - module Himari.Prelude exports "base" Data.Functor.Compose+  - module Himari.Prelude exports "base" Data.Int+  - module Himari.Prelude exports "base" Data.Kind   - module Himari.Prelude exports "base" Data.Maybe-  - module Himari.Prelude exports "base" Data.Monoid   - module Himari.Prelude exports "base" Data.Ord+  - module Himari.Prelude exports "base" Data.Proxy   - module Himari.Prelude exports "base" Data.Ratio   - module Himari.Prelude exports "base" Data.String   - module Himari.Prelude exports "base" Data.Traversable@@ -48,6 +53,7 @@   - module Himari.Prelude exports "mtl" Control.Monad.Reader   - module Himari.Prelude exports "mtl" Control.Monad.State.Strict   - module Himari.Prelude exports "mtl" Control.Monad.Writer.CPS+  - module Himari.Prelude exports "base" Numeric.Natural   - module Himari.Prelude exports "pretty-simple" Debug.Pretty.Simple   - module Himari.Prelude exports "pretty-simple" Text.Pretty.Simple   - module Himari.Prelude exports "primitive" Control.Monad.Primitive@@ -56,11 +62,16 @@   - module Himari.Prelude exports "unliftio" UnliftIO   # Himari.Prelude → 内部サブモジュール   - module Himari.Prelude exports "himari" Himari.Prelude.Aeson+  - module Himari.Prelude exports "himari" Himari.Prelude.Arrow+  - module Himari.Prelude exports "himari" Himari.Prelude.Catch   - module Himari.Prelude exports "himari" Himari.Prelude.Category+  - module Himari.Prelude exports "himari" Himari.Prelude.Data   - module Himari.Prelude exports "himari" Himari.Prelude.FilePath   - module Himari.Prelude exports "himari" Himari.Prelude.Generics+  - module Himari.Prelude exports "himari" Himari.Prelude.Monoid   - module Himari.Prelude exports "himari" Himari.Prelude.Safe   - module Himari.Prelude exports "himari" Himari.Prelude.Type+  - module Himari.Prelude exports "himari" Himari.Prelude.TypeLevel    # Himari.Prelude.Aeson → 外部モジュール   - module Himari.Prelude.Aeson exports "aeson" Data.Aeson@@ -82,8 +93,20 @@   - module Himari.Prelude.Safe exports "safe" Safe.Exact   - module Himari.Prelude.Safe exports "safe" Safe.Foldable +  # Himari.Prelude.Arrow → 外部モジュール+  - module Himari.Prelude.Arrow exports "base" Control.Arrow++  # Himari.Prelude.Catch → 外部モジュール+  - module Himari.Prelude.Catch exports "exceptions" Control.Monad.Catch++  # Himari.Prelude.Data → 外部モジュール+  - module Himari.Prelude.Data exports "base" Data.Data++  # Himari.Prelude.Monoid → 外部モジュール+  - module Himari.Prelude.Monoid exports "base" Data.Monoid+  - module Himari.Prelude.Monoid exports "base" Data.Semigroup+   # Himari.Prelude.Type → 外部モジュール-  - module Himari.Prelude.Type exports "exceptions" Control.Monad.Catch   - module Himari.Prelude.Type exports "bytestring" Data.ByteString   - module Himari.Prelude.Type exports "bytestring" Data.ByteString.Lazy   - module Himari.Prelude.Type exports "bytestring" Data.ByteString.Short@@ -100,6 +123,10 @@   - module Himari.Prelude.Type exports "text" Data.Text.Lazy   - module Himari.Prelude.Type exports "containers" Data.Tree   - module Himari.Prelude.Type exports "vector" Data.Vector++  # Himari.Prelude.TypeLevel → 外部モジュール+  - module Himari.Prelude.TypeLevel exports "base" Data.Type.Coercion+  - module Himari.Prelude.TypeLevel exports "base" Data.Type.Equality  # 利用者向けの汎用的なfixity設定 # hspecは既にfourmoluによってサポートされているため不要
himari.cabal view
@@ -1,6 +1,6 @@ cabal-version: 3.0 name: himari-version: 1.0.1.0+version: 1.0.2.0 synopsis: A standard library for Haskell as an alternative to rio description:   A standard library for Haskell inspired by rio.@@ -86,11 +86,16 @@     Himari.Logger     Himari.Prelude     Himari.Prelude.Aeson+    Himari.Prelude.Arrow+    Himari.Prelude.Catch     Himari.Prelude.Category+    Himari.Prelude.Data     Himari.Prelude.FilePath     Himari.Prelude.Generics+    Himari.Prelude.Monoid     Himari.Prelude.Safe     Himari.Prelude.Type+    Himari.Prelude.TypeLevel  test-suite himari-test   import: basic@@ -114,6 +119,7 @@   other-modules:     Himari.CharSpec     Himari.Env.SimpleSpec+    Himari.Prelude.FunctorSpec     Himari.Title     HlintBaseSpec     HlintSamples.BasePartial
src/Himari/Prelude.hs view
@@ -15,18 +15,23 @@ import Control.Monad.State.Strict as Export import Control.Monad.Writer.CPS as Export import Data.Bifoldable as Export-import Data.Bifunctor as Export import Data.Bitraversable as Export import Data.Bool as Export+import Data.Coerce as Export+import Data.Complex as Export import Data.Convertible as Export import Data.Either as Export import Data.Eq as Export+import Data.Fixed as Export import Data.Foldable as Export import Data.Function as Export+import Data.Functor.Compose as Export import Data.Hashable as Export+import Data.Int as Export+import Data.Kind as Export import Data.Maybe as Export-import Data.Monoid as Export import Data.Ord as Export+import Data.Proxy as Export import Data.Ratio as Export import Data.String as Export import Data.Time as Export@@ -36,11 +41,17 @@ import Data.Word as Export import Debug.Pretty.Simple as Export import Himari.Prelude.Aeson as Export+import Himari.Prelude.Arrow as Export+import Himari.Prelude.Catch as Export import Himari.Prelude.Category as Export+import Himari.Prelude.Data as Export import Himari.Prelude.FilePath as Export import Himari.Prelude.Generics as Export+import Himari.Prelude.Monoid as Export import Himari.Prelude.Safe as Export import Himari.Prelude.Type as Export+import Himari.Prelude.TypeLevel as Export+import Numeric.Natural as Export import System.Process.Typed as Export import Text.Pretty.Simple as Export import Text.Show as Export
src/Himari/Prelude/Aeson.hs view
@@ -6,16 +6,21 @@ -- aeson has many functions with common names that may conflict, -- so we hide some and selectively import others. import Data.Aeson as Export hiding-  ( decode+  ( KeyValue+  , Options+  , decode   , decode'   , decodeFileStrict   , decodeFileStrict'   , decodeStrict   , decodeStrict'   , decodeStrictText+  , defaultOptions   , eitherDecode'   , eitherDecodeFileStrict'   , eitherDecodeStrict'+  , object+  , pairs   , throwDecode'   , throwDecodeStrict'   , (.=)
+ src/Himari/Prelude/Arrow.hs view
@@ -0,0 +1,6 @@+-- | "Control.Arrow" re-exports, hiding symbols that conflict with "Data.Bifunctor".+module Himari.Prelude.Arrow+  ( module Export+  ) where++import Control.Arrow as Export hiding (first, second)
+ src/Himari/Prelude/Catch.hs view
@@ -0,0 +1,27 @@+-- | Re-exports from "Control.Monad.Catch" that don't conflict with "UnliftIO".+--+-- Functions that conflict with "UnliftIO" are hidden.+-- Use 'catch', 'bracket', 'finally', 'mask', etc. from "UnliftIO" instead.+module Himari.Prelude.Catch+  ( module Control.Monad.Catch+  ) where++import Control.Monad.Catch hiding+  ( Handler+  , bracket+  , bracketOnError+  , bracket_+  , catch+  , catchJust+  , catches+  , finally+  , handle+  , handleJust+  , mask+  , mask_+  , onException+  , try+  , tryJust+  , uninterruptibleMask+  , uninterruptibleMask_+  )
+ src/Himari/Prelude/Data.hs view
@@ -0,0 +1,6 @@+-- | "Data.Data" re-exports, hiding symbols that conflict with "GHC.Generics".+module Himari.Prelude.Data+  ( module Export+  ) where++import Data.Data as Export hiding (Fixity, Infix, Prefix)
src/Himari/Prelude/Generics.hs view
@@ -3,4 +3,4 @@   ( module Export   ) where -import GHC.Generics as Export hiding (from, to)+import GHC.Generics as Export hiding (Fixity, Infix, Prefix, from, to)
+ src/Himari/Prelude/Monoid.hs view
@@ -0,0 +1,7 @@+-- | "Data.Monoid" and "Data.Semigroup" re-exports, hiding conflicting symbols.+module Himari.Prelude.Monoid+  ( module Export+  ) where++import Data.Monoid as Export hiding (First, Last, getFirst, getLast)+import Data.Semigroup as Export hiding (First, Last, getFirst, getLast)
src/Himari/Prelude/Type.hs view
@@ -1,16 +1,11 @@ -- | Type-only re-exports from various modules. ----- Includes types from "Control.Monad.Catch", "Data.ByteString", "Data.HashMap.Strict",+-- Includes types from "Data.ByteString", "Data.HashMap.Strict", -- "Data.HashSet", "Data.IntMap.Strict", "Data.IntSet", "Data.List", "Data.List.NonEmpty", -- "Data.Map.Strict", "Data.Sequence", "Data.Set", "Data.Text", "Data.Tree", and "Data.Vector". module Himari.Prelude.Type-  ( -- * Exception handling-    MonadCatch-  , MonadMask-  , MonadThrow--    -- * ByteString-  , ByteString+  ( -- * ByteString+    ByteString   , StrictByteString   , LazyByteString   , ShortByteString@@ -37,7 +32,6 @@   , Vector   ) where -import Control.Monad.Catch (MonadCatch, MonadMask, MonadThrow) import Data.ByteString (ByteString, StrictByteString) import Data.ByteString.Lazy (LazyByteString) import Data.ByteString.Short (ShortByteString)
+ src/Himari/Prelude/TypeLevel.hs view
@@ -0,0 +1,9 @@+-- | Type-level programming re-exports from "Data.Type.Coercion" and "Data.Type.Equality".+--+-- Hides conflicting symbols between the two modules.+module Himari.Prelude.TypeLevel+  ( module Export+  ) where++import Data.Type.Coercion as Export hiding (sym, trans)+import Data.Type.Equality as Export hiding (outer, sym, trans)
+ test/Himari/Prelude/FunctorSpec.hs view
@@ -0,0 +1,43 @@+{-# LANGUAGE OverloadedStrings #-}++-- | Tests for functor-related re-exports in Himari.Prelude.+module Himari.Prelude.FunctorSpec (spec) where++import Data.Text qualified as T+import Himari+import Test.Syd++spec :: Spec+spec = do+  describe "Data.Bifunctor" $ do+    it "bimap is available and works correctly" $ do+      bimap (+ 1) (* 2) (Left 5 :: Either Int Int) `shouldBe` Left 6+      bimap (+ 1) (* 2) (Right 3 :: Either Int Int) `shouldBe` Right 6++    it "bifunctorインスタンスが使える" $ do+      bimap (convert . show) T.length (42 :: Int, "hello") `shouldBe` ("42" :: Text, 5 :: Int)++  describe "Data.Functor.Const" $ do+    it "Const functor is available" $ do+      let x = Const 42 :: Const Int Text+      getConst x `shouldBe` (42 :: Int)++    it "Const functor maps correctly (ignores function)" $ do+      let x = Const 42 :: Const Int Text+      let y = fmap (const ("ignored" :: Text)) x+      getConst y `shouldBe` (42 :: Int)++  describe "Data.Functor.Identity" $ do+    it "Identity functor is available" $ do+      let x = Identity (42 :: Int)+      runIdentity x `shouldBe` (42 :: Int)++    it "Identity functor maps correctly" $ do+      let x = Identity (5 :: Int)+      let y = fmap (* 2) x+      runIdentity y `shouldBe` (10 :: Int)++    it "Identity applicative works" $ do+      let f = Identity ((+ 1) :: Int -> Int)+      let x = Identity (10 :: Int)+      runIdentity (f <*> x) `shouldBe` (11 :: Int)
test/Main.hs view
@@ -3,6 +3,7 @@ import Himari import Himari.CharSpec qualified as CharSpec import Himari.Env.SimpleSpec qualified as SimpleSpec+import Himari.Prelude.FunctorSpec qualified as FunctorSpec import HlintBaseSpec qualified import HlintUnliftioSpec qualified import Test.Syd@@ -13,5 +14,6 @@   describe "Char" CharSpec.spec   describe "Simple" SimpleSpec.spec   describe "Title" TitleSpec.spec+  describe "Prelude.Functor" FunctorSpec.spec   describe "HlintUnliftio" HlintUnliftioSpec.spec   describe "HlintBase" HlintBaseSpec.spec