小编Cir*_*dec的帖子

鉴于可区分的类型,我们知道它Zipper是一个Comonad.对此,Dan Burton问道,"如果衍生产生了一个共同点,这是否意味着整合会产生一个单子？或者这是无意义的？".我想给这个问题一个特定的含义.如果类型是可区​​分的,它是否必然是monad？考虑到以下定义,问题的一个表述是要问

data Zipper t a = Zipper { diff :: D t a, here :: a }

deriving instance Diff t => Functor (Zipper t)

class (Functor t, Functor (D t)) => Diff t where
    type D t :: * -> *
    up :: Zipper t a -> t a
    down :: t a -> t (Zipper t a)

我们可以编写类似于签名的函数吗？

return :: (Diff t) => a -> t a
(>>=) …

在Haskell中,是否可以测试一个值是否已被评估为弱头正常形式？如果一个函数已经存在,我希望它有一个像这样的签名

evaluated :: a -> IO Bool

有一些类似功能的地方.

一个以前的答案给我介绍:sprintghci的命令,该命令将打印已经被迫弱头部正常形态的值只有部分.:sprint可以观察是否已评估某个值:

> let l = ['a'..]
> :sprint l
l = _
> head l
'a'
> :sprint l
l = 'a' : _

有可能IO检查本来是禁止的属性.例如,可以比较IO以查看两个值是否来自同一声明.这是由StableNames in提供System.Mem.StableName并用于解决数据统一中的可观察共享问题.相关内容StablePtr未提供检查引用值是否为弱头正常形式的机制.

可能已经有newtype一种翻转Ord,Bounded等感觉的东西

newtype FlipOrd a = FlipOrd {unFlip :: a} deriving (Eq)

instance (Ord a) => Ord (FlipOrd a) where
    compare = flip compare

instance (Bounded a) => Bounded (FlipOrd a) where
    minBound = FlipOrd maxBound
    maxBound = FlipOrd minBound

这在现有的Haskell软件包中存在于哪里？

注意:存在一个Reverse Functor非常不同的东西,幸运的是它有一种完全不兼容的东西.

我正在寻找一个功能

{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ConstraintKinds #-}

memoC :: (c => a) -> (c => a)

这样得到的as仅针对所提供的约束进行一次评估.

另一个简短版本

如何创建某种类型的值,a只有在存在某些约束的证明时才能检查c？

动机

我一直在追求一种通用的解决方案来记住表格的价值:

C a => a

所有类型的C约束和a范围都在哪里.通过Typeable约束a和一些智能构造器,可以Typeable a => b通过在TypeReps上构建trie 来安全地记住trie的脊柱.这个问题是关于更难的部分,在这样一个特里的叶子上放什么.

如果我们可以以某种方式a进入叶子,则trie的叶子最初需要具有C a => a某种具体类型的值a,因为类的字典无法从类型中查找.查找trie中的值将需要字典C a.这似乎等于根据传入的字典修改trie叶子上保存的值.

如果我们不能以某种方式a进入叶子,叶子将会有一个更加可怕C a => b的单一类型b,并且,在提供字典时,我们需要证明类型a(因此字典)可以由什么是举行b,这将不会比一个更强大TypeRep.

邪恶 …

我正在尝试建立一个可以启动nova实例的最小devstack,一些将具有公共地址,一些将需要打开到公共网络的连接.我希望能够为实例分配浮动ips,并使来自具有公共地址的实例的流量到达公共网络.

解决

Devstack将在一个带有两个物理接口的Ubuntu 14.04盒子上运行.第一个接口eth0是在10.48.4.0/22,我拥有地址10.48.6.232; 这是与盒子的管理连接.第二个接口eth1是10.48.8.0/22,拥有地址10.48.11.6和10.48.11.57-10.48.11.59.eth1配置为使用10.48.11.6地址,为浮动范围留下一小段地址.

auto eth1
iface eth1 inet static
    address 10.48.11.6
    netmask 255.255.252.0

我想使用范围10.48.11.57-10.48.11.59作为浮动IP池.这构成了我的开始local.conf

[[local|localrc]]

# Devstack host IP eth1 address
HOST_IP=10.48.11.6

# Private network
FIXED_RANGE=10.90.100.0/24
NETWORK_GATEWAY=10.90.100.1

# Public network
Q_FLOATING_ALLOCATION_POOL=start=10.48.11.57,end=10.48.11.59
FLOATING_RANGE=10.48.8.0/22
PUBLIC_NETWORK_GATEWAY=10.48.8.1

# Public network is eth1
PUBLIC_INTERFACE=eth1

ML2

我的相关部分的其余部分local.conf是配置neutron和ovs以使用公共网络.我按照评论中的说明进行操作neutron-legacy.

# Neutron
# -------

PUBLIC_BRIDGE=br-ex

Q_USE_PROVIDERNET_FOR_PUBLIC=True
PUBLIC_PHYSICAL_NETWORK=public
OVS_BRIDGE_MAPPINGS=public:br-ex

# Neutron Provider Network
ENABLE_TENANT_TUNNELS=True
PHYSICAL_NETWORK=public
OVS_PHYSICAL_BRIDGE=br-ex

# Use ml2 and openvswitch
Q_PLUGIN=ml2
Q_ML2_PLUGIN_MECHANISM_DRIVERS=openvswitch,logger
Q_AGENT=openvswitch
enable_service q-agt

# …

Applicative变压器类在哪里？我想在之前的答案中使用变压器类的变压器类,但它们似乎不存在.

该变压器包和许多其他的全是保护者变压器的Applicative结构,即使在底层结构不是Monad.

快速浏览一下transformers有Applicative大部分变压器的实例.

Applicative f => Applicative (Backwards f)
Applicative f => Applicative (Lift f)
Applicative (ContT r m)
Applicative m => Applicative (IdentityT m)
Applicative m => Applicative (ReaderT r m)
(Monoid w, Applicative m) => Applicative (WriterT w m)
(Applicative f, Applicative g) => Applicative (Compose f g)
(Applicative f, Applicative g) => Applicative (Product f g)

只有状态和替换的变换器(ExceptT和MaybeT)需要Applicative实例的底层monad . …

多金属型应用是否是内射的？

当我们能PolyKinds,我们知道f a ~ g b意味着f ~ g和a ~ b？

动机

当试图回答另一个问题时,我将问题减少到只有PolyKinds启用时才收到以下错误.

Could not deduce (c1 ~ c)
from the context ((a, c z) ~ (c1 a1, c1 b))

如果多金属型应用是单射的,我们可以推导c1 ~ c如下.

(a,   c z) ~ (c1 a1,   c1 b)
(a,) (c z) ~ (c1 a1,) (c1 b) {- switch to prefix notation -}
      c z  ~           c1 b  {- f a ~ g b …

AndrásKovács 在回答前一个问题时提出了这个问题.

在镜头风格的uniplate库中,* -> *基于类的类型

class Uniplate1 f where
    uniplate1 :: Applicative m => f a -> (forall b. f b -> m (f b)) -> m (f a)

类似于类的种类 *

class Uniplate on where
    uniplate :: Applicative m => on -> (on -> m on) -> m on

是有可能实现类似物contexts和holes,二者均具有类型Uniplate on => on -> [(on, on -> on)],而不需要Typeable1？

很明显,这可以在uniplate库的旧式中实现,该库用于Str通过返回具有子类型的类型级列表的结构来表示数据的结构.

一个洞可以用以下数据类型表示,它将替换(on, on -> on)为contexts …

我使用llvm-general-pure为LLVM语言中的程序构建抽象语法树.

使用提供的漂亮的打印机,我得到的输出看起来像

A.Module {
  A.moduleName = "main",
  A.moduleDataLayout = Nothing,
  A.moduleTargetTriple = Nothing,
  A.moduleDefinitions = [
    ...
    A.GlobalDefinition A.G.Function {
      A.G.linkage = A.L.External,
      A.G.visibility = A.V.Default,
      A.G.callingConvention = A.CC.C,
      A.G.returnAttributes = [],
      A.G.returnType = A.IntegerType {A.typeBits = 32},
      A.G.name = A.Name "Main",
      A.G.parameters = ([], False),
      A.G.functionAttributes = [],
      A.G.section = Nothing,
      A.G.alignment = 0,
      A.G.garbageCollectorName = Nothing,
      A.G.basicBlocks = [
        A.G.BasicBlock (A.Name "mainBlock") [
          A.Name "n57" A.:= A.Alloca {
            A.allocatedType = A.IntegerType {A.typeBits …

我有一个抽象基类：

import abc
import six

@six.add_metaclass(abc.ABCMeta)
class A(object):

    @abc.abstractmethod
    def f(self, arg1):
        pass

我想使用此类作为模拟的规范。

import mock
mock_a = mock.Mock(spec=A)

这部分起作用。例如，mock_a.x结果为AttribureError("Mock object has no attribute 'x')。但是mock_a.f，并未基于的抽象方法进行说明A.f。无论传递给的参数数量如何，它都会返回一个模拟f。

mock_a = mock.Mock(spec=A)

# Succeeds
print mock_a.f(1)

# Should fail, but returns a mock
print mock_a.f(1,2)

# Correctly fails
print mock_a.x

模拟可以创建speced一个模拟A.f带create_autospec...

f_spec = mock.create_autospec(A.f)

# Succeeds
f_spec(mock_a, 1)

# Correctly fails
f_spec(mock_a, 1, 2)

...但是对于A的属性却不这样做

如何创建可以准确实现抽象基类的模拟？