如何刷新oracle中的物化视图(How to refresh materialized view in oracle)

 是的，你是对的，你正在寻找代数数据类型。 在Learn You a Haskell上有一个很棒的教程。 
 
 为了记录，来自OOP的抽象类的概念实际上有三种不同的翻译成Haskell，而ADT仅仅是一种。 这里简要介绍一下这些技术。 
 
 代数数据类型 
 
 代数数据类型对其子类已知的抽象类的模式进行编码，其中函数通过向下转换来检查对象是哪个特定实例。 
 
abstract class IntBox { }

class Empty : IntBox { }

class Full : IntBox {
    int inside;
    Full(int inside) { this.inside = inside; }
}

int Get(IntBox a) {
    if (a is Empty) { return 0; }
    if (a is Full)  { return ((Full)a).inside; }
    error("IntBox not of expected type");
}
 
 翻译成： 
 
data IntBox = Empty | Full Int

get :: IntBox -> Int
get Empty = 0
get (Full x) = x
 
 功能记录 
 
 这种风格不允许向下转换，所以上面的Get函数在这种风格中是不可表达的。 所以这里完全不同。 
 
abstract class Animal { 
    abstract string CatchPhrase();
    virtual void Speak() { print(CatchPhrase()); }
}

class Cat : Animal {
    override string CatchPhrase() { return "Meow"; }
}

class Dog : Animal {
    override string CatchPhrase() { return "Woof"; }
    override void Speak() { print("Rowwrlrw"); }
}
 
 它在Haskell中的翻译不会将类型映射到类型中。 Animal是唯一的类型， Dog和Cat被挤压到它们的构造函数中： 
 
data Animal = Animal {
    catchPhrase :: String,
    speak       :: IO ()
}

protoAnimal :: Animal
protoAnimal = Animal {
    speak = putStrLn (catchPhrase protoAnimal)
}

cat :: Animal
cat = protoAnimal { catchPhrase = "Meow" }

dog :: Animal
dog = protoAnimal { catchPhrase = "Woof", speak = putStrLn "Rowwrlrw" }
 
 这个基本概念有几种不同的排列。 不变的是，抽象类型是记录类型，其中方法是记录的字段。 
 
 编辑：有关此方法的一些细微之处的评论中有一个很好的讨论，包括上述代码中的一个错误。 
 
 类型类 
 
 这是我最不喜欢的面向对象思想的编码。 OO程序员很舒服，因为它使用熟悉的单词和地图类型来表示类型。 但是当事情变得复杂时，以上函数的记录往往更容易处理。 
 
 我将再次编码Animal示例： 
 
class Animal a where
    catchPhrase :: a -> String
    speak       :: a -> IO ()

    speak a = putStrLn (catchPhrase a)

data Cat = Cat 
instance Animal Cat where
    catchPhrase Cat = "Meow"

data Dog = Dog
instance Animal Dog where
    catchPhrase Dog = "Woof"
    speak Dog = putStrLn "Rowwrlrw"
 
 这看起来不错，不是吗？ 当你意识到即使它看起来像面向对象的时候，困难就出现了，它并不像面向对象那样工作。 你可能想要一个动物列表，但你现在可以做的最好的动物是Animal a => [a] ，同类动物列表，例如。 只有猫或只有狗的列表。 然后你需要使这个包装类型： 
 
data AnyAnimal = forall a. Animal a => AnyAnimal a
instance Animal AnyAnimal where
    catchPhrase (AnyAnimal a) = catchPhrase a
    speak (AnyAnimal a) = speak a
 
 然后[AnyAnimal]就是你想要的动物列表。 然而，事实证明， AnyAnimal在第二个例子中公开了关于它自己的与Animal记录完全相同的信息，我们刚刚以迂回的方式进行了讨论。 因此，为什么我不认为类型类是一个非常好的面向对象编码。 
 
 因此总结本周版本的方式太多信息！ 

Yes, you are correct, you are looking for algebraic data types. There is a great tutorial on them at Learn You a Haskell.
 
For the record, the concept of an abstract class from OOP actually has three different translations into Haskell, and ADTs are just one. Here is a quick overview of the techniques.
 
Algebraic Data Types
 
Algebraic data types encode the pattern of an abstract class whose subclasses are known, and where functions check which particular instance the object is a member of by down-casting.
 
abstract class IntBox { }

class Empty : IntBox { }

class Full : IntBox {
    int inside;
    Full(int inside) { this.inside = inside; }
}

int Get(IntBox a) {
    if (a is Empty) { return 0; }
    if (a is Full)  { return ((Full)a).inside; }
    error("IntBox not of expected type");
}
 
Translates into:
 
data IntBox = Empty | Full Int

get :: IntBox -> Int
get Empty = 0
get (Full x) = x
 
Record of functions
 
This style does not allow down-casting, so the Get function above would not be expressible in this style. So here is something completely different.
 
abstract class Animal { 
    abstract string CatchPhrase();
    virtual void Speak() { print(CatchPhrase()); }
}

class Cat : Animal {
    override string CatchPhrase() { return "Meow"; }
}

class Dog : Animal {
    override string CatchPhrase() { return "Woof"; }
    override void Speak() { print("Rowwrlrw"); }
}
 
Its translation in Haskell doesn't map types into types. Animal is the only type, and Dog and Cat are squashed away into their constructor functions:
 
data Animal = Animal {
    catchPhrase :: String,
    speak       :: IO ()
}

protoAnimal :: Animal
protoAnimal = Animal {
    speak = putStrLn (catchPhrase protoAnimal)
}

cat :: Animal
cat = protoAnimal { catchPhrase = "Meow" }

dog :: Animal
dog = protoAnimal { catchPhrase = "Woof", speak = putStrLn "Rowwrlrw" }
 
There are a few different permutations of this basic concept. The invariant is that the abstract type is a record type where the methods are the fields of the record.
 
EDIT: There is a good discussion in the comments on some of the subtleties of this approach, including a bug in the above code.
 
Typeclasses
 
This is my least favorite encoding of OO ideas. It is comfortable to OO programmers because it uses familiar words and maps types to types. But the record of functions approach above tends to be easier to work with when things get complicated.
 
I'll encode the Animal example again:
 
class Animal a where
    catchPhrase :: a -> String
    speak       :: a -> IO ()

    speak a = putStrLn (catchPhrase a)

data Cat = Cat 
instance Animal Cat where
    catchPhrase Cat = "Meow"

data Dog = Dog
instance Animal Dog where
    catchPhrase Dog = "Woof"
    speak Dog = putStrLn "Rowwrlrw"
 
This looks nice, doesn't it? The difficulty comes when you realize that even though it looks like OO, it doesn't really work like OO. You might want to have a list of Animals, but the best you can do right now is Animal a => [a], a list of homogeneous animals, eg. a list of only Cats or only Dogs. Then you need to make this wrapper type:
 
{-# LANGUAGE ExistentialQuantification #-}

data AnyAnimal = forall a. Animal a => AnyAnimal a
instance Animal AnyAnimal where
    catchPhrase (AnyAnimal a) = catchPhrase a
    speak (AnyAnimal a) = speak a
 
And then [AnyAnimal] is what you want for your list of animals. However, it turns out that AnyAnimal exposes exactly the same information about itself as the Animal record in the second example, we've just gone about it in a roundabout way. Thus why I don't consider typeclasses to be a very good encoding of OO.
 
And thus concludes this week's edition of Way Too Much Information!