小编Sho*_* Ya的帖子

假设我有一个可枚举的对象enum,现在我想得到第三个项目.

我知道一种通用方法是转换为数组,然后使用索引访问:

enum.to_a[2]

但是这种方式会创建一个临时数组,效率可能会很低.

现在我使用:

enum.each_with_index {|v, i| break v if i == 2}

但这是非常丑陋和多余的.

最有效的方法是什么？

我正在尝试为图形编写类型类.基本上,类型类看起来像:

class Graph g where
  adjacentNodes :: g n -> n -> [n]

我在其中n用来表示节点的类型.

然后我有如下Graph定义:

data FiniteGraph n = FiniteGraph { runFiniteGraph :: Array n [n] }

Array从标准容器采用的地方Data.Array,该结构用于表示将每个节点映射到其相邻节点的方式的有限图.

当我尝试创建FiniteGraph一个实例时,问题出现了Graph.

instance Graph FiniteGraph where
  adjacentNodes g n = (runFiniteGraph g) ! n

不幸的是,这不起作用,因为!运算符需要约束Ix n,但我找不到声明它的位置.

我希望实例声明有点像:

instance (Ix n) => Graph (FiniteGraph n) where { ... }

但是这需要gin 而不是class Graph g那种,以至于我无法在哪里显示依赖.** …

我正在阅读 B.Russell 的《数学哲学导论》一书，并试图将其中描述的所有定理形式化。

一对多关系由以下文本（书上的上下文）描述。

一对多关系可以定义为这样的关系，如果 x 与 y 具有相关关系，则没有其他项 x' 也与 y 具有关系。

或者，它们可以定义如下：给定两个项 x 和 x'，x 与之有给定关系的项和 x' 与之有关系的项没有共同成员。

或者，再一次，它们可以被定义为这样的关系，即其中一个关系的相对乘积及其逆向意味着同一性，其中两个关系 R 和 S 的“相对积”是当存在 x 和 z 时在 x 和 z 之间成立的关系中间项 y，使得 x 具有 R 与 y 的关系，y 具有 S 与 z 的关系。

它提出了三种定义方式。我已经成功地描述了前两个并证明了它们的等效性。在卡在第三个的时候，我试图摆脱“相对产品”的概念，直接触及它的内涵，但也失败了。

以下是我的定义，我有没有弄错？

Definition one_many {X} (R : relation X) : Prop :=
  forall x y, R x y -> forall x', x <> x' -> ~(R x' y).

Definition one_many' {X} (R : …

最近,我一直在开发一个具有客户端和服务器的开源代理.客户端和服务器都有脚本.

服务器端可以在云平台上运行,客户端连接服务器.

我在Heroku上注册了一个用于调试服务器的应用程序,该应用程序的地址暂时写在客户端脚本中.

这就是环境.但显然服务器的地址仅用于个人调试.我不想公之于众.

我当前的方法是,每次我提交到存储库之前,我都会删除该地址,并在提交后,我将其添加回来.这显然不是一个好方法.

这种现象应该很常见.人们通常如何处理这个问题？

我正在学习用任意级别类型的实用类型推断的类型推断,我陷入了困境.我基本上对关于更多多态的概念感到困惑,因此无法继续.

在其第3.3节中,它指出:

如果函数的类型比函数的参数类型更具多态性,则该函数可以接受该参数.

在我的理解中,要说T1比T2具有类型的任何实例T2必须满足类型更具多态性T1.所以根据我的定义,forall a. a比多态更多Int.forall a b. a -> b -> b比forall a. a -> a -> a.更多态.

据我了解,存在冲突.鉴于:

f :: (forall a. a) -> Int
k :: (forall a. a -> a)

(f k)显然是有效的[1].然后根据文章的引文,forall a. a -> a应该比多态多forall a. a.然而,举一个例子,文字1将满足,forall a. a而显然它不是一个forall a. a -> a,因此根据我的定义,forall …

我正在尝试实现自己的应用解析器，这是我使用的代码：

{-# LANGUAGE ApplicativeDo, LambdaCase #-}

module Parser where

-- Implementation of an Applicative Parser

import Data.Char
import Control.Applicative (some, many, empty, (<*>), (<$>), (<|>), Alternative)

data Parser a = Parser { runParser :: String -> [(a, String)] }

instance Functor Parser where
  -- fmap :: (a -> b) -> (Parser a -> Parser b)
  fmap f (Parser p) = Parser (\s -> [(f a, s') | (a,s') <- p s])

instance Applicative Parser where
  -- pure :: a -> …

假设这段代码有效：

left '*'
left '+'

expr: expr '+' expr
    | expr '*' expr
    ;

我想定义另一个优先标记，例如：

left MULTIPLY
left PLUS

expr: expr '+' expr %prec PLUS
    | expr '*' expr %prec MULTIPLY
    ;

但这实际上并没有效果。

我认为这两种形式应该是等价的，但事实并非如此。

这不是实际问题。我只是想知道这种现象的原因和原理。

谢谢。

我最近正在学习计划并且对一个没有标识符就无法评估宏的设计感到好奇,而lambda(程序)可以这样做.

例如,我可以使用匿名lambda:

((lambda x x) 1 2 3)

似乎我必须使用以下语法定义宏:

(define-macro my-macro (lambda x x))

我很好奇为什么这样的方法会像这样直接创建一个宏:

(define my-macro (macro-lambda x x))

我想如果将宏和lambda视为不同的类型,第二个可能更优雅.

我的问题是:

1. 怎么define-macro办？
2. 宏和lambda之间的根本区别是什么？
3. 方案中是否有匿名宏,如果没有,为什么？

我有一个类型T定义如下,我想在其中包含一个整数.

newtype T = T Int
-- liftM2 (+) (T 1) (T 2)    -- error: `T' is not an instance of Monad

现在,如果我想在包装器中包装一个操作值并返回类似于结果的结果liftM*,就像上面的代码所示,但它不起作用.我期望一组功能myLiftT2如下所示,但更普遍适用.

myLiftT2 :: (Int -> Int -> Int) -> T -> T -> T
myLiftT2 f (T a) (T b) = T $ f a b

myLiftT2 (+) (T 1) (T 2)     -- `T 3'

我知道我可以将它定义为Monad或Applicative并且实际上效果很好:

newtype T a = T a

instance Monad T where
  (T a) >>= f = f …

我发现当尝试捕获退出信号时，使用pid 启动 GenServer 的结果与GenServer.start运行.Process.linkGenServer.start_link

这是我用来演示该问题的实验代码：

defmodule Foo do
  defmodule Server do
    def init(_) do
      Process.flag(:trap_exit, true)
      {:ok, nil}
    end
    def handle_info({:EXIT, from, reason}, _) do
      IO.inspect({:kill_signal, from, reason})
      {:noreply, nil}
    end
  end

  def foo() do
    Process.flag(:trap_exit, true)
    # version 1
    {:ok, pid} = GenServer.start_link(Server, nil)

    # version 2
    # {:ok, pid} = GenServer.start(Server, nil)
    # Process.link(pid)

    # print process info
    IO.inspect({self(), pid, Process.info(pid)})

    Process.exit(pid, :reason)

    :timer.sleep(200)
  end
end

Foo.foo

在版本 1 中，EXIT 信号导致Server退出而不会被捕获在其handle_info …