Safe Haskell	Safe
Language	Haskell2010

LiveCoding.Migrate.Migration

Synopsis

data Migration = Migration {
- runMigration :: forall a b. (Data a, Data b) => a -> b -> Maybe a
}
runSafeMigration :: (Data a, Data b) => Migration -> a -> b -> a
castMigration :: Migration
newtypeMigration :: Migration
userMigration :: (Typeable c, Typeable d) => (c -> d) -> Migration
migrationTo2 :: Typeable t => (forall a b c. (Typeable a, Typeable b, Typeable c) => t b c -> a -> Maybe (t b c)) -> Migration
constMigrationFrom2 :: Typeable t => (forall a b c. (Typeable a, Typeable b, Typeable c) => t b c -> Maybe a) -> Migration
migrationTo1 :: Typeable t => (forall a b. (Typeable a, Typeable b) => t b -> a -> Maybe (t b)) -> Migration

Documentation

data Migration Source #

Constructors

Migration
Fields runMigration :: forall a b. (Data a, Data b) => a -> b -> Maybe a

Instances

Semigroup Migration Source #	If both migrations would succeed, the result from the first is used.
Instance details Defined in LiveCoding.Migrate.Migration Methods (<>) :: Migration -> Migration -> Migration # sconcat :: NonEmpty Migration -> Migration # stimes :: Integral b => b -> Migration -> Migration #
Monoid Migration Source #
Instance details Defined in LiveCoding.Migrate.Migration Methods mempty :: Migration # mappend :: Migration -> Migration -> Migration # mconcat :: [Migration] -> Migration #

runSafeMigration :: (Data a, Data b) => Migration -> a -> b -> a Source #

Run a migration and insert the new initial state in case of failure.

castMigration :: Migration Source #

Try to migrate by casting the first type into the second

newtypeMigration :: Migration Source #

Migrate a value into a newtype wrapping

userMigration :: (Typeable c, Typeable d) => (c -> d) -> Migration Source #

If you have a specific type that you would like to be migrated to a specific other type, you can create a migration for this. For example: userMigration (toInteger :: Int -> Integer)

migrationTo2 :: Typeable t => (forall a b c. (Typeable a, Typeable b, Typeable c) => t b c -> a -> Maybe (t b c)) -> Migration Source #

constMigrationFrom2 :: Typeable t => (forall a b c. (Typeable a, Typeable b, Typeable c) => t b c -> Maybe a) -> Migration Source #

migrationTo1 :: Typeable t => (forall a b. (Typeable a, Typeable b) => t b -> a -> Maybe (t b)) -> Migration Source #