Wolfram言語＆システムドキュメントセンター

TypeDeclaration

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

指定の分野における製品型の宣言を表す．

TypeDeclaration["Abstract",name]

抽象的な型 name の宣言を表す．

TypeDeclaration["Alias",name,targetType]

targetType の内部表現を使った型 name の宣言を表す．

TypeDeclaration["Macro",name,targetType]

name のすべてのインスタンスを targetType で置換するように指定する宣言を表す．

TypeDeclaration

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

指定の分野における製品型の宣言を表す．

TypeDeclaration["Abstract",name]

抽象的な型 name の宣言を表す．

TypeDeclaration["Alias",name,targetType]

targetType の内部表現を使った型 name の宣言を表す．

TypeDeclaration["Macro",name,targetType]

name のすべてのインスタンスを targetType で置換するように指定する宣言を表す．

詳細とオプション

TypeDeclarationは宣言の記号表現で，そのままでは評価されない．
TypeDeclarationは，CompilerEnvironmentAppendToの中で，およびFunctionCompile等の関数の第1引数として使うことができる．
次の種類の宣言がサポートされている．

	"Product"	いくつかのフィールドを含む型．Cの構造体に似ている
	"Abstract"	具体的な型がそのインスタンスであり得る抽象型．型のクラス
	"Alias"	別の型と同じ内部実装を使う型
	"Macro"	すべての型に適用される置換規則

C互換プログラムとインターフェースで接続する場合，次の型宣言は同等である：

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

製品型インスタンス prod のフィールドには prod["field"]でアクセスし，設定できる．
次は，サポートされるオプションである．

"AbstractTypes"	{}	宣言された型を含む抽象型
"Creator"	None	宣言された型のインターフェースの作成のために呼び出す関数
"MemoryManaged"	Automatic	参照されていないインスタンスを自動的に解放するかどうか
"Operations"	{}	宣言された型が使用可能な操作
"ReferenceSemantics"	Automatic	ポインタがある型を内部的に表すかどうか

デフォルトで，"Product"の宣言は"MemoryManaged"Trueおよび"ReferenceSemantics"Trueを含む．
"ReferenceSemantics"は"Product"宣言についてはTrueにしか設定できない．
"MemoryManaged"はReference Semanticsを使う"Product"宣言についてはTrueにしか設定できない．
"Creator"は，"Product"宣言についてしか設定できない．
"Operations"は，"Product"および"Abstract"の宣言についてしか設定できない．
"AbstractTypes"は"Macro"宣言については設定できない．
Cの構造との互換性については，一般に，製品型を"MemoryManaged"に，"ReferenceSemantics"をFalseに設定しなければならない．
製品型のインスタンスであるオブジェクト prod については以下のメソッドが定義されている．

	prod["field"]	"field"の値を得る
	prod["field"]=val	"field"の値を設定する
	DeleteObject[prod]	free prod を解放する（prod がメモリ管理されていない場合のみ）

例題

すべて開くすべて閉じる

例 (2)

"MachineInteger"のマクロ型としての"fooInteger"の宣言を表す：

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)

製品型の宣言：

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

製品型をインスタンス化してフィールドを抽出する関数をコンパイルする：

Wolfram Language code:

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

Wolfram Language code: cf[]

多様な製品型の宣言：

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

機械整数を取り，これを使って上記の製品型を作る関数をコンパイルする：

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"];

抽象型のインスタンスである製品型の宣言：

Wolfram Language code:

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

抽象型のインスタンスではない製品型の宣言：

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]
	];

ビットキャスティングを介してエイリアスをインスタンス化するプログラムをコンパイルし，それについて関数を評価する：

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]];

抽象型に属する製品型を取ることを示して関数をコンパイルする：

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"}];

2番目の抽象型のインスタンスである製品型を表す：

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"への所属を継承する製品型を取ることを示して関数をコンパイルする：

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[{typeDec, createDec}, Function[{}, 
	With[{obj = CreateTypeInstance["TestType"]}, 
	obj["value"]
	]
	]]

予想される通り，結果は10である：

Wolfram Language code: cf[]

"MemoryManaged" (3)

自動メモリ管理がない型を表す：

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

この型を使う関数をコンパイルする：

Wolfram Language code:

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

オブジェクトが自動的に解放されないので，結果の関数にはメモリリークがある：

Wolfram Language code:

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

デフォルトで，製品型のメモリは自動的に管理される：

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

Wolfram Language code:

cf2 = FunctionCompile[managed, Function[{}, 
	With[{obj = CreateTypeInstance["managedType", <|"field" -> 12|>]}, 
	obj["field"]
	]
	]]

メモリ管理型を使う関数にはメモリリークはない：

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]

メモリ管理の製品型には参照数が含まれ，外部プログラムと互換ではない．製品型をライブラリ関数に渡したりライブラリ関数から製品型を受け取ったりする際は，メモリ管理は無効にすべきである．

構造体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)

一つの操作による製品型の宣言：

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"操作を呼び出す．古い値の1が返される：

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の標準ライブラリには2つの整数の商と余りを計算する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

その他のラーニングリソース

テクニカルサポート

データサイエンス，金融，ビジネス

工学

科学とテクノロジー

教育のためのテクノロジー

教育イニシアチブ

使い始める

Grow Your Skills

Wolframと繋がる

大人用の教育プログラム

若者のための教育プログラム

読む

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

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