小编Sho*_*hon的帖子

我想将我的项目包含README.md在我的Sphinx文档中,例如 Can sphinx链接到不在根文档下面的目录中的文档？ - 在生成的Sphinx html文档中,我点击欢迎页面上的目录中的链接,然后转到README.md.

为此,readme_link.rst创建了包含行的文档

Readme File
-----------

.. include:: ../../README.md

我添加了这一行

README <readme_link>

进入toctree index.rst.与此同时,我README.md不会被解析为Markdown,而只是按原样打印到页面上.

我认为另一个想法可能是改为使用markdown文件readme_link.md,但是没有办法包含markdown文件.

如何将我的README.md解析为markdown？

(当然我不想把它重写为.rst.)

为什么m2r不起作用

我试图从.rst文件中的markdown文件中跟随Render输出,但这不起作用.我README.md有一些标题

# First heading

some text

## Second heading 1

some text

## Second heading 2

some text

我得到了错误WARNING: ../README.md:48: (SEVERE/4) Title level inconsistent:.我理解"标题级别不一致"是什么意思？我需要使用其他符号 - 但读入它们我意识到答案是指rst符号.这意味着我的降价自述文件实际上并未转化为rst.

PS:尝试类似这样的人的其他人是 https://muffinresearch.co.uk/selectively-including-parts-readme-rst-in-your-docs/

实际上,我所知道的每种语言基本上都是主题的变体:你创建变量和函数,然后使用条件和其他结构来操作它们.我理解功能编程等与"传统"语言有些不同,但在它们下面几乎是相同的.您仍在使用变量(有些,即使它们是不可变的等等),也可以创建函数.

是否有任何语言或系统完全取消我们现在使用的内容并采用完全不同的方法？

我正在尝试编写玩具逻辑编程查询语言,基于各种指令来源,包括SICP和Prolog的艺术(AoP).我刚刚开始研究统一算法的第一个草图(根据AoP的"逻辑编程计算模型的核心"),AoP指出

当为特定逻辑编程语言实现统一算法时,避免了堆栈和统一器上的等式中的显式替换.相反,逻辑变量和其他术语由具有不同值的存储器单元表示,并且通过将表示逻辑变量的存储器单元分配给包含变量所绑定的术语的表示的单元来实现变量绑定.(第1版,第71页)

阅读这篇文章让我意识到我对逻辑变量的工作方式只有粗略而实际的把握,但我并不真正理解它们是如何实现的.我甚至不确定将逻辑变量与声明性编程范例的其他区域中的不可变变量区分开来的精确,形式特征是什么.我将感激所有有启发性的解释和有益的参考.

动机

对于我的生活,我无法弄清楚如何在SML/NJ中使用更高阶的仿函数到任何实际的目的.

根据 SML/NJ关于实现特殊功能的文档,应该可以通过使用funsig关键字将一个仿函数指定为另一个仿函数.因此,给予签名

signature SIG = sig ... end

SIG当应用于满足某些签名的结构时,我们应该能够指定一个生成满足模块的仿函数 SIG'.例如,

funsig Fn (S:SIG') = SIG

通过Fn这种方式声明,我们应该(能够定义另一个将该仿函数作为参数的仿函数.即,我们可以定义一个参数化在另一个参数化模块上的模块,并且可能在前者中使用后者;因此:

functor Fn' (functor Fn:SIG) =
struct
...
structure S' = Fn (S:SIG')
...
end

这在理论上看起来都不错,但我无法弄清楚如何实际使用这种模式.

示例问题

以下是我尝试使用此模式的两个实例,但却发现它不切实际:

第一次尝试

对于我的第一次尝试,只是玩游戏,我试图制作一个仿函数,它将实现一个有序集的仿函数,并生成一个处理整数集的模块(不是很有用,但它可以让你参数化一组给定的键入不同的集合实现).我可以定义以下结构,它们将编译(使用新泽西州标准ML v110.7):

structure IntOrdKey : ORD_KEY
= struct
    type ord_key = int
    val compare = Int.compare
end

funsig SET_FN (KEY:ORD_KEY) = ORD_SET

functor IntSetFn (functor SetFn:SET_FN) =
struct
    structure Set = SetFn (IntOrdKey) …

我正在努力深入理解ML风格的模块:我认为这个概念很重要,我喜欢他们鼓励的那种思维方式.我刚刚发现参数类型和参数模块之间可能出现的张力.我正在寻找工具来思考这个问题,这将有助于我在构建程序时做出明智的设计决策.

拳头我将试着总体上描述我的问题.然后我将从我正在研究的学习项目中提供一个具体的例子.最后,我将重新审视一般性问题,以便将其引入一定程度.

(对不起,我还不太了解这个问题更简洁.)

总的来说,我发现的紧张是:当我们为它们提供参数类型签名(适当时)时,函数是最灵活的,并且对最广泛的重用开放.但是,当我们在模块内部封闭函数的参数化时,模块是最灵活的,并且对最广泛的重用是开放的,而是在给定类型上参数化整个模块.

在将实现LIST签名的模块与实现签名的 模块进行比较时,可以找到这种差异的现成示例ORD_SET.模块List:LIST提供了许多有用的函数,可以在任何类型上进行参数化.一旦我们定义或加载了一个List模块,我们就可以轻松地应用它提供的任何功能来构造,操作或检查任何类型的列表.例如,如果我们使用字符串和整数,我们可以使用同一个模块来构造和操作两种类型的值:

val strList = List.@ (["a","b"], ["c","d"])
val intList = List.@ ([1,2,3,4], [5,6,7,8])

另一方面,如果我们想要处理有序集合,那么事情是不同的:有序集合要求有序关系保持其所有元素,并且没有单个具体函数compare : 'a * 'a -> order 为每种类型产生该关系.因此,我们需要一个不同的模块来满足ORD_SET我们希望放入有序集合的每种类型的签名.因此,为了构造或操纵有序的字符串和整数集,我们必须为每种类型实现不同的模块[1]:

structure IntOrdSet = BinarySetFn ( type ord_key = int
                                    val compare = Int.compare )
structure StrOrdSet = BinarySetFn ( type ord_key = string
                                    val compare = String.compare )

然后,当我们希望对给定类型进行操作时,我们必须使用适当模块中的拟合函数:

val strSet = StrOrdSet.fromList ["a","b","c"]
val intSet = IntOrdSet.fromList [1,2,3,4,5,6]

这里有一个非常直接的权衡:LIST模块提供的范围超出你喜欢的任何类型的函数,但它们不能利用任何特定类型的值之间的任何关系; ORD_SET …

我正在构建一个相对简单的程序来收集和排序用户输入的数据。我想使用通过 Web 浏览器运行的本地服务器有两个原因：

1. HTML 表单是收集我需要的输入的一种简单而有效的方法。
2. 我希望能够离线运行程序，而不必管理访问远程服务器所涉及的安全风险。

编辑：澄清一下，我的意思是应用程序应该只能从本地网络而不是从 Internet 访问。

当我一直在寻找有关该问题的信息时，我遇到了一两条评论，表明本地服务器有自己的安全风险，但我不清楚这些风险的性质或严重程度。

（如果是相关的，我将使用 SWI-Prolog 来处理数据操作。我还计划为服务器使用SWI-Prolog HTTP 包，但如果结果证明是一个，我愿意重新考虑这个选择馊主意。）

我有两个问题：

1. 为此目的使用本地服务器时需要注意哪些安全风险？（注意：就我而言，该程序可能会处理一些非常敏感的信息，所以我在这个问题上没有任何松懈的余地）。
2. 如何降低这些风险？（或者，我应该在哪里学习如何解决这个问题？）

我非常感谢任何和所有的帮助！

我知道一些Prolog,刚开始在Haskell做一些自学.我一直在努力解决Haskell的99个问题,一路上学习并真正享受Haskell.有时我试图通过在Prolog中编写代码来解释我对问题空间的理解,然后思考该解决方案如何与Haskell中的函数方法相关.今晚,在处理逻辑问题(问题47和48)时,我分心试图完成构建一个包含n值的所有真值组合列表的简单任务.我想要一个功能tValues :: Int -> [[Bool]].这个问题可以在Prolog中以非常简单和声明的方式解决,例如:

combinations_of_n_truth_values(N, AllValues) :-
    findall(Values, n_truth_values(N, Values), AllValues).

n_truth_values(N, TruthValues) :-
    length(TruthValues, N),
    maplist(truth_value, TruthValues).

truth_value(true).
truth_value(false).

使用时,变量AllValues将与所需的真值列表列表统一.我想知道一位经验丰富的Haskell程序员将如何解决同样的问题.我希望有一个同样简单明了的解决方案,但我似乎无法让我的Haskell大脑以正确的方式运作.

我使用列表推导摆弄了一些半类似物,如下所示:

tValues:: Int -> [[Bool]]
tValues 0 = []
tValues n = [v:vs | v  <- tValue
                  , vs <- tValues (n-1) ] 

tValue :: [Bool]
tValue = [True, False]

但tValues只返回[].我想我只需要一些人与人之间的互动来帮助我清醒一下,并且可以让我更深入地了解我.

非常感谢.

my_computer([
    case([
        motherboard([board(plastic),ports(metal),slots(plastic),capacitors(plastic)]),
        power_supply_unit([casing(metal),cables(plastic),connectors(plastic),capacitors(plastic),fan(plastic),transformer(metal)]),
        central_processing_unit([board(plastic),fan(plastic),heatsink(metal)]),
        random_access_memory([board(plastic)]),
        graphics_processing_unit([board(plastic),ports(metal),capacitors(plastic),fan(plastic),heatsink(metal)])
    ]),
    monitor([
        lcd_screen(plastic),inverter(plastic),frame(plastic)
    ]),
    keyboard([
        key(plastic),frame(plastic),cable(plastic)
    ]),
    mouse([
        key(plastic),wheel(plastic),casing(plastic),cable(plastic)
    ])
]).

我应该怎么做才能运行类似monitor(X).或motherboard(X)提供一层或多层(子)材料的问题(就像my_computer(X).那样做)？

下面的代码对于提出这样的问题会更有用吗？关于一层子材料的问题很容易通过这种方式回答.

my_computer([case,monitor,keyboard,mouse]).
    case([motherboard,power_supply_unit,central_processing_unit,random_access_memory,graphics_processing_unit]).
        motherboard([board,ports,slots,capacitors]).
        power_supply_unit([casing,cables,connectors,capacitors,fan,transformer]).
        central_processing_unit([board,fan,heatsink]).
        random_access_memory([board]).
        graphics_processing_unit([board,ports,capacitors,fan,heatsink]).
    monitor([lcd_screen,inverter,frame]).
    keyboard(keys,frame,cable).
    mouse([keys,wheel,casing,cable]).

如果我尝试编写一个调用参数=提供的未指定类型的参数化模块,SML/NJ会抛出一个类型错误.例如,如果我有签名

signature SIG =
sig
  type t
end

并尝试使用签名在模块F上参数化模块SSIG

functor F (S : SIG) =
struct
  fun f (x:S.t) (y:S.t) = (x = y)
end

我将触发以下编译错误:

Error: operator and operand don't agree [equality type required]
  operator domain: ''Z * ''Z
  operand:         S.t * S.t
  in expression:
    x = y

如何指定S.t应该是相等类型？

到目前为止,我能够找到的唯一解决方法是在参数化仿函数的结构中提供相等函数,即:

signature SIG' =
sig
  type t
  val eq : (''a * ''a) -> bool
end

functor F' (S' : SIG') = …

根据https://github.com/ocaml/ocaml/pull/1110，OCaml 4.08 及更高版本会对未使用的模块打开发出警告，即使它们是使用open!. open! Foo这与使用来确定以下代码位于模块上下文中的常见做法产生了摩擦Foo（无论是否从内部使用任何东西Foo）。此外，由于dune默认情况下将所有警告视为致命错误，这将导致默认dev配置文件中的沙丘构建失败，并出现类似错误

$ dune build
File "lib/mylib.ml", line 1, characters 0-10:
1 | open! Core
    ^^^^^^^^^^
Error (warning 66): unused open! Core.

如何禁用此警告和致命错误？