packages feed

MetaObject 0.0.5 → 0.0.6

raw patch · 8 files changed

+10/−9 lines, 8 filesdep ~stringtable-atomPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: stringtable-atom

API changes (from Hackage documentation)

- MO.Base: instance (Typeable (NoCode m), Monad m) => Codeable m (NoCode m)
- MO.Base: instance (Typeable1 m, Monad m) => Codeable m (HsCode m)
- MO.Base: instance (Typeable1 m, Monad m) => Codeable m PureCode
- MO.Base: instance Show (HsCode m)
- MO.Base: instance Show (NoCode m)
- MO.Base: instance Show PureCode
- MO.Capture: instance (Eq a) => Eq (Capt a)
- MO.Capture: instance (Eq a) => Eq (Feed a)
- MO.Capture: instance (Ord a) => Ord (Capt a)
- MO.Capture: instance (Ord a) => Ord (Feed a)
- MO.Capture: instance (Show a) => Show (Capt a)
- MO.Capture: instance (Show a) => Show (Feed a)
- MO.Capture: instance Monoid (Feed a)
- MO.Capture: instance Monoid [:a:]
- MO.Capture: instance Typeable1 Capt
- MO.Capture: instance Typeable1 Feed
- MO.Compile: instance (Monad m) => Method m (AnyMethod m)
- MO.Compile: instance (Monad m) => Method m (SimpleMethod m)
- MO.Compile: instance Eq (AnyMethod m)
- MO.Compile: instance Ord (AnyMethod m)
- MO.Compile: instance Show (AnyMethod m)
- MO.Compile.Attribute: instance (Monad m) => Eq (Attribute m)
- MO.Compile.Attribute: instance (Monad m) => Ord (Attribute m)
- MO.Compile.Attribute: instance (Monad m) => Show (Attribute m)
- MO.Compile.Class: instance [overlap ok] (Monad m) => Method m (MethodAttached m)
- MO.Compile.Role: instance (Monad m) => Eq (Role m)
- MO.Run: instance [overlap ok] (Monad m) => ResponderInterface m (NoResponse m)
- MO.Util: instance (Ord a) => Eq (Collection a)
- MO.Util: instance (Ord a) => Ord (Collection a)
- MO.Util: instance (Ord a, Show a) => Show (Collection a)
- MO.Util: instance Typeable1 Collection
+ MO.Base: instance [overlap ok] (Typeable (NoCode m), Monad m) => Codeable m (NoCode m)
+ MO.Base: instance [overlap ok] (Typeable1 m, Monad m) => Codeable m (HsCode m)
+ MO.Base: instance [overlap ok] (Typeable1 m, Monad m) => Codeable m PureCode
+ MO.Base: instance [overlap ok] Show (HsCode m)
+ MO.Base: instance [overlap ok] Show (NoCode m)
+ MO.Base: instance [overlap ok] Show PureCode
+ MO.Capture: instance [overlap ok] Eq a => Eq (Capt a)
+ MO.Capture: instance [overlap ok] Eq a => Eq (Feed a)
+ MO.Capture: instance [overlap ok] Monoid (Feed a)
+ MO.Capture: instance [overlap ok] Monoid [:a:]
+ MO.Capture: instance [overlap ok] Ord a => Ord (Capt a)
+ MO.Capture: instance [overlap ok] Ord a => Ord (Feed a)
+ MO.Capture: instance [overlap ok] Show a => Show (Capt a)
+ MO.Capture: instance [overlap ok] Show a => Show (Feed a)
+ MO.Capture: instance [overlap ok] Typeable1 Capt
+ MO.Capture: instance [overlap ok] Typeable1 Feed
+ MO.Compile: instance [overlap ok] Eq (AnyMethod m)
+ MO.Compile: instance [overlap ok] Monad m => Method m (AnyMethod m)
+ MO.Compile: instance [overlap ok] Monad m => Method m (SimpleMethod m)
+ MO.Compile: instance [overlap ok] Ord (AnyMethod m)
+ MO.Compile: instance [overlap ok] Show (AnyMethod m)
+ MO.Compile.Attribute: instance [overlap ok] Monad m => Eq (Attribute m)
+ MO.Compile.Attribute: instance [overlap ok] Monad m => Ord (Attribute m)
+ MO.Compile.Attribute: instance [overlap ok] Monad m => Show (Attribute m)
+ MO.Compile.Class: instance [overlap ok] Monad m => Method m (MethodAttached m)
+ MO.Compile.Role: instance [overlap ok] Monad m => Eq (Role m)
+ MO.Run: instance [overlap ok] Monad m => ResponderInterface m (NoResponse m)
+ MO.Util: instance [overlap ok] (Ord a, Show a) => Show (Collection a)
+ MO.Util: instance [overlap ok] Ord a => Eq (Collection a)
+ MO.Util: instance [overlap ok] Ord a => Ord (Collection a)
+ MO.Util: instance [overlap ok] Typeable1 Collection
- MO.Base: class (Monad m) => Codeable m c
+ MO.Base: class Monad m => Codeable m c
- MO.Base: newtype (Monad m) => HsCode m
+ MO.Base: newtype Monad m => HsCode m
- MO.Base: run :: (Codeable m c) => c -> Arguments m -> m (Invocant m)
+ MO.Base: run :: Codeable m c => c -> Arguments m -> m (Invocant m)
- MO.Compile: class (Monad m) => Method m a | a -> m
+ MO.Compile: class Monad m => Method m a | a -> m
- MO.Compile: methodCompile :: (Method m a) => a -> MethodCompiled m
+ MO.Compile: methodCompile :: Method m a => a -> MethodCompiled m
- MO.Compile: methodName :: (Method m a) => a -> MethodName
+ MO.Compile: methodName :: Method m a => a -> MethodName
- MO.Compile.Attribute: data (Monad m) => Attribute m
+ MO.Compile.Attribute: data Monad m => Attribute m
- MO.Compile.Attribute: mkAttribute :: (Monad m) => AttributeName -> Invocant m -> Attribute m
+ MO.Compile.Attribute: mkAttribute :: Monad m => AttributeName -> Invocant m -> Attribute m
- MO.Compile.Attribute: mkAttributeMandatory :: (Monad m) => AttributeName -> Attribute m
+ MO.Compile.Attribute: mkAttributeMandatory :: Monad m => AttributeName -> Attribute m
- MO.Compile.Attribute: mkPrivateAttribute :: (Monad m) => AttributeName -> Invocant m -> Attribute m
+ MO.Compile.Attribute: mkPrivateAttribute :: Monad m => AttributeName -> Invocant m -> Attribute m
- MO.Compile.Attribute: mkPrivateAttributeMandatory :: (Monad m) => AttributeName -> Attribute m
+ MO.Compile.Attribute: mkPrivateAttributeMandatory :: Monad m => AttributeName -> Attribute m
- MO.Compile.Class: all_attribute_methods :: (Class m c) => c -> [AnyMethod m]
+ MO.Compile.Class: all_attribute_methods :: Class m c => c -> [AnyMethod m]
- MO.Compile.Class: all_attributes :: (Class m c) => c -> [Attribute m]
+ MO.Compile.Class: all_attributes :: Class m c => c -> [Attribute m]
- MO.Compile.Class: all_methods :: (Class m c) => c -> [AnyMethod m]
+ MO.Compile.Class: all_methods :: Class m c => c -> [AnyMethod m]
- MO.Compile.Class: all_regular_methods :: (Class m c) => c -> [AnyMethod m]
+ MO.Compile.Class: all_regular_methods :: Class m c => c -> [AnyMethod m]
- MO.Compile.Class: attributes :: (Class m c) => c -> [Attribute m]
+ MO.Compile.Class: attributes :: Class m c => c -> [Attribute m]
- MO.Compile.Class: blessMOClass :: (Class m c) => c -> AnyMethod m
+ MO.Compile.Class: blessMOClass :: Class m c => c -> AnyMethod m
- MO.Compile.Class: class_interface :: (Class m c) => c -> AnyResponder m
+ MO.Compile.Class: class_interface :: Class m c => c -> AnyResponder m
- MO.Compile.Class: class_name :: (Class m c) => c -> ClassName
+ MO.Compile.Class: class_name :: Class m c => c -> ClassName
- MO.Compile.Class: class_precedence_list :: (Class m c) => c -> [AnyClass m]
+ MO.Compile.Class: class_precedence_list :: Class m c => c -> [AnyClass m]
- MO.Compile.Class: merged_roles :: (Class m c) => c -> Role m
+ MO.Compile.Class: merged_roles :: Class m c => c -> Role m
- MO.Compile.Class: private_methods :: (Class m c) => c -> Collection (AnyMethod m)
+ MO.Compile.Class: private_methods :: Class m c => c -> Collection (AnyMethod m)
- MO.Compile.Class: public_methods :: (Class m c) => c -> Collection (AnyMethod m)
+ MO.Compile.Class: public_methods :: Class m c => c -> Collection (AnyMethod m)
- MO.Compile.Class: roles :: (Class m c) => c -> [Role m]
+ MO.Compile.Class: roles :: Class m c => c -> [Role m]
- MO.Compile.Class: superclasses :: (Class m c) => c -> [AnyClass m]
+ MO.Compile.Class: superclasses :: Class m c => c -> [AnyClass m]
- MO.Run: class (Monad m) => ResponderInterface m a | a -> m
+ MO.Run: class Monad m => ResponderInterface m a | a -> m
- MO.Run: data (Monad m) => NoResponse m
+ MO.Run: data Monad m => NoResponse m
- MO.Run: dispatch :: (ResponderInterface m a) => a -> Invocant m -> MethodInvocation m -> m (Invocant m)
+ MO.Run: dispatch :: ResponderInterface m a => a -> Invocant m -> MethodInvocation m -> m (Invocant m)
- MO.Run: fromMethodList :: (ResponderInterface m a) => [(MethodName, MethodCompiled m)] -> m a
+ MO.Run: fromMethodList :: ResponderInterface m a => [(MethodName, MethodCompiled m)] -> m a
- MO.Util: data (Ord a) => Collection a
+ MO.Util: data Ord a => Collection a
- MO.Util: emptyCollection :: (Ord a) => Collection a
+ MO.Util: emptyCollection :: Ord a => Collection a
- MO.Util: includes :: (Ord a) => Collection a -> a -> Bool
+ MO.Util: includes :: Ord a => Collection a -> a -> Bool
- MO.Util: includes_all :: (Ord a) => Collection a -> [a] -> Bool
+ MO.Util: includes_all :: Ord a => Collection a -> [a] -> Bool
- MO.Util: includes_any :: (Ord a) => Collection a -> [a] -> Bool
+ MO.Util: includes_any :: Ord a => Collection a -> [a] -> Bool
- MO.Util: includes_any_name :: (Ord a) => Collection a -> [Atom] -> Bool
+ MO.Util: includes_any_name :: Ord a => Collection a -> [Atom] -> Bool
- MO.Util: includes_name :: (Ord a) => Collection a -> Atom -> Bool
+ MO.Util: includes_name :: Ord a => Collection a -> Atom -> Bool
- MO.Util: insert :: (Ord a) => Atom -> a -> Collection a -> Collection a
+ MO.Util: insert :: Ord a => Atom -> a -> Collection a -> Collection a
- MO.Util: items :: (Ord a) => Collection a -> [a]
+ MO.Util: items :: Ord a => Collection a -> [a]
- MO.Util: items_named :: (Ord a) => Collection a -> [(Atom, a)]
+ MO.Util: items_named :: Ord a => Collection a -> [(Atom, a)]
- MO.Util: merge :: (Ord a) => [Collection a] -> [a]
+ MO.Util: merge :: Ord a => [Collection a] -> [a]
- MO.Util: merge' :: (Ord a) => [Collection a] -> AtomMap a
+ MO.Util: merge' :: Ord a => [Collection a] -> AtomMap a
- MO.Util: merge_collection :: (Ord a) => [Collection a] -> Collection a
+ MO.Util: merge_collection :: Ord a => [Collection a] -> Collection a
- MO.Util: newCollection :: (Ord a) => [(Atom, a)] -> Collection a
+ MO.Util: newCollection :: Ord a => [(Atom, a)] -> Collection a
- MO.Util: newCollection' :: (Ord a) => (a -> Atom) -> [a] -> Collection a
+ MO.Util: newCollection' :: Ord a => (a -> Atom) -> [a] -> Collection a
- MO.Util: newCollectionMap :: (Ord a) => AtomMap a -> Collection a
+ MO.Util: newCollectionMap :: Ord a => AtomMap a -> Collection a
- MO.Util: shadow :: (Ord a) => [Collection a] -> [a]
+ MO.Util: shadow :: Ord a => [Collection a] -> [a]
- MO.Util: shadow' :: (Ord a) => [Collection a] -> AtomMap a
+ MO.Util: shadow' :: Ord a => [Collection a] -> AtomMap a
- MO.Util: shadow_collection :: (Ord a) => [Collection a] -> Collection a
+ MO.Util: shadow_collection :: Ord a => [Collection a] -> Collection a
- MO.Util: sym_inheritance :: (Ord a) => b -> (b -> [b]) -> (b -> (Collection a)) -> Collection a
+ MO.Util: sym_inheritance :: Ord a => b -> (b -> [b]) -> (b -> (Collection a)) -> Collection a
- MO.Util: traceM :: (Monad m) => String -> m ()
+ MO.Util: traceM :: Monad m => String -> m ()
- MO.Util: traceShow :: (Show a) => a -> b -> b
+ MO.Util: traceShow :: Show a => a -> b -> b

Files

MetaObject.cabal view
@@ -1,5 +1,5 @@ name:               MetaObject-version:            0.0.5+version:            0.0.6 copyright:          2006 Caio Marcelo, 2008 Audrey Tang license:            BSD3 license-file:       LICENSE@@ -13,6 +13,7 @@ exposed-modules:    MO.Base MO.Compile.Attribute MO.Compile.Class                     MO.Compile.Role MO.Compile MO.Run MO.Util MO.Capture MO.Util.C3 build-depends:      base, haskell98, containers,-                    stringtable-atom >= 0.0.4+                    stringtable-atom >= 0.0.6+extensions:         UndecidableInstances OverlappingInstances extra-source-files: README, examples/si.hs, examples/old/mi.hs examples/old/roles.hs hs-source-dirs:     src
src/MO/Base.hs view
@@ -1,4 +1,4 @@-{-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances -fparr #-}+{-# OPTIONS_GHC -fglasgow-exts -fparr #-}  module MO.Base where import {-# SOURCE #-} MO.Run
src/MO/Compile.hs view
@@ -1,4 +1,4 @@-{-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances -funbox-strict-fields #-}+{-# OPTIONS_GHC -fglasgow-exts -funbox-strict-fields #-}  module MO.Compile where
src/MO/Compile/Attribute.hs view
@@ -1,4 +1,4 @@-{-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances #-}+{-# OPTIONS_GHC -fglasgow-exts #-}  module MO.Compile.Attribute where import MO.Base
src/MO/Compile/Class.hs view
@@ -1,4 +1,4 @@-{-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances -fallow-overlapping-instances #-}+{-# OPTIONS_GHC -fglasgow-exts #-}  module MO.Compile.Class where
src/MO/Compile/Role.hs view
@@ -1,4 +1,4 @@-{-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances #-}+{-# OPTIONS_GHC -fglasgow-exts #-}  module MO.Compile.Role where
src/MO/Run.hs view
@@ -1,4 +1,4 @@-{-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances -fallow-overlapping-instances -fparr #-}+{-# OPTIONS_GHC -fglasgow-exts -fparr #-}  module MO.Run (     module MO.Run,
src/MO/Run.hs-boot view
@@ -1,4 +1,4 @@-{-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances -fno-warn-orphans #-}+{-# OPTIONS_GHC -fglasgow-exts -fno-warn-orphans #-} {-# LANGUAGE KindSignatures #-} module MO.Run where import Data.Typeable