我正在尝试将OCaml中的csv文件导入数组中。我确实意识到这并不是最适合语言的方法,我也不确定数组是否是最好的结构,但无论如何.它运转得很好,但我真的对我的做法感到不安。
let import file_name separator =
let reg_separator = Str.regexp separator in
let value_array = Array.make_matrix 1600 12 0. in
let i = ref 0 in
try
let ic = open_in file_name in
(* Skip the first l
我在OCaml上遇到了一个问题,我目前正在学习它,但我仍然是个新手。如果字符串为空或仅包含空格,则我希望创建一个返回true的函数,同时删除任何出现的begin和end。
我已经试过了
let isEmptyString s =
let rec empty i =
if i < 0 then true
else
let c = String.get s i in
if c = ' ' || c = '\009' then empty (pred i)
else false
我写了下面的代码,从列表中随机选择n个项目,并将选择的项目放在一个新的列表中,代码如下
let random_extract list n =
let l = ((List.length list)- 1)
and acc = [] in
for i = 1 to n do
(List.nth list (Random.int l) ) :: acc (* Line 447 *)
done;
acc
;;
当我加载包含此代码的文件时,我得到以下错误
File "all_code.ml", line 447, ch
我一直在尝试弄清楚我认为是一项非常简单的任务,即从一个函数中向OCaml中的字符串图添加条目。相关元素如下:
module StringMap = Map.Make (String);;
let m = StringMap.empty;;
let rec count ke = match ke with
|[] -> []
|hd::tl -> begin let m = StringMap.add hd 1 m; [hd] @ count tl end;;
我一直收到神秘的“语法错误”消息,但即使在将代码剥离到基本上什么都没有之后,我也还没有找到解决方案。我可以使用一个命令
最近,我正在读一些有关Haskell的函数式编程书籍。
例如,Haskell似乎很喜欢“模块化程序”,
f :: (Integer,Integer) -> Integer
f = sum . map sq . filter . odd . between
即使相同的函数可以编写成
f' (m, n) = go m
where go m | m > n = 0
| otherwise = go (m + 1) + if odd m then sq m else 0
“融合定律”也很受欢迎和使用()
我不是OCaml专家,但如果可能的话,我会使用
我正在看这个编程语言" ocaml“,我有一些麻烦,因为我读了ocaml的官方文档,但我不理解如何使用: ";“和”;“和"in”,特别是在函数的定义中。 这是我的代码: let abs_val value : int -> int =
let abs_ret = ref 0 ;
if value >= 0
then abs_ret := value
else abs_ret := -value ;
let return : int = abs_ret
;;
print_int abs_val -12 用"ocamlc“编译,它
出于学习的原因,我想在OCaml中使用For循环,而不是递归。 我做了一点研究,并应用了一个(https://ocaml.org/learn/tutorials/camlp4_3.10/foreach_tutorial.html)的例子: let a_list = ["hello"; "world"] in
for s in a_list do
print_endline s
done 这是有道理的。然而,当我查看它时(例如在Visual Studio上),它告诉我's‘是一个int变量。因此,我不能做这样的事情(其中'a',
有没有一种更优雅或者更好的方法来用F#/OCaml编写交换函数,而不是列出所有可能的情况? let commutative x y =
match x,y with
a, _ -> val1
|_, a -> val1
|b, _ -> val2
|_, b -> val2
...
|_,z -> |valN 当我写这个问题的时候,我想可以让函数变得递归,如果找不到匹配的话就交换参数。 let rec commutative x y =
match x,y
在“计划”中,我可以编写一个函数:
(define (eat-line line)
eat-line)
我可以用在一个循环中,比如:
(define (loop op)
(let ((line (read-line))
(loop (op line))))
在OCaml中,我试图定义一个函数:
let rec eat_line line = eat_line
但我发现了一个错误:
Error: This expression has type 'a -> 'b
but an expression was expected of type 'b
我想知道是否有任何方法可以让OCaml编译器报告关于未使用函数的警告?我在googled上搜索过,但是关于这个特性讨论的话题不多。
特别是在下面的程序中,有两个函数"foo“和"bar”被声明,但是"_“函数中没有使用"bar”。因此,我认为OCaml编译器应该将"bar“报告为未使用的函数。
let foo x y = x + y
let bar x y z = x + y + z (* should be reported unused *)
let _ =
let x = foo 1 2 in
x
我试图在OCAML中增加两种int类型,但我不确定自己可能做错了什么。
let prime = Int64.of_string("0x100000002b2") in
let temp = ref prime in
hash := Int64.mul(!temp,prime);
我知道错误了
Error: This expression has type 'a * 'b
but an expression was expected of type int64
对我怎么解决这个有什么建议吗?
我正在尝试在ocaml中做一个while do do循环,但是我在第21行(刚才说完成的那行)有一个语法错误,我不知道错误是什么。
let ver = 1 in
while ver > 0 do
let () = Printf.printf "Olá, insere o número de casas que o tabuleiro tem numa linha, separe por um espaço\n" in
let tudo = read_line () in (* Le a linha inserida*)
let ncc = tudo.[0] in (*
简单的例子:我有一些函数,我需要调用它们,来修改一个结构,只在一个函数中。使用这些简单的函数,任务可以使用不使用void的方式,但在其他任务中,您必须使用void。那你能做什么?
type player = { mutable name : string; mutable points : int } ;;
let putname brad = match brad with
{ name = x; points = y } -> { name = brad; points = y } ;;
let putpoint guy score = match guy with
{
我经常需要在OCaml中中断循环,至少有两种方法:
(* by exception *)
try
for i = 0 to 100 do
...
if cond then raise BreakLoop
done;
...
with BreakLoop -> ...
(* by while *)
let cond = ref false in
let i = ref 0 in
while (not !cond) && (i<= 100) do
...
i := !i + 1
done;
if !cond then ...
我最关心的
OCaml教程说,引用是“真实的变量”,您可以在整个程序中分配和更改这些变量。让-绑定并不能达到相同的目的。在这个中,它说当名称由let绑定设置时,不能"...reassign它指向不同的小部件“。我知道引用实际上存储在内存中,而让绑定不是,但我不明白他们对赋值的看法。
在Ocaml交互会话中,看起来让-绑定和引用做同样的事情,在语法上有一些不同。如果我使用let绑定将变量名设置为某个整数值,则该名称将返回该值,直到我将其解除或将名称重置为不同的整数为止,而let绑定将允许这样做。对于ints、floats和strings,这是正确的,但还没有尝试其他类型。我遗漏了什么?
# let
因此,我是OCaml的新手,我正在尝试为我的函数找出一种方法来检查多个条件,并在其中任何一个条件为真时修改变量
粗略的伪代码是
var list = []
if cond1 then 1::list
if cond2 then 2::list
etc
但据我所知,一旦你输入了一个if语句,你就会一直待在它里面,直到它返回一个值给函数。有没有办法绕过这个限制?感谢您的时间,提示或提示是非常感谢,因为我喜欢理解的语言
我是个新手。对int使用普通的旧ref,或者其他简单的内置类型,到目前为止,我在所有方面都像预期的那样工作。我在元组的上下文中使用了它们,其中ref是元组的成员。我可以更新引用,取消引用,等等。
# let e = 1, ref 1;;
val e : int * int ref = (1, {contents = 1})
# snd e := 2;;
- : unit = ()
# e;;
- : int * int ref = (1, {contents = 2})
# !(snd e);;
- : int = 2
但是,一旦我将一个命名类型"of ref“声明为其
我想要定义一个函数check_char_fun:(char ->‘a) -> ( char ->’a) -> bool,如果在char上有两个函数,则当两个函数相同时(即,当它们在每个可能的字符值上都是完全相同的行为时)返回true,否则返回false。
let check_char_fun f1 f2 =
let aux = true
for i=0 to 255 do
if (f1 (char_of_int i))=(f2 (char_of_int i))
then aux=false;
done;
if aux=true
then true
els
嗨,我一直在互联网上检查,以找到一种在OCaml中实现“字符串是否以特定文本结尾”的好方法,我发现在OCaml中操作字符串并不像我预期的那样简单。
下面是我的OCaml代码,它使用Str.regexp检查文件名称是否以".ml“结尾,以查看它是否是OCaml脚本文件。但是,它并不像我预期的那样起作用:
let r = Str.regexp "*\\.ml" in
if (Str.string_match r file 0)
then
let _ = print_endline ("Read file: "^full_path) in
我有一个让我疯狂的简单功能:
它应该是这种类型的函数:
myfunction : (int * int list) list -> int -> int
对于第一个参数的每个元组:
当第二个参数与元组的第一个元素匹配时,函数返回元组中列表的最后一个元素。
如果没有匹配,它应该返回-1。
let rec myfunction alist anum =
let last_e l =
let len = List.length l in
List.nth l (len - 1) in
match alist with
| [] -> -1
| (n
当我学习OCaml要点时,有人告诉我,OCaml中的每个函数实际上都是一个只有一个参数的函数。多参数函数实际上是一个函数,它接受一个参数,并返回一个函数,该函数接受下一个参数并返回.
这是赛跑,我知道了。
,所以我的问题是
案例1
如果我做了
let plus x y = x + y
在OCaml内部,当它编译时,OCaml是否会将它更改为let plus = fun x -> fun y -> x + y
或者相反的情况
案例2
如果我做了
let plus = fun x -> fun y -> x + y
OCaml将把它转换为let plus x y = x
我如何在OCaml中编写这样的代码(在C中是main())
for (i=0; i<y; i++)
if (x==5)
{
y=i;
return true;
}
它将返回布尔值True,y将等于相应的i值。
基本上,在OCaml中,我想知道您是否可以拥有一个if:
for i=0 to y-1 do
if x=5 then
begin
y=i
true
end
else ()
done;;
我知道开头-结束之间的线没有
我有一个程序,它循环遍历一个字符串并打印出每个字符的dir。
我想把这些dir值加到一个单独的离散值中,我可以打印出来。
以下是我的当前代码:
let word = "(())";;
let dir = function
| '(' -> 1
| ')' -> -1
| _ -> 0;;
let z =
(String.iter (fun (c: char) ->
let d = dir c in
Printf.printf "%d is the direction of %
我阅读了一个用OCaml编写的项目,但在这里找不到一些源代码:
type 'a node = {mutable parent: 'a node; mutable rank: int; label: 'a}
let singleton x =
let rec n = {parent=n; rank=0; label=x} in
n
这段代码是不相交集的一部分,但我并不真正理解递归函数。我以前是一个C++程序员,可以很容易地使用指针来处理父程序。
当我在OCaml utop中运行这段代码时,结果让我感到意外。它确实产生了许多节点。
这段代码是否需要很大的内存