这里是OCaml的新手。 基本上,我试图用两个函数来编译一段代码,但我不能编译它,因为在第9行,列字符26-27处出现了类型错误,如下所示: “错误:此表达式的类型为%t,但需要类型为string的表达式”“ 基本上,在第8行调用的解析函数需要类型字符串,但我不知道为什么。 sexp参数的类型: type sexp = Atom of string | List of sexp list 代码: open Sexplib.Sexp
let rec parse_bindings bindings =
match bindings with
| [] -> []
|
所以我正在编写一个程序,来显示所选元素的结合原子质量。下面是我的代码片段:
start :: Integer -> [Double] -> IO()
start num empty =
if num /= 0
then do
putStrLn "Term:"
term <- getLine
let atom = element term
putStrLn "Subscript:"
subscript
为什么下面的模式匹配在列表理解中不起作用?
一个术语数据类型中原子的同时替换。
数据类型:
data Term a
= Atom a
| Compound (Term a) (Term a)
deriving Show
原子的替换算法(如果有的话,选择第一个匹配的替换,而忽略其余的):
subs :: [(Term a, Term a)] -> Term a -> Term a
subs subList term = case term of
atom@(Atom x) -> let substitutions =
我正在尝试迭代在Jane Street 中定义的Sexp.t数据类型。我希望以显示其递归结构以进行调试的方式打印数据类型。到目前为止,这就是我所拥有的:
type sexp =
| Atom of string
| List of sexp list
(* pretty prints an sexp *)
let rec to_str (se : sexp) : string =
match se with
| Atom s -> s
| List [] -> ""
| List (hd :: tl) -> to_str hd ^ t
我正在学习教程,一个代码块让我想知道绑定和赋值之间的区别:
parseAtom = do first <- letter <|> symbol
rest <- many (letter <|> digit <|> symbol)
let atom = first:rest
return $ case atom of
"#t" -> Bool True
"
我正在用OCaml实现一种符号语言,并且一直在努力将我的s表达式树转换成抽象语法树。
S-表达式树是
(* sexpr.mli *)
type atom =
| Atom_unit
| Atom_int of int
| Atom_sym of string
type expr =
| Expr_atom of atom
| Expr_list of expr list
抽象语法树是
(* ast.ml *)
open Sexpr
type sym = string
(* abstract syntax tree nodes *)
type expr =
假设我有2个CNF逻辑短语a,b,我的distrib函数应该返回a|b (a OR b)的CNF形式。
替换我得到的规则是:
1) Replace p|(q&r) by (p|q)&(p|r)
2) Replace (q&r)|p by (q|p)&(r|p)
这样定义的道具:
datatype prop = Atom of string | Not of prop | And of prop*prop | Or of prop*prop;
函数:
local
fun doOr(prop1,prop2) = (Or(prop1,prop2))
fun di
我正在尝试用下面这段代码为一种小型语言编写一个解析器
import Text.ParserCombinators.Parsec
import Text.Parsec.Token
data Exp = Atom String | Op String Exp
instance Show Exp where
show (Atom x) = x
show (Op f x) = f ++ "(" ++ (show x) ++ ")"
parse_exp :: Parser Exp
parse_exp = (try parse_atom) <|>
让我们考虑下面的代码:
class A {
string a;
public A(string a) : a(a) { }
};
class B : public A {
public B(string a) : A(a) { }
};
int main() {
std::shared_ptr<A> x1 = std::make_shared<B>("x");
std::shared_ptr<A> x2 = std::make_shared<B>("x");
我的代码中有一个错误,结果是我在方法的代码中重新定义了一个方法参数,而没有意识到这一点。我预计会出现编译器错误,但我没有得到:
func someMethod(parameter:Int)
{
let parameter = 10 //Why does this not result in error?
}
我知道你可以做parameter = 10,但我不明白为什么let parameter = 10是有效的。
这种行为有什么好的理由吗?
你好,我正在尝试从pdb文件中取出以ATOM开头的所有行。不知为什么,我有麻烦了。我的代码是:
open (FILE, $ARGV[0])
or die "Could not open file\n";
my @newlines;
my $atomcount = 0;
while ( my $lines = <FILE> ) {
if ($lines =~ m/^ATOM.*/) {
@newlines = $lines;
$atomcount++;
}
}
print "@newlines\n";
print &
我正在看Control.Lens introduction 。
这让我想知道为什么Setter类型需要用函子包装东西。
它(大致)的定义如下:
type Control.Lens.Setter s t a b = (Functor f) => (a -> f a) -> s -> f t
假设我有一个名为Point的数据,定义如下:
data Point = Point { _x :: Int, _y :: Int } deriving Show
然后我可以这样写我自己的xlens:
type MySetter s t a b = (a -> b) -> s
假设它的工作方式与我预期的一样:
(do
(println (resolve 'a)) ; nil
(def a "a")
(println (resolve 'a))) ; #'user/a
我想要理解为什么这不是:
(future
(println (resolve 'b)) ; #'user/b (shouldn't it be still undefined at this point?)
(def b "b")
(println (resolve 'b))) ; #
我试图使用FParsec解析标准的简单类型(在lambda演算意义上),但我很难从Lex/Yacc风格转换到FParsec中使用的类型,特别是在递归定义方面。
我试图解析的类型的示例如下:
O
O -> o
(o -> o -> o) -> o
以下是我的尝试:
type SType =
| Atom
| Arrow of SType * SType
let ws = spaces
let stype, styperef = createParserForwardedToRef()
let