标签: ml

有没有更清洁的方式这样做？我正在尝试进行模式匹配

(a' option * (char * nodeType) list ref

我找到的唯一方法是这样做:

match a with
| _, l -> match !l with
  | (c, n)::t -> doSomething 

难道没有办法a与其他东西相匹配......

match a with
| _, ref (c,n)::t -> doSomething

......或类似的东西？在这个例子中,只是做另一个匹配看起来并不重,但在实际情况下,它可能有点......

谢谢你的回答.

标准ML中的函数与模块系统相关,并且可以基于其他结构生成结构.下面给出了为各种类型的列表生成列表组合器的仿函数的示例,但是此示例存在一个问题:

各种类型的列表都具有优势 - 例如,惰性列表可以无限长,并且concantenation列表具有O(1)concat运算符.但是当所有这些列表类型符合相同的签名时,仿函数只能使用它们的常规属性.

因此,我的问题是:什么是一个很好的例子,当函子有用时,各种生成的结构不会失去它们的特殊能力？

signature MYLIST =
sig
  type 'a t
  val null : 'a t -> bool
  val empty : 'a t
  val cons : 'a * 'a t -> 'a t
  val hd : 'a t -> 'a
  val tl : 'a t -> 'a t
end

structure RegularList : MYLIST =
struct
  type 'a t = 'a list
  val null = List.null
  val empty = []
  val cons = op::
  val hd = List.hd
  val tl …

任何人都可以向我解释数据/类型构造函数和函数之间的区别是什么？Haskell混合它们并给我们一个通用接口(所有看起来像函数,特别是,我们可以部分应用它们),而ML家族语言区分它们.

我试图推断以下表达式的类型:

let rec fix f = f (fix f)

应该给出类型 (a -> a) -> a

使用自下而上的算法(在概括hindley-milner类型推理算法中描述)后面添加了以下规则:

           a1, c1 |-BU e1 : t1     B = fresh var
---------------------------------------------------------
a1\x, c1 U {t' == B | x : t' in A} |-BU let rec x = e1 : t

我留下以下类型: t1 -> t2

以及以下限制:

t0 = fix
t1 = f
t2 = f (fix f)
t3 = f
t4 = fix f
t5 = fix
t6 = f

t3 = …

我正在尝试使用SML/NJ,我用它sml < source.sml来运行代码,但它打印出太多的信息.

例如,这是source.sml:

fun fac 0 = 1
  | fac n = n * fac (n - 1)
val r = fac 10 ;
print(Int.toString(r));

这是输出:

Standard ML of New Jersey v110.77 [built: Tue Mar 10 07:03:24 2015]
- val fac = fn : int -> int
val r = 3628800 : int
[autoloading]
[library $SMLNJ-BASIS/basis.cm is stable]
[autoloading done]
3628800val it = () : unit

来自标准ML中的抑制"val it"输出,如何禁用SMLNJ警告？,并且SMLNJ想要从每个print语句执行中删除"val it =():unit" …

在Idris中,Maybe类型定义如下:

data Maybe a = Just a | Nothing  

它在Haskell中的定义类似:

 data Maybe a = Just a | Nothing
     deriving (Eq, Ord)

这是ML版本:

datatype 'a option = NONE | SOME of 'a

使用Just和有Some什么好处？
没有它们为什么不定义类型？

例:

data Maybe a = a | Nothing

我知道OCaml不支持重载.然后,我们可以做些什么才能解决这个问题,而不是超载？

1)使用多态而不是？2)给不同的功能不同的名字？3)将同名函数放在不同的模块中？

哪一个会起作用？

在Ocaml中,具有不同arities的元组具有不同的类型和值构造函数:

# let a = (1, 2, 3);;
val a : int * int * int = (1, 2, 3)
# let b = (1, (2, 3));;
val b : int * (int * int) = (1, (2, 3))

注意,第二个例子(b)比第一个(a)更灵活,因为b - (2,3)的"尾部" - 本身是有效值:

# let (_, c) = b;;
val c : int * int = (2, 3)
# let d = snd b;;
val d : int * int = (2, 3)

是什么原因不解析"(1,2,3)"为"(1,(2,3))"而是为不同的arities引入无限(或甚至更糟,有限)数量的新类型和值构造函数？

我想要将外部库中的函数注释为已弃用,以确保它不会在我的项目中使用.我们假设该库提供以下模块:

module Lib : sig
  val safe_function : int -> unit
  val unsafe_function : int -> int -> unit
end = struct
  let safe_function _ = ()
  let unsafe_function _ _ = ()
end

Util.ml我的项目中有一个文件,我在每个文件中打开.在其中,我想做类似的事情:

open Lib

let unsafe_function = Lib.unsafe_function
  [@@deprecated "Use safe_function instead."]

let foo = (fun x -> x)
  [@@deprecated "BBB"]

type t =
  | A [@deprecated]
  | B [@deprecated]
  [@@deprecated]

编译以下usage.ml文件

open Util

let _ = unsafe_function 0 0
let _ = foo …

我不确定我是否理解分隔延续运算符对prompt/control和reset/shift之间的区别。我了解一些基本的使用示例，但在这些示例中它们的行为是相同的。

我在Dariusz Biernacki 和 Olivier Danvy 的“ On the Dynamic Extent of Delimited Continuations ”中找到了这个例子：

reset\n  (fn () => shift (fn k => 10 + (k 100))\n          + shift (fn k\xe2\x80\x99 => 1))\n\nprompt \n  (fn () => control (fn k => 10 + (k 100))\n          + control (fn k\xe2\x80\x99 => 1))\n

racket/control我已将其翻译成 Scheme 并使用该库在 Racket 中成功运行并获得了预期结果：

(reset  (+ (shift   k  (+ 10 (k 100)))\n           (shift   kk 1))) \n   ;; ==> 11\n\n(prompt …