Wolfram 语言与系统参考资料中心

TypeDeclaration

TypeDeclaration["Product",name,<|field₁type₁,field₂type₂,…|>]

表示具有指定字段的 product 类型的声明.

TypeDeclaration["Abstract",name]

表示抽象类型 name 的声明.

TypeDeclaration["Alias",name,targetType]

表示类型 name 的声明，使用的是 targetType 的内部表示.

TypeDeclaration["Macro",name,targetType]

表示一个声明，指定 name 的所有实例应被 targetType 替换.

TypeDeclaration

TypeDeclaration["Product",name,<|field₁type₁,field₂type₂,…|>]

表示具有指定字段的 product 类型的声明.

TypeDeclaration["Abstract",name]

表示抽象类型 name 的声明.

TypeDeclaration["Alias",name,targetType]

表示类型 name 的声明，使用的是 targetType 的内部表示.

TypeDeclaration["Macro",name,targetType]

表示一个声明，指定 name 的所有实例应被 targetType 替换.

范例

打开所有单元关闭所有单元

基本范例 (2)

将 "fooInteger" 的声明表示为 "MachineInteger" 的宏类型：

Wolfram Language code: dec = TypeDeclaration["Macro", "fooInteger", "MachineInteger"];

用声明编译函数：

Wolfram Language code: cf = FunctionCompile[dec, Function[Typed[arg, "fooInteger"], arg + 2]]

Wolfram Language code: cf[5]

全局声明 "fooInteger" 为 "MachineInteger" 的宏：

Wolfram Language code:

CompilerEnvironmentAppendTo[{
	TypeDeclaration["Macro", "fooInteger", "MachineInteger"]
	}];

用 "fooInteger" 编译一个函数：

Wolfram Language code: cf = FunctionCompile[Function[Typed[arg, "fooInteger"], arg + 2]]

Wolfram Language code: cf[5]

重置编译环境以清除声明：

Wolfram Language code: $CompilerEnvironment = CreateCompilerEnvironment[];

范围 (6)

"Product" (2)

product 类型的声明：

Wolfram Language code: dec = TypeDeclaration["Product", "simpleProd", <|"field1" -> "MachineInteger", "field2" -> "Boolean"|>];

编译一个实例化 product 类型的函数，然后提取一个字段：

Wolfram Language code:

cf = FunctionCompile[dec, Function[{}, 
	With[{prod = CreateTypeInstance["simpleProd", <|"field1" -> 12, "field2" -> True|>]}, 
	prod["field1"]]
	]]

Wolfram Language code: cf[]

多态 product 类型的声明：

Wolfram Language code: dec = TypeDeclaration["Product", "polyProd"::[T], <|"field1" -> T, "field2" -> "Boolean"|>];

编译一个接受机器整数的函数，并使用它来创建上面的 product 类型：

Wolfram Language code:

cf = FunctionCompile[dec, 
	Function[{Typed[n, "MachineInteger"]}, 
	Module[{prod = CreateTypeInstance["polyProd", <|"field1" -> n, "field2" -> True|>]}, 
	prod["field1"] + 1
	]
	]
	]

Wolfram Language code: cf[42]

"Abstract" (1)

抽象类型的声明：

Wolfram Language code: dec1 = TypeDeclaration["Abstract", "simpleAbstract"];

作为抽象类型实例的 product 类型的声明：

Wolfram Language code:

dec2 = TypeDeclaration["Product", "abstractInstance1", <|"field1" -> "MachineInteger", "field2" -> "Boolean"|>, "AbstractTypes" -> {"simpleAbstract"}];

不是抽象类型实例的 product 类型的声明：

Wolfram Language code: dec3 = TypeDeclaration["Product", "abstractInstance2", <|"field1" -> "MachineInteger", "field2" -> "Real64"|>];

接受任何抽象类型实例的函数的声明：

Wolfram Language code:

dec4 = FunctionDeclaration[fieldExtractor, 
	Typed[ForAllType[t, t∈"simpleAbstract", {t} -> "MachineInteger"]]@
	Function[arg, arg["field1"]]
	];

用该函数编译程序，处理是抽象类型实例的类型：

Wolfram Language code:

cf = FunctionCompile[{dec1, dec2, dec3, dec4}, Function[{}, 
	fieldExtractor[CreateTypeInstance["abstractInstance1", <|"field1" -> 12, "field2" -> True|>]]
	]]

Wolfram Language code: cf[]

该函数不接受不是抽象类型实例的类型的输入：

Wolfram Language code:

FunctionCompile[Function[{}, 
	fieldExtractor[CreateTypeInstance["abstractInstance2", <|"field1" -> 12, "field2" -> 3.4|>]]
	]]

"Alias" (1)

"String" 类型的别名：

Wolfram Language code: dec = TypeDeclaration["Alias", "aliasString", "String"];

别名的函数与其在原始类型上的实现不同：

Wolfram Language code:

funcDec = FunctionDeclaration[StringLength, 
	Typed[{"aliasString"} -> "MachineInteger"]@
	Function[arg, 12]
	];

编译一个程序，通过 bitcasting 实例化别名，然后用来对函数进行计算：

Wolfram Language code:

cf = FunctionCompile[{dec, funcDec}, Function[Typed[str, "String"], 
	StringLength[Cast[str, "aliasString", "BitCast"]]]]

Wolfram Language code: cf["hello"]

"Macro" (2)

"String" 类型的宏：

Wolfram Language code: dec = TypeDeclaration["Macro", "macroString", "String"];

用宏指代 "String" 的函数：

Wolfram Language code: cf = FunctionCompile[{dec}, Function[Typed[expr, "macroString"], StringLength[expr]]]

Wolfram Language code: cf["hello"]

宏不是类型，而是在解析时应用于类型的替换规则. 因此，一个宏和它所指代的类型不可能对同一个函数有不同的定义：

Wolfram Language code: dec = TypeDeclaration["Macro", "macroString", "String"];

Wolfram Language code:

funcDec = FunctionDeclaration[StringLength, Typed[{"macroString"} -> "MachineInteger"]@
	Function[arg, 12]
	];

Wolfram Language code:

FunctionCompile[{dec, funcDec}, 
	Function[Typed[arg, "macroString"], StringLength[arg]]]

与宏不同，别名是类型，因此函数可以识别它们是应用于类型还是该类型的别名.

选项 (11)

"AbstractTypes" (2)

表示一个抽象类型：

Wolfram Language code: absDec = TypeDeclaration["Abstract", "simpleAbstract"];

表示是抽象类型成员的对象：

Wolfram Language code:

prodDec = TypeDeclaration["Product", "abstractInstance", <|"field1" -> "MachineInteger", "field2" -> "Boolean"|>, "AbstractTypes" -> {"simpleAbstract"}];

表示一个接受任何抽象类型实例的函数：

Wolfram Language code:

funcDec = FunctionDeclaration[abstractEater, 
	Typed[ForAllType[t, t∈"simpleAbstract", {t} -> "MachineInteger"]]@
	Function[arg, 42]];

编译该函数，显示它接受是抽象类型成员的 product 类型：

Wolfram Language code:

cf = FunctionCompile[{absDec, prodDec, funcDec}, 
	Function[{}, With[{
	obj = CreateTypeInstance["abstractInstance", <|"field1" -> 12, "field2" -> False|>]}, 
	abstractEater[obj]]
	]]

Wolfram Language code: cf[]

表示一个抽象类型：

Wolfram Language code: superDec = TypeDeclaration["Abstract", "superType"];

表示是第一个抽象类型成员的另一个抽象类型：

Wolfram Language code: subDec = TypeDeclaration["Abstract", "subType", "AbstractTypes" -> {"superType"}];

表示是第二个抽象类型的实例的 product 类型：

Wolfram Language code:

prodDec = TypeDeclaration["Product", "abstractInstance", <|"field1" -> "MachineInteger", "field2" -> "Boolean"|>, "AbstractTypes" -> {"subType"}];

表示一个接受抽象类型 "superType" 的任何实例的函数：

Wolfram Language code:

funcDec = FunctionDeclaration[abstractEater, 
	Typed[ForAllType[t, t∈"superType", {t} -> "MachineInteger"]]@
	Function[arg, 42]];

编译该函数，显示它接受通过 "subType" 继承 "superType" 成员资格的 product 类型：

Wolfram Language code:

cf = FunctionCompile[{superDec, subDec, prodDec, funcDec}, 
	Function[{}, With[{
	obj = CreateTypeInstance["abstractInstance", <|"field1" -> 12, "field2" -> False|>]}, 
	abstractEater[obj]]
	]]

Wolfram Language code: cf[]

"Creator" (1)

表示有自己的创建函数的类型：

Wolfram Language code: typeDec = TypeDeclaration["Product", "TestType", <|"value" -> "MachineInteger"|>, "Creator" -> CreateTestType];

表示创建函数的实现：

Wolfram Language code:

createDec = FunctionDeclaration[CreateTestType, 
	Typed[{} -> "TestType"]@
	Function[{}, CreateTypeInstance["TestType", <|"value" -> 10|>]]];

编译一个使用 CreateTypeInstance 的函数，并调用 "Creator" 函数：

Wolfram Language code:

cf = FunctionCompile[{absDec, prodDec, funcDec}, 
	Function[{}, With[{
	obj = CreateTypeInstance["abstractInstance", <|"field1" -> 12, "field2" -> False|>]}, 
	abstractEater[obj]]
	]]

与预期相符，结果为 10：

Wolfram Language code: cf[]

"MemoryManaged" (3)

表示没有自动内存管理的类型：

Wolfram Language code: unmanaged = TypeDeclaration["Product", "unmanagedType", <|"field" -> "MachineInteger"|>, "MemoryManaged" -> False];

编译一个使用该类型的函数：

Wolfram Language code:

cf = FunctionCompile[{superDec, subDec, prodDec, funcDec}, 
	Function[{}, With[{
	obj = CreateTypeInstance["abstractInstance", <|"field1" -> 12, "field2" -> False|>]}, 
	abstractEater[obj]]
	]]

所得函数泄漏内存，因为对象没有被自动释放：

Wolfram Language code:

With[{before = MemoryInUse[]}, 
	Do[cf[], 1000];
	MemoryInUse[] - before]

默认情况下，product 类型是自动被内存管理的：

Wolfram Language code: managed = TypeDeclaration["Product", "managedType", <|"field" -> "MachineInteger"|>];

Wolfram Language code:

cf = FunctionCompile[{typeDec, createDec}, Function[{}, 
	With[{obj = CreateTypeInstance["TestType"]}, 
	obj["value"]
	]
	]]

使用内存管理类型的函数不会泄漏内存：

Wolfram Language code:

With[{before = MemoryInUse[]}, 
	Do[cf2[], 1000];
	MemoryInUse[] - before]

表示没有自动内存管理的类型：

Wolfram Language code: unmanaged = TypeDeclaration["Product", "unmanagedType", <|"field" -> "MachineInteger"|>, "MemoryManaged" -> False];

编译一个使用该类型的函数并用，并用 DeleteObject 释放它：

Wolfram Language code:

cf = FunctionCompile[unmanaged, Function[{}, 
	Module[{obj, out}, 
	obj = obj = CreateTypeInstance["unmanagedType", <|"field" -> 12|>];
	out = obj["field"];
	DeleteObject[obj];
	out
	]
	]]

所得函数不会泄漏内存，因为它是被手动释放的：

Wolfram Language code:

With[{before = MemoryInUse[]}, 
	Do[cf[], 1000];
	MemoryInUse[] - before]

由内存管理的 product 类型包括引用计数，并且与外部程序不兼容. 将 product 型传进和传出库函数时，应禁用内存管理.

编译一个定义结构体 foo 的库：

Wolfram Language code:

Needs["CCompilerDriver`"];
CreateLibrary["
#include \"dllexport.h\"
typedef struct {
	int f1;
	float f2;
} foo;

DLLEXPORT int getIntFieldRef(foo* arg) {
	return arg->f1;
}", "memoryManagementExample"];

用 TypeDeclaration 表示兼容类型：

Wolfram Language code: fooTypeDec = TypeDeclaration["Product", "foo", <|"f1" -> "CInt", "f2" -> "CFloat"|>, "MemoryManaged" -> False];

注意已编译类型 "foo" 默认是引用类型，相当于 C 中的 foo*.

编译一个使用该类型调用库的函数：

Wolfram Language code:

cf = FunctionCompile[{
	fooTypeDec, LibraryFunctionDeclaration["getIntFieldRef", "memoryManagementExample", {"foo"} -> "CInt"]
	}, 
	Function[{}, 
	With[{foo = CreateTypeInstance["foo", <|"f1" -> Typed[42, "CInt"], "f2" -> Typed[3.1, "CFloat"]|>]}, 
	LibraryFunction["getIntFieldRef"][foo]
	]
	]
	]

Wolfram Language code: cf[]

"Operations" (3)

声明一种 product 类型，并给出一种运算：

Wolfram Language code:

dec1 = TypeDeclaration["Product", "simpleValue", <|"value" -> "MachineInteger"|>, "Operations" -> {"Increment"}, "AbstractTypes"  -> {"DataStructures"}];

运算声明：

Wolfram Language code:

dec2 = OperationDeclaration["simpleValue", "Increment", Typed[{"simpleValue"} -> "MachineInteger"]@Function[{arg}, 
	  arg["value"]++
	]];

编译一个函数，创建该类型的实例及另一实例，调用 "Increment" 运算：

Wolfram Language code:

funs = FunctionCompile[{dec1, dec2}, <|"create" -> Function[{}, CreateTypeInstance["simpleValue", <|"value" -> 0|>]], 
	"increment" -> Function[{Typed[ arg, "simpleValue"]}, arg["Increment"]]
	|>]

创建实例：

Wolfram Language code: obj = funs["create"][];

调用 "Increment" 运算；返回旧值 0：

Wolfram Language code: funs["increment"][obj]

再次调用 "Increment" 运算；现在，旧值为 1：

Wolfram Language code: funs["increment"][obj]

也可以为抽象类型定义运算. 在这种情况下，它们可用于实现抽象类型的任何类型：

表示一个抽象类型：

Wolfram Language code: absDec = TypeDeclaration["Abstract", "incrementer", "Operations" -> {"Increment"}];

表示一个实现该抽象类型的对象：

Wolfram Language code:

prodDec = TypeDeclaration["Product", "testType", <|"value" -> "MachineInteger"|>, "AbstractTypes" -> {"incrementer", "DataStructures"}];

运算声明：

Wolfram Language code:

decOp = OperationDeclaration["testType", "Increment", Typed[ {"testType"} -> "MachineInteger"]@Function[{arg}, 
	  arg["value"]++
	]];

编译一个函数，创建该类型的实例及另一实例，调用 "Increment" 运算：

Wolfram Language code:

funs = FunctionCompile[{absDec, prodDec, decOp}, <|"create" -> Function[{}, CreateTypeInstance["testType", <|"value" -> 0|>]], 
	"increment" -> Function[{Typed[ arg, "testType"]}, arg["Increment"]]
	|>]

创建实例：

Wolfram Language code: obj = funs["create"][];

调用 "Increment" 运算；返回旧值 0：

Wolfram Language code: funs["increment"][obj]

再次调用 "Increment" 运算；现在，旧值为 1：

Wolfram Language code: funs["increment"][obj]

为抽象类型定义的运算可引用实际的实现：

表示一个抽象类型：

Wolfram Language code: absDec = TypeDeclaration["Abstract", "incrementer", "Operations" -> {"Increment" -> increment}];

运算声明；它是用 ForAllType 多态编写的：

Wolfram Language code:

decOp = FunctionDeclaration[increment, 
	Typed[ForAllType[v, {v} -> "MachineInteger"]]@Function[{arg}, 
	  arg["value"]++
	]];

表示一个抽象类型的对象：

Wolfram Language code:

prodDec = TypeDeclaration["Product", "testType", <|"value" -> "MachineInteger"|>, "AbstractTypes" -> {"incrementer", "DataStructures"}];

编译一个函数，创建该类型的实例及另一实例，调用 "Increment" 运算：

Wolfram Language code:

funs = FunctionCompile[{absDec, prodDec, decOp}, <|"create" -> Function[{}, CreateTypeInstance["testType", <|"value" -> 0|>]], 
	"increment" -> Function[{Typed[ arg, "testType"]}, arg["Increment"]]
	|>]

创建实例：

Wolfram Language code: obj = funs["create"][];

调用 "Increment" 运算；返回旧值 0：

Wolfram Language code: funs["increment"][obj]

再次调用 "Increment" 运算；现在，旧值为 1：

Wolfram Language code: funs["increment"][obj]

运算的实现完全由抽象类型设置.

也可以用其他方式实现运算. 由于它是用实际类型以更窄的方式声明的，因此它会覆盖抽象类型给出的实现：

Wolfram Language code:

decOp1 = OperationDeclaration["testType", "Increment", Typed[{"testType"} -> "MachineInteger"]@Function[{arg}, 
	  arg["value"] += 2
	]];

编译一个函数，创建该类型的实例及另一实例，调用 "Increment" 运算：

Wolfram Language code:

funs = FunctionCompile[{absDec, prodDec, decOp, decOp1}, <|"create" -> Function[{}, CreateTypeInstance["testType", <|"value" -> 0|>]], 
	"increment" -> Function[{Typed[ arg, "testType"]}, arg["Increment"]]
	|>]

创建实例：

Wolfram Language code: obj = funs["create"][];

现在，"Increment" 运算给出不同的结果：

Wolfram Language code: funs["increment"][obj]

"ReferenceSemantics" (2)

表示将通过值而不是通过引用传递的类型：

Wolfram Language code: valueTypeDec = TypeDeclaration["Product", "valueType", <|"field" -> "MachineInteger"|>, "ReferenceSemantics" -> False];

编译使用值类型的函数：

Wolfram Language code:

cf = FunctionCompile[valueTypeDec, Function[{}, 
	With[{obj = CreateTypeInstance["valueType", <|"field" -> 12|>]}, 
	obj["field"]
	]
	]]

Wolfram Language code: cf[]

编译一个定义结构体 foo 的库：

Wolfram Language code:

Needs["CCompilerDriver`"];
CreateLibrary["
#include \"dllexport.h\"
typedef struct {
	int f1;
	float f2;
} foo;

DLLEXPORT int getIntField(foo arg) {
	return arg.f1;
}", "valueTypeExample"];

用 TypeDeclaration 表示兼容类型：

Wolfram Language code: fooTypeDec = TypeDeclaration["Product", "foo", <|"f1" -> "CInt", "f2" -> "CFloat"|>, "ReferenceSemantics" -> False];

编译使用该类型的函数：

Wolfram Language code:

cf = FunctionCompile[{
	fooTypeDec, LibraryFunctionDeclaration["getIntField", "valueTypeExample", {"foo"} -> "CInt"]
	}, 
	Function[{}, 
	With[{foo = CreateTypeInstance["foo", <|"f1" -> Typed[42, "CInt"], "f2" -> Typed[3.1, "CFloat"]|>]}, 
	LibraryFunction["getIntField"][foo]
	]
	]
	]

Wolfram Language code: cf[]

应用 (1)

C 标准库包含一个名为 ldiv 的函数，用于计算两个整数的商和余数. 它返回一个声明为以下内容的对象：

typedef struct {
    long quot;        /* quotient */
    long rem;         /* remainder */
} ldiv_t;

表示 ldiv_t 类型的声明：

Wolfram Language code: divtDec = TypeDeclaration["Product", "CLDivT", <|"quot" -> "CLong", "rem" -> "CLong"|>, "ReferenceSemantics" -> False];

表示 ldiv 函数的声明：

Wolfram Language code: funcDec = LibraryFunctionDeclaration["ldiv", Automatic, {"CLong", "CLong"} -> "CLDivT"];

编译一个从 C 标准库调用该函数的程序：

Wolfram Language code:

quotRem = FunctionCompile[{divtDec, funcDec}, 
	Function[{Typed[n, "CLong"], Typed[d, "CLong"]}, 
	With[{divt = LibraryFunction["ldiv"][n, d]}, 
	{divt["quot"], divt["rem"]}]
	]
	]

Wolfram Language code: quotRem[7, 2]

可能存在的问题 (1)

宏不是类型，而是在解析时应用于类型的替换规则. 因此，一个宏和它所指代的类型不可能对同一个函数有不同的定义：

Wolfram Language code: dec = TypeDeclaration["Macro", "macroString", "String"];

Wolfram Language code:

funcDec = FunctionDeclaration[StringLength, Typed[{"macroString"} -> "MachineInteger"]@
	Function[arg, 12]
	];

Wolfram Language code:

FunctionCompile[{dec, funcDec}, 
	Function[Typed[arg, "macroString"], StringLength[arg]]]

与宏不同，别名是类型，因此函数可以识别它们是应用于类型还是该类型的别名.

Top

	TypeDeclaration["Product", "myStruct", <\|"f1"->"CInt","f2"->"CDouble"\|>, "ReferenceSemantics"->False]	struct myStruct {int f1; double f2;};
	TypeDeclaration["Macro","myInteger","CInt"]	typedef int myInteger;

	prod["field"]	获取 "field" 的值
	prod["field"]=val	设置 "field" 的值
	DeleteObject[prod]	释放 prod （只在 prod 不是内存管理的情况下可用）

更多学习资源

技术支持

数据科学、金融与商业

工程

科学与技术

教育科技

教育举措

开始

提高你的技能

与我们合作

成人教育计划

青少年教育计划

欢迎阅读

TypeDeclaration

更多信息和选项

范例

基本范例 (2)

范围 (6)

"Product" (2)

"Abstract" (1)

"Alias" (1)

"Macro" (2)

选项 (11)

"AbstractTypes" (2)

"Creator" (1)

"MemoryManaged" (3)

"Operations" (3)

"ReferenceSemantics" (2)

应用 (1)

可能存在的问题 (1)

文本

CMS

APA

BibTeX

BibLaTeX

	"Product"	含有几个字段的类型；类似于 C 中的结构体 (struct)
	"Abstract"	具体类型可以是某个类型的类别 (class) 的实例的抽象类型
	"Alias"	内部实现与另一种类型相同的类型
	"Macro"	适用于所有类型的替换规则

"AbstractTypes"	{}	含有所声明类型的抽象类型
"Creator"	None	调用以创建声明类型的实例的函数
"MemoryManaged"	Automatic	是否自动释放未引用的实例
"Operations"	{}	可用于所声明类型的运算
"ReferenceSemantics"	Automatic	是否在内部用指针表示类型

TypeDeclaration

更多信息和选项

范例

基本范例 (2)

范围 (6)

"Product" (2)

"Abstract" (1)

"Alias" (1)

"Macro" (2)

选项 (11)

"AbstractTypes" (2)

"Creator" (1)

"MemoryManaged" (3)

"Operations" (3)

"ReferenceSemantics" (2)

应用 (1)

可能存在的问题 (1)

参见

技术笔记

相关指南

历史

文本

CMS

APA

BibTeX

BibLaTeX