小编Jus*_* L.的帖子

Haskell中的可变载体有三个元素级变异器:

read :: PrimMonad m => MVector (PrimState m) a -> Int -> m a
write :: PrimMonad m => MVector (PrimState m) a -> Int -> a -> m ()
swap :: PrimMonad m => MVector (PrimState m) a -> Int -> Int -> m ()

现在我可以使用这些 -

import Data.Vector
import Data.Vector.Mutable 
import Control.Monad.ST
import Control.Monad.Primitive 

incrAt :: Vector Double -> Int -> Vector Double
incrAt vec i = runST $ do
  mvec <- thaw vec
  oldval <- read …

例如,我总是看到所谓的方法String#split,但从来没有String.split,这似乎更合乎逻辑.或者甚至可能String::split,因为你可以考虑#split在名称空间中String.当假设/隐含(#split)时,我甚至独自看过这个方法.

我知道这是在ri中识别方法的方式.哪个先来？

这是区分,例如,来自领域的方法吗？我也听说这有助于区分实例方法和类方法.但这是从哪里开始的？

因此，我们有免费的monad ：（编码可能会有所不同，但它们都是一样的）

data Free f a = Pure a
              | Impure (f (Free f a))

instance Functor f => Monad (Free f) where
    pure = Pure
    Pure   x >>= f = f x
    Impure x >>= f = Impure ((>>= f) <$> x)

liftFree :: Functor f => f a -> Free f a
liftFree x = Impure (Pure <$> x)

runFree :: Monad g => (forall x. f x -> g x) -> Free f a -> g a …

它是一个非常普通的二叉树,除了其中一个节点可能为空的事实.

我想找到一种以水平方式输出它的方法(也就是说,根节点在左侧并向右扩展).

我有一些垂直扩展树木的经验(根节点在顶部,向下扩展),但在这种情况下,我不知道从哪里开始.

最好是遵循以下几条规则:

• 如果一个节点只有一个子节点,则可以将其作为冗余跳过(始终显示"终端节点",没有子节点)
• 相同深度的所有节点必须垂直对齐; 所有节点必须位于所有较低深度节点的右侧,并且位于所有较深节点的左侧.
• 节点具有包含其深度的字符串表示.
• 每个"端节点"都有自己独特的线路; 也就是说,行数是树中终端节点的数量,当终端节点在一条线上时,该终端节点之后该行上可能没有其他内容.
• 作为最后一条规则的结果,根节点在左上角或左下角可能会更好; 左上角是首选.

例如,这是一个有效的树,有六个端节点(节点由一个名称及其深度表示):编辑:请参阅问题的底部以获得替代,更容易渲染

        
[a0]-----------[b3]------[c5]------[d8]
    \              \         \----------[e9]
     \              \----[f5]
      \-[g1]--------[h4]------[i6]
            \           \--------------------[j10]
             \-[k3]

它代表垂直的显式二叉树:

0              a
              / \
1            g   *
            / \   \
2          *   *   *
          /     \   \
3        k       *   b
                /   / \
4              h   *   *
              / \   \   \
5            *   *   f   c
            /     \     / \
6          *       i   *   *
          /           /     \
7        *           *       *
        /           / …

编辑 正如有人指出的那样,我正在寻找的实际上是最小化所有其他点之间的总测地距离的点

我的地图在地形上类似于吃豆人和小行星的地图.越过顶部会让你翘起到底部,经过左边会让你向右弯曲.

假设我在地图上有两个点(质量相同),我想找到它们的质心.我可以使用经典定义,它基本上是中点.

但是,让我们说这两点是在质量的两端.可以说,还有另一个质心,它是通过"环绕"包裹而形成的.基本上,它是与其他两个点等距的点,但是通过"环绕"边缘来链接.

例

b . O . . a . . O .

两点O.他们的"经典"中点/质心是标记的点a.然而,另一个中点也在b(b通过环绕绕两个点等距离).

在我的情况下,我想选择两点之间平均距离较低的那个.在这种情况下,a具有三个步骤的两个点之间的平均距离. b平均距离为两步.所以我会选择b.

解决两点情况的一种方法是简单地测试经典中点和最短环绕中点,并使用具有较短平均距离的中点.

然而!这不容易推广到3个点,或4个,或5个,或n个点.

有没有我可以用来找到这个的公式或算法？

(假设所有积分将永远是等质量的,我只能用"重心",因为它是我知道松散地描述我试图做的唯一项)

如果我的解释不清楚,我会尝试更好地解释它.

我正在处理这种形状的数据类型,使用Vfromlinear:

type Foo n = V (n * 3) Double -> Double

修好了 n它非常重要,因为我希望能够确保在编译时传递正确数量的元素.这是我的程序的一部分,已经运行良好,独立于我在这里做的事情.

对于任何人KnownNat n,我可以生成Foo n令人满意的程序所需的行为.出于这个问题的目的,它可能是愚蠢的

mkFoo :: KnownNat (n * 3) => Foo n
mkFoo = sum

或者对于一个更有意义的例子,它可以生成V相同长度的随机数并dot在两者上使用.KnownNat这里的约束是多余的,但实际上,它需要做一个Foo.我制作一个Foo并将它用于我的整个程序(或多个输入),所以这保证了我每次使用它时,我都会使用相同长度的东西,以及Foo指示结构的东西.

最后,我有一个函数可以为Foo:

bar :: KnownNat (n * 3) => Proxy n -> [V (n * 3) Double]

bar实际上是我n * 3用作类型函数的原因,而不是仅仅手动扩展它.原因是bar可以通过使用三个长度向量n并将它们作为长度向量附加在一起来完成其工作n …

我不完全确定如何问这个,但有没有办法显示一个thunk的结构？

例如

f x = x + 2
g x = 3 x

compo x = f (g x)

ans = compo 5
-- result: (3 * 5) + 2 = 17

有什么方法可以"看到"thunk ans吗？就像在,我可以看到β减少的过程compo或像"一般"形式.

我想看看,例如:

compo n
--> (3 * n) + 2

就像在,如果我有一个函数compo x,我想看到它被分解为(3*n)+2.

例如,在Mathematica中:

f[x_] := x+2;
g[x_] := 3*x;
compo[x_] := f[g[x]];

compo[n]
(%
  --> (3 * n) + 2
%)

根据我的理解,元组上的延迟模式匹配只是推迟(,)构造函数的解析......如果我们立即使用这两个字段,那么真的有任何缺点吗？无论如何它都会得到解决......

有没有理由不使用懒惰模式匹配？

foo ~(x, y) = x + y
-- vs
foo (x, y)  = x + y

你何时喜欢使用第二个？

编辑:我特别感兴趣的是只有一种模式并且模式总是匹配的情况.

我有一个简化版本的标准解释器monad变换器生成FreeT:

data InteractiveF p r a = Interact p (r -> a)

type Interactive p r = FreeT (InteractiveF p r)

p是"提示",r是"环境"......人们可以使用以下方式运行:

runInteractive :: Monad m => (p -> m r) -> Interactive p r m a -> m a
runInteractive prompt iact = do
  ran <- runFreeT iact
  case ran of
    Pure x -> return x
    Free (Interact p f) -> do
      response <- prompt p
      runInteractive prompt (f resp)

instance MonadFix m => …

我有一个bash脚本: my.sh

#!/bin/bash

do_sth()
{
    sleep 5
}

main()
{
    do_sth >/dev/null &
    echo do sth in background ...
}

if [ "$1" = "1st_way" ]; then
    main
elif [ "$1" = "2nd_way" ]; then
    main >/dev/null
fi

以下命令立即返回

./my.sh 1st_way | cat

但是,以下命令会阻塞5秒钟

./my.sh 2nd_way | cat

我想知道为什么它会以第二种方式阻挡5秒钟.