Global

// .NET, .NET Standard 2.0
class method AssertableTo(V: Memory<Interface>; T: Type): bool
// Island
class method AssertableTo(V: Memory<Interface>; T: Type): bool

// .NET, .NET Standard 2.0
static bool AssertableTo(Memory<Interface> V, Type T)
// Island
static bool AssertableTo(Memory<Interface> V, Type T)

// .NET, .NET Standard 2.0
static func AssertableTo(_ V: Memory<Interface>, _ T: Type) -> bool
// Island
static func AssertableTo(_ V: Memory<Interface>, _ T: Type) -> bool

// .NET, .NET Standard 2.0
func AssertableTo(V Memory<Interface>, T Type) bool
// Island
func AssertableTo(V Memory<Interface>, T Type) bool

// .NET, .NET Standard 2.0
Shared Function AssertableTo(V As Memory<Interface>, T As Type) As bool
// Island
Shared Function AssertableTo(V As Memory<Interface>, T As Type) As bool

class method AssignableTo(V: Type; T: Type): bool

static bool AssignableTo(Type V, Type T)

static func AssignableTo(_ V: Type, _ T: Type) -> bool

func AssignableTo(V Type, T Type) bool

Shared Function AssignableTo(V As Type, T As Type) As bool

const Bool: BasicKind = 1;

const BasicKind Bool = 1

static let Bool: BasicKind = 1

const Bool BasicKind = 1

Dim Bool As BasicKind = 1

const Byte: BasicKind = 8;

const BasicKind Byte = 8

static let Byte: BasicKind = 8

const Byte BasicKind = 8

Dim Byte As BasicKind = 8

// .NET, .NET Standard 2.0
class method CheckExpr(fset: Memory<FileSet>; pkg: Memory<Package>; pos: Pos; expr: Expr; info: Memory<Info>): error
// Island
class method CheckExpr(fset: Memory<FileSet>; pkg: Memory<Package>; pos: Pos; expr: Expr; info: Memory<Info>): error

// .NET, .NET Standard 2.0
static error CheckExpr(Memory<FileSet> fset, Memory<Package> pkg, Pos pos, Expr expr, Memory<Info> info)
// Island
static error CheckExpr(Memory<FileSet> fset, Memory<Package> pkg, Pos pos, Expr expr, Memory<Info> info)

// .NET, .NET Standard 2.0
static func CheckExpr(_ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ pos: Pos, _ expr: Expr, _ info: Memory<Info>) -> error
// Island
static func CheckExpr(_ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ pos: Pos, _ expr: Expr, _ info: Memory<Info>) -> error

// .NET, .NET Standard 2.0
func CheckExpr(fset Memory<FileSet>, pkg Memory<Package>, pos Pos, expr Expr, info Memory<Info>) error
// Island
func CheckExpr(fset Memory<FileSet>, pkg Memory<Package>, pos Pos, expr Expr, info Memory<Info>) error

// .NET, .NET Standard 2.0
Shared Function CheckExpr(fset As Memory<FileSet>, pkg As Memory<Package>, pos As Pos, expr As Expr, info As Memory<Info>) As error
// Island
Shared Function CheckExpr(fset As Memory<FileSet>, pkg As Memory<Package>, pos As Pos, expr As Expr, info As Memory<Info>) As error

class method Comparable(T: Type): bool

static bool Comparable(Type T)

static func Comparable(_ T: Type) -> bool

func Comparable(T Type) bool

Shared Function Comparable(T As Type) As bool

const Complex128: BasicKind = 16;

const BasicKind Complex128 = 16

static let Complex128: BasicKind = 16

const Complex128 BasicKind = 16

Dim Complex128 As BasicKind = 16

const Complex64: BasicKind = 15;

const BasicKind Complex64 = 15

static let Complex64: BasicKind = 15

const Complex64 BasicKind = 15

Dim Complex64 As BasicKind = 15

class method ConvertibleTo(V: Type; T: Type): bool

static bool ConvertibleTo(Type V, Type T)

static func ConvertibleTo(_ V: Type, _ T: Type) -> bool

func ConvertibleTo(V Type, T Type) bool

Shared Function ConvertibleTo(V As Type, T As Type) As bool

class method Default(typ: Type): Type

static Type Default(Type typ)

static func Default(_ typ: Type) -> Type

func Default(typ Type) Type

Shared Function Default(typ As Type) As Type

class method DefPredeclaredTestFuncs

static void DefPredeclaredTestFuncs()

static func DefPredeclaredTestFuncs()

// .NET, .NET Standard 2.0
func DefPredeclaredTestFuncs() 
// Island
func DefPredeclaredTestFuncs() void

Shared Sub DefPredeclaredTestFuncs()

// .NET, .NET Standard 2.0
class method Eval(fset: Memory<FileSet>; pkg: Memory<Package>; pos: Pos; expr: string): tuple of (: TypeAndValue, err: error)
// Island
class method Eval(fset: Memory<FileSet>; pkg: Memory<Package>; pos: Pos; expr: string): tuple of (: TypeAndValue, err: error)

// .NET, .NET Standard 2.0
static (TypeAndValue _, error err) Eval(Memory<FileSet> fset, Memory<Package> pkg, Pos pos, string expr)
// Island
static (TypeAndValue _, error err) Eval(Memory<FileSet> fset, Memory<Package> pkg, Pos pos, string expr)

// .NET, .NET Standard 2.0
static func Eval(_ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ pos: Pos, _ expr: string) -> (TypeAndValue, error)
// Island
static func Eval(_ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ pos: Pos, _ expr: string) -> (TypeAndValue, error)

// .NET, .NET Standard 2.0
func Eval(fset Memory<FileSet>, pkg Memory<Package>, pos Pos, expr string) tuple of (|name=| TypeAndValue, |name=err| error)
// Island
func Eval(fset Memory<FileSet>, pkg Memory<Package>, pos Pos, expr string) tuple of (|name=| TypeAndValue, |name=err| error)

// .NET, .NET Standard 2.0
Shared Function Eval(fset As Memory<FileSet>, pkg As Memory<Package>, pos As Pos, expr As string) As Tuple (Of TypeAndValue, error)
// Island
Shared Function Eval(fset As Memory<FileSet>, pkg As Memory<Package>, pos As Pos, expr As string) As Tuple (Of TypeAndValue, error)

class method ExprString(x: Expr): string

static string ExprString(Expr x)

static func ExprString(_ x: Expr) -> string

func ExprString(x Expr) string

Shared Function ExprString(x As Expr) As string

const FieldVal: SelectionKind = 0;

const SelectionKind FieldVal = 0

static let FieldVal: SelectionKind = 0

const FieldVal SelectionKind = 0

Dim FieldVal As SelectionKind = 0

const Float32: BasicKind = 13;

const BasicKind Float32 = 13

static let Float32: BasicKind = 13

const Float32 BasicKind = 13

Dim Float32 As BasicKind = 13

const Float64: BasicKind = 14;

const BasicKind Float64 = 14

static let Float64: BasicKind = 14

const Float64 BasicKind = 14

Dim Float64 As BasicKind = 14

// .NET, .NET Standard 2.0
class method Id(pkg: Memory<Package>; name: string): string
// Island
class method Id(pkg: Memory<Package>; name: string): string

// .NET, .NET Standard 2.0
static string Id(Memory<Package> pkg, string name)
// Island
static string Id(Memory<Package> pkg, string name)

// .NET, .NET Standard 2.0
static func Id(_ pkg: Memory<Package>, _ name: string) -> string
// Island
static func Id(_ pkg: Memory<Package>, _ name: string) -> string

// .NET, .NET Standard 2.0
func Id(pkg Memory<Package>, name string) string
// Island
func Id(pkg Memory<Package>, name string) string

// .NET, .NET Standard 2.0
Shared Function Id(pkg As Memory<Package>, name As string) As string
// Island
Shared Function Id(pkg As Memory<Package>, name As string) As string

class method Identical(x: Type; y: Type): bool

static bool Identical(Type x, Type y)

static func Identical(_ x: Type, _ y: Type) -> bool

func Identical(x Type, y Type) bool

Shared Function Identical(x As Type, y As Type) As bool

class method IdenticalIgnoreTags(x: Type; y: Type): bool

static bool IdenticalIgnoreTags(Type x, Type y)

static func IdenticalIgnoreTags(_ x: Type, _ y: Type) -> bool

func IdenticalIgnoreTags(x Type, y Type) bool

Shared Function IdenticalIgnoreTags(x As Type, y As Type) As bool

// .NET, .NET Standard 2.0
class method Implements(V: Type; T: Memory<Interface>): bool
// Island
class method Implements(V: Type; T: Memory<Interface>): bool

// .NET, .NET Standard 2.0
static bool Implements(Type V, Memory<Interface> T)
// Island
static bool Implements(Type V, Memory<Interface> T)

// .NET, .NET Standard 2.0
static func Implements(_ V: Type, _ T: Memory<Interface>) -> bool
// Island
static func Implements(_ V: Type, _ T: Memory<Interface>) -> bool

// .NET, .NET Standard 2.0
func Implements(V Type, T Memory<Interface>) bool
// Island
func Implements(V Type, T Memory<Interface>) bool

// .NET, .NET Standard 2.0
Shared Function Implements(V As Type, T As Memory<Interface>) As bool
// Island
Shared Function Implements(V As Type, T As Memory<Interface>) As bool

const Int: BasicKind = 2;

const BasicKind Int = 2

static let Int: BasicKind = 2

const Int BasicKind = 2

Dim Int As BasicKind = 2

const Int16: BasicKind = 4;

const BasicKind Int16 = 4

static let Int16: BasicKind = 4

const Int16 BasicKind = 4

Dim Int16 As BasicKind = 4

const Int32: BasicKind = 5;

const BasicKind Int32 = 5

static let Int32: BasicKind = 5

const Int32 BasicKind = 5

Dim Int32 As BasicKind = 5

const Int64: BasicKind = 6;

const BasicKind Int64 = 6

static let Int64: BasicKind = 6

const Int64 BasicKind = 6

Dim Int64 As BasicKind = 6

const Int8: BasicKind = 3;

const BasicKind Int8 = 3

static let Int8: BasicKind = 3

const Int8 BasicKind = 3

Dim Int8 As BasicKind = 3

const Invalid: BasicKind = 0;

const BasicKind Invalid = 0

static let Invalid: BasicKind = 0

const Invalid BasicKind = 0

Dim Invalid As BasicKind = 0

const IsBoolean: BasicInfo = 1;

const BasicInfo IsBoolean = 1

static let IsBoolean: BasicInfo = 1

const IsBoolean BasicInfo = 1

Dim IsBoolean As BasicInfo = 1

const IsComplex: BasicInfo = 16;

const BasicInfo IsComplex = 16

static let IsComplex: BasicInfo = 16

const IsComplex BasicInfo = 16

Dim IsComplex As BasicInfo = 16

const IsConstType: BasicInfo = 59;

const BasicInfo IsConstType = 59

static let IsConstType: BasicInfo = 59

const IsConstType BasicInfo = 59

Dim IsConstType As BasicInfo = 59

const IsFloat: BasicInfo = 8;

const BasicInfo IsFloat = 8

static let IsFloat: BasicInfo = 8

const IsFloat BasicInfo = 8

Dim IsFloat As BasicInfo = 8

const IsInteger: BasicInfo = 2;

const BasicInfo IsInteger = 2

static let IsInteger: BasicInfo = 2

const IsInteger BasicInfo = 2

Dim IsInteger As BasicInfo = 2

class method IsInterface(typ: Type): bool

static bool IsInterface(Type typ)

static func IsInterface(_ typ: Type) -> bool

func IsInterface(typ Type) bool

Shared Function IsInterface(typ As Type) As bool

const IsNumeric: BasicInfo = 26;

const BasicInfo IsNumeric = 26

static let IsNumeric: BasicInfo = 26

const IsNumeric BasicInfo = 26

Dim IsNumeric As BasicInfo = 26

const IsOrdered: BasicInfo = 42;

const BasicInfo IsOrdered = 42

static let IsOrdered: BasicInfo = 42

const IsOrdered BasicInfo = 42

Dim IsOrdered As BasicInfo = 42

const IsString: BasicInfo = 32;

const BasicInfo IsString = 32

static let IsString: BasicInfo = 32

const IsString BasicInfo = 32

Dim IsString As BasicInfo = 32

const IsUnsigned: BasicInfo = 4;

const BasicInfo IsUnsigned = 4

static let IsUnsigned: BasicInfo = 4

const IsUnsigned BasicInfo = 4

Dim IsUnsigned As BasicInfo = 4

const IsUntyped: BasicInfo = 64;

const BasicInfo IsUntyped = 64

static let IsUntyped: BasicInfo = 64

const IsUntyped BasicInfo = 64

Dim IsUntyped As BasicInfo = 64

// .NET, .NET Standard 2.0
class method LookupFieldOrMethod(T: Type; addressable: bool; pkg: Memory<Package>; name: string): tuple of (obj: Object, index: Slice<Int64>, indirect: Boolean)
// Island
class method LookupFieldOrMethod(T: Type; addressable: bool; pkg: Memory<Package>; name: string): tuple of (obj: Object, index: Slice<Int64>, indirect: Boolean)

// .NET, .NET Standard 2.0
static (Object obj, Slice<Int64>index, Boolean indirect) LookupFieldOrMethod(Type T, bool addressable, Memory<Package> pkg, string name)
// Island
static (Object obj, Slice<Int64>index, Boolean indirect) LookupFieldOrMethod(Type T, bool addressable, Memory<Package> pkg, string name)

// .NET, .NET Standard 2.0
static func LookupFieldOrMethod(_ T: Type, _ addressable: bool, _ pkg: Memory<Package>, _ name: string) -> (Object, Slice<Int64>, Boolean)
// Island
static func LookupFieldOrMethod(_ T: Type, _ addressable: bool, _ pkg: Memory<Package>, _ name: string) -> (Object, Slice<Int64>, Boolean)

// .NET, .NET Standard 2.0
func LookupFieldOrMethod(T Type, addressable bool, pkg Memory<Package>, name string) tuple of (|name=obj| Object, |name=index| Slice<Int64>, |name=indirect| Boolean)
// Island
func LookupFieldOrMethod(T Type, addressable bool, pkg Memory<Package>, name string) tuple of (|name=obj| Object, |name=index| Slice<Int64>, |name=indirect| Boolean)

// .NET, .NET Standard 2.0
Shared Function LookupFieldOrMethod(T As Type, addressable As bool, pkg As Memory<Package>, name As string) As Tuple (Of Object, Slice<Int64>, Boolean)
// Island
Shared Function LookupFieldOrMethod(T As Type, addressable As bool, pkg As Memory<Package>, name As string) As Tuple (Of Object, Slice<Int64>, Boolean)

const MethodExpr: SelectionKind = 2;

const SelectionKind MethodExpr = 2

static let MethodExpr: SelectionKind = 2

const MethodExpr SelectionKind = 2

Dim MethodExpr As SelectionKind = 2

const MethodVal: SelectionKind = 1;

const SelectionKind MethodVal = 1

static let MethodVal: SelectionKind = 1

const MethodVal SelectionKind = 1

Dim MethodVal As SelectionKind = 1

// .NET, .NET Standard 2.0
class method MissingMethod(V: Type; T: Memory<Interface>; static: bool): tuple of (method: Memory<Func>, wrongType: Boolean)
// Island
class method MissingMethod(V: Type; T: Memory<Interface>; static: bool): tuple of (method: Memory<Func>, wrongType: Boolean)

// .NET, .NET Standard 2.0
static (Memory<Func>method, Boolean wrongType) MissingMethod(Type V, Memory<Interface> T, bool static)
// Island
static (Memory<Func>method, Boolean wrongType) MissingMethod(Type V, Memory<Interface> T, bool static)

// .NET, .NET Standard 2.0
static func MissingMethod(_ V: Type, _ T: Memory<Interface>, _ static: bool) -> (Memory<Func>, Boolean)
// Island
static func MissingMethod(_ V: Type, _ T: Memory<Interface>, _ static: bool) -> (Memory<Func>, Boolean)

// .NET, .NET Standard 2.0
func MissingMethod(V Type, T Memory<Interface>, static bool) tuple of (|name=method| Memory<Func>, |name=wrongType| Boolean)
// Island
func MissingMethod(V Type, T Memory<Interface>, static bool) tuple of (|name=method| Memory<Func>, |name=wrongType| Boolean)

// .NET, .NET Standard 2.0
Shared Function MissingMethod(V As Type, T As Memory<Interface>, static As bool) As Tuple (Of Memory<Func>, Boolean)
// Island
Shared Function MissingMethod(V As Type, T As Memory<Interface>, static As bool) As Tuple (Of Memory<Func>, Boolean)

// .NET, .NET Standard 2.0
class method NewArray(elem: Type; len: int64): Memory<Array>
// Island
class method NewArray(elem: Type; len: int64): Memory<Array>

// .NET, .NET Standard 2.0
static Memory<Array> NewArray(Type elem, int64 len)
// Island
static Memory<Array> NewArray(Type elem, int64 len)

// .NET, .NET Standard 2.0
static func NewArray(_ elem: Type, _ len: int64) -> Memory<Array>
// Island
static func NewArray(_ elem: Type, _ len: int64) -> Memory<Array>

// .NET, .NET Standard 2.0
func NewArray(elem Type, len int64) Memory<Array>
// Island
func NewArray(elem Type, len int64) Memory<Array>

// .NET, .NET Standard 2.0
Shared Function NewArray(elem As Type, len As int64) As Memory<Array>
// Island
Shared Function NewArray(elem As Type, len As int64) As Memory<Array>

// .NET, .NET Standard 2.0
class method NewChan(dir: ChanDir; elem: Type): Memory<Chan>
// Island
class method NewChan(dir: ChanDir; elem: Type): Memory<Chan>

// .NET, .NET Standard 2.0
static Memory<Chan> NewChan(ChanDir dir, Type elem)
// Island
static Memory<Chan> NewChan(ChanDir dir, Type elem)

// .NET, .NET Standard 2.0
static func NewChan(_ dir: ChanDir, _ elem: Type) -> Memory<Chan>
// Island
static func NewChan(_ dir: ChanDir, _ elem: Type) -> Memory<Chan>

// .NET, .NET Standard 2.0
func NewChan(dir ChanDir, elem Type) Memory<Chan>
// Island
func NewChan(dir ChanDir, elem Type) Memory<Chan>

// .NET, .NET Standard 2.0
Shared Function NewChan(dir As ChanDir, elem As Type) As Memory<Chan>
// Island
Shared Function NewChan(dir As ChanDir, elem As Type) As Memory<Chan>

// .NET, .NET Standard 2.0
class method NewChecker(conf: Memory<Config>; fset: Memory<FileSet>; pkg: Memory<Package>; info: Memory<Info>): Memory<Checker>
// Island
class method NewChecker(conf: Memory<Config>; fset: Memory<FileSet>; pkg: Memory<Package>; info: Memory<Info>): Memory<Checker>

// .NET, .NET Standard 2.0
static Memory<Checker> NewChecker(Memory<Config> conf, Memory<FileSet> fset, Memory<Package> pkg, Memory<Info> info)
// Island
static Memory<Checker> NewChecker(Memory<Config> conf, Memory<FileSet> fset, Memory<Package> pkg, Memory<Info> info)

// .NET, .NET Standard 2.0
static func NewChecker(_ conf: Memory<Config>, _ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ info: Memory<Info>) -> Memory<Checker>
// Island
static func NewChecker(_ conf: Memory<Config>, _ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ info: Memory<Info>) -> Memory<Checker>

// .NET, .NET Standard 2.0
func NewChecker(conf Memory<Config>, fset Memory<FileSet>, pkg Memory<Package>, info Memory<Info>) Memory<Checker>
// Island
func NewChecker(conf Memory<Config>, fset Memory<FileSet>, pkg Memory<Package>, info Memory<Info>) Memory<Checker>

// .NET, .NET Standard 2.0
Shared Function NewChecker(conf As Memory<Config>, fset As Memory<FileSet>, pkg As Memory<Package>, info As Memory<Info>) As Memory<Checker>
// Island
Shared Function NewChecker(conf As Memory<Config>, fset As Memory<FileSet>, pkg As Memory<Package>, info As Memory<Info>) As Memory<Checker>

// .NET, .NET Standard 2.0
class method NewConst(pos: Pos; pkg: Memory<Package>; name: string; typ: Type; val: Value): Memory<Const>
// Island
class method NewConst(pos: Pos; pkg: Memory<Package>; name: string; typ: Type; val: Value): Memory<Const>

// .NET, .NET Standard 2.0
static Memory<Const> NewConst(Pos pos, Memory<Package> pkg, string name, Type typ, Value val)
// Island
static Memory<Const> NewConst(Pos pos, Memory<Package> pkg, string name, Type typ, Value val)

// .NET, .NET Standard 2.0
static func NewConst(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type, _ val: Value) -> Memory<Const>
// Island
static func NewConst(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type, _ val: Value) -> Memory<Const>

// .NET, .NET Standard 2.0
func NewConst(pos Pos, pkg Memory<Package>, name string, typ Type, val Value) Memory<Const>
// Island
func NewConst(pos Pos, pkg Memory<Package>, name string, typ Type, val Value) Memory<Const>

// .NET, .NET Standard 2.0
Shared Function NewConst(pos As Pos, pkg As Memory<Package>, name As string, typ As Type, val As Value) As Memory<Const>
// Island
Shared Function NewConst(pos As Pos, pkg As Memory<Package>, name As string, typ As Type, val As Value) As Memory<Const>

// .NET, .NET Standard 2.0
class method NewField(pos: Pos; pkg: Memory<Package>; name: string; typ: Type; embedded: bool): Memory<Var>
// Island
class method NewField(pos: Pos; pkg: Memory<Package>; name: string; typ: Type; embedded: bool): Memory<Var>

// .NET, .NET Standard 2.0
static Memory<Var> NewField(Pos pos, Memory<Package> pkg, string name, Type typ, bool embedded)
// Island
static Memory<Var> NewField(Pos pos, Memory<Package> pkg, string name, Type typ, bool embedded)

// .NET, .NET Standard 2.0
static func NewField(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type, _ embedded: bool) -> Memory<Var>
// Island
static func NewField(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type, _ embedded: bool) -> Memory<Var>

// .NET, .NET Standard 2.0
func NewField(pos Pos, pkg Memory<Package>, name string, typ Type, embedded bool) Memory<Var>
// Island
func NewField(pos Pos, pkg Memory<Package>, name string, typ Type, embedded bool) Memory<Var>

// .NET, .NET Standard 2.0
Shared Function NewField(pos As Pos, pkg As Memory<Package>, name As string, typ As Type, embedded As bool) As Memory<Var>
// Island
Shared Function NewField(pos As Pos, pkg As Memory<Package>, name As string, typ As Type, embedded As bool) As Memory<Var>

// .NET, .NET Standard 2.0
class method NewFunc(pos: Pos; pkg: Memory<Package>; name: string; sig: Memory<Signature>): Memory<Func>
// Island
class method NewFunc(pos: Pos; pkg: Memory<Package>; name: string; sig: Memory<Signature>): Memory<Func>

// .NET, .NET Standard 2.0
static Memory<Func> NewFunc(Pos pos, Memory<Package> pkg, string name, Memory<Signature> sig)
// Island
static Memory<Func> NewFunc(Pos pos, Memory<Package> pkg, string name, Memory<Signature> sig)

// .NET, .NET Standard 2.0
static func NewFunc(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ sig: Memory<Signature>) -> Memory<Func>
// Island
static func NewFunc(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ sig: Memory<Signature>) -> Memory<Func>

// .NET, .NET Standard 2.0
func NewFunc(pos Pos, pkg Memory<Package>, name string, sig Memory<Signature>) Memory<Func>
// Island
func NewFunc(pos Pos, pkg Memory<Package>, name string, sig Memory<Signature>) Memory<Func>

// .NET, .NET Standard 2.0
Shared Function NewFunc(pos As Pos, pkg As Memory<Package>, name As string, sig As Memory<Signature>) As Memory<Func>
// Island
Shared Function NewFunc(pos As Pos, pkg As Memory<Package>, name As string, sig As Memory<Signature>) As Memory<Func>

// .NET, .NET Standard 2.0
class method NewInterface(methods: Slice<Memory<Func>>; embeddeds: Slice<Memory<Named>>): Memory<Interface>
// Island
class method NewInterface(methods: Slice<Memory<Func>>; embeddeds: Slice<Memory<Named>>): Memory<Interface>

// .NET, .NET Standard 2.0
static Memory<Interface> NewInterface(Slice<Memory<Func>> methods, Slice<Memory<Named>> embeddeds)
// Island
static Memory<Interface> NewInterface(Slice<Memory<Func>> methods, Slice<Memory<Named>> embeddeds)

// .NET, .NET Standard 2.0
static func NewInterface(_ methods: Slice<Memory<Func>>, _ embeddeds: Slice<Memory<Named>>) -> Memory<Interface>
// Island
static func NewInterface(_ methods: Slice<Memory<Func>>, _ embeddeds: Slice<Memory<Named>>) -> Memory<Interface>

// .NET, .NET Standard 2.0
func NewInterface(methods Slice<Memory<Func>>, embeddeds Slice<Memory<Named>>) Memory<Interface>
// Island
func NewInterface(methods Slice<Memory<Func>>, embeddeds Slice<Memory<Named>>) Memory<Interface>

// .NET, .NET Standard 2.0
Shared Function NewInterface(methods As Slice<Memory<Func>>, embeddeds As Slice<Memory<Named>>) As Memory<Interface>
// Island
Shared Function NewInterface(methods As Slice<Memory<Func>>, embeddeds As Slice<Memory<Named>>) As Memory<Interface>

// .NET, .NET Standard 2.0
class method NewInterfaceType(methods: Slice<Memory<Func>>; embeddeds: Slice<Type>): Memory<Interface>
// Island
class method NewInterfaceType(methods: Slice<Memory<Func>>; embeddeds: Slice<Type>): Memory<Interface>

// .NET, .NET Standard 2.0
static Memory<Interface> NewInterfaceType(Slice<Memory<Func>> methods, Slice<Type> embeddeds)
// Island
static Memory<Interface> NewInterfaceType(Slice<Memory<Func>> methods, Slice<Type> embeddeds)

// .NET, .NET Standard 2.0
static func NewInterfaceType(_ methods: Slice<Memory<Func>>, _ embeddeds: Slice<Type>) -> Memory<Interface>
// Island
static func NewInterfaceType(_ methods: Slice<Memory<Func>>, _ embeddeds: Slice<Type>) -> Memory<Interface>

// .NET, .NET Standard 2.0
func NewInterfaceType(methods Slice<Memory<Func>>, embeddeds Slice<Type>) Memory<Interface>
// Island
func NewInterfaceType(methods Slice<Memory<Func>>, embeddeds Slice<Type>) Memory<Interface>

// .NET, .NET Standard 2.0
Shared Function NewInterfaceType(methods As Slice<Memory<Func>>, embeddeds As Slice<Type>) As Memory<Interface>
// Island
Shared Function NewInterfaceType(methods As Slice<Memory<Func>>, embeddeds As Slice<Type>) As Memory<Interface>

// .NET, .NET Standard 2.0
class method NewLabel(pos: Pos; pkg: Memory<Package>; name: string): Memory<Label>
// Island
class method NewLabel(pos: Pos; pkg: Memory<Package>; name: string): Memory<Label>

// .NET, .NET Standard 2.0
static Memory<Label> NewLabel(Pos pos, Memory<Package> pkg, string name)
// Island
static Memory<Label> NewLabel(Pos pos, Memory<Package> pkg, string name)

// .NET, .NET Standard 2.0
static func NewLabel(_ pos: Pos, _ pkg: Memory<Package>, _ name: string) -> Memory<Label>
// Island
static func NewLabel(_ pos: Pos, _ pkg: Memory<Package>, _ name: string) -> Memory<Label>

// .NET, .NET Standard 2.0
func NewLabel(pos Pos, pkg Memory<Package>, name string) Memory<Label>
// Island
func NewLabel(pos Pos, pkg Memory<Package>, name string) Memory<Label>

// .NET, .NET Standard 2.0
Shared Function NewLabel(pos As Pos, pkg As Memory<Package>, name As string) As Memory<Label>
// Island
Shared Function NewLabel(pos As Pos, pkg As Memory<Package>, name As string) As Memory<Label>

// .NET, .NET Standard 2.0
class method NewMap(key: Type; elem: Type): Memory<Map>
// Island
class method NewMap(key: Type; elem: Type): Memory<Map>

// .NET, .NET Standard 2.0
static Memory<Map> NewMap(Type key, Type elem)
// Island
static Memory<Map> NewMap(Type key, Type elem)

// .NET, .NET Standard 2.0
static func NewMap(_ key: Type, _ elem: Type) -> Memory<Map>
// Island
static func NewMap(_ key: Type, _ elem: Type) -> Memory<Map>

// .NET, .NET Standard 2.0
func NewMap(key Type, elem Type) Memory<Map>
// Island
func NewMap(key Type, elem Type) Memory<Map>

// .NET, .NET Standard 2.0
Shared Function NewMap(key As Type, elem As Type) As Memory<Map>
// Island
Shared Function NewMap(key As Type, elem As Type) As Memory<Map>

// .NET, .NET Standard 2.0
class method NewMethodSet(T: Type): Memory<MethodSet>
// Island
class method NewMethodSet(T: Type): Memory<MethodSet>

// .NET, .NET Standard 2.0
static Memory<MethodSet> NewMethodSet(Type T)
// Island
static Memory<MethodSet> NewMethodSet(Type T)

// .NET, .NET Standard 2.0
static func NewMethodSet(_ T: Type) -> Memory<MethodSet>
// Island
static func NewMethodSet(_ T: Type) -> Memory<MethodSet>

// .NET, .NET Standard 2.0
func NewMethodSet(T Type) Memory<MethodSet>
// Island
func NewMethodSet(T Type) Memory<MethodSet>

// .NET, .NET Standard 2.0
Shared Function NewMethodSet(T As Type) As Memory<MethodSet>
// Island
Shared Function NewMethodSet(T As Type) As Memory<MethodSet>

// .NET, .NET Standard 2.0
class method NewNamed(obj: Memory<TypeName>; underlying: Type; methods: Slice<Memory<Func>>): Memory<Named>
// Island
class method NewNamed(obj: Memory<TypeName>; underlying: Type; methods: Slice<Memory<Func>>): Memory<Named>

// .NET, .NET Standard 2.0
static Memory<Named> NewNamed(Memory<TypeName> obj, Type underlying, Slice<Memory<Func>> methods)
// Island
static Memory<Named> NewNamed(Memory<TypeName> obj, Type underlying, Slice<Memory<Func>> methods)

// .NET, .NET Standard 2.0
static func NewNamed(_ obj: Memory<TypeName>, _ underlying: Type, _ methods: Slice<Memory<Func>>) -> Memory<Named>
// Island
static func NewNamed(_ obj: Memory<TypeName>, _ underlying: Type, _ methods: Slice<Memory<Func>>) -> Memory<Named>

// .NET, .NET Standard 2.0
func NewNamed(obj Memory<TypeName>, underlying Type, methods Slice<Memory<Func>>) Memory<Named>
// Island
func NewNamed(obj Memory<TypeName>, underlying Type, methods Slice<Memory<Func>>) Memory<Named>

// .NET, .NET Standard 2.0
Shared Function NewNamed(obj As Memory<TypeName>, underlying As Type, methods As Slice<Memory<Func>>) As Memory<Named>
// Island
Shared Function NewNamed(obj As Memory<TypeName>, underlying As Type, methods As Slice<Memory<Func>>) As Memory<Named>

// .NET, .NET Standard 2.0
class method NewPackage(path: string; name: string): Memory<Package>
// Island
class method NewPackage(path: string; name: string): Memory<Package>

// .NET, .NET Standard 2.0
static Memory<Package> NewPackage(string path, string name)
// Island
static Memory<Package> NewPackage(string path, string name)

// .NET, .NET Standard 2.0
static func NewPackage(_ path: string, _ name: string) -> Memory<Package>
// Island
static func NewPackage(_ path: string, _ name: string) -> Memory<Package>

// .NET, .NET Standard 2.0
func NewPackage(path string, name string) Memory<Package>
// Island
func NewPackage(path string, name string) Memory<Package>

// .NET, .NET Standard 2.0
Shared Function NewPackage(path As string, name As string) As Memory<Package>
// Island
Shared Function NewPackage(path As string, name As string) As Memory<Package>

// .NET, .NET Standard 2.0
class method NewParam(pos: Pos; pkg: Memory<Package>; name: string; typ: Type): Memory<Var>
// Island
class method NewParam(pos: Pos; pkg: Memory<Package>; name: string; typ: Type): Memory<Var>

// .NET, .NET Standard 2.0
static Memory<Var> NewParam(Pos pos, Memory<Package> pkg, string name, Type typ)
// Island
static Memory<Var> NewParam(Pos pos, Memory<Package> pkg, string name, Type typ)

// .NET, .NET Standard 2.0
static func NewParam(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type) -> Memory<Var>
// Island
static func NewParam(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type) -> Memory<Var>

// .NET, .NET Standard 2.0
func NewParam(pos Pos, pkg Memory<Package>, name string, typ Type) Memory<Var>
// Island
func NewParam(pos Pos, pkg Memory<Package>, name string, typ Type) Memory<Var>

// .NET, .NET Standard 2.0
Shared Function NewParam(pos As Pos, pkg As Memory<Package>, name As string, typ As Type) As Memory<Var>
// Island
Shared Function NewParam(pos As Pos, pkg As Memory<Package>, name As string, typ As Type) As Memory<Var>

// .NET, .NET Standard 2.0
class method NewPkgName(pos: Pos; pkg: Memory<Package>; name: string; imported: Memory<Package>): Memory<PkgName>
// Island
class method NewPkgName(pos: Pos; pkg: Memory<Package>; name: string; imported: Memory<Package>): Memory<PkgName>

// .NET, .NET Standard 2.0
static Memory<PkgName> NewPkgName(Pos pos, Memory<Package> pkg, string name, Memory<Package> imported)
// Island
static Memory<PkgName> NewPkgName(Pos pos, Memory<Package> pkg, string name, Memory<Package> imported)

// .NET, .NET Standard 2.0
static func NewPkgName(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ imported: Memory<Package>) -> Memory<PkgName>
// Island
static func NewPkgName(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ imported: Memory<Package>) -> Memory<PkgName>

// .NET, .NET Standard 2.0
func NewPkgName(pos Pos, pkg Memory<Package>, name string, imported Memory<Package>) Memory<PkgName>
// Island
func NewPkgName(pos Pos, pkg Memory<Package>, name string, imported Memory<Package>) Memory<PkgName>

// .NET, .NET Standard 2.0
Shared Function NewPkgName(pos As Pos, pkg As Memory<Package>, name As string, imported As Memory<Package>) As Memory<PkgName>
// Island
Shared Function NewPkgName(pos As Pos, pkg As Memory<Package>, name As string, imported As Memory<Package>) As Memory<PkgName>

// .NET, .NET Standard 2.0
class method NewPointer(elem: Type): Memory<Pointer>
// Island
class method NewPointer(elem: Type): Memory<Pointer>

// .NET, .NET Standard 2.0
static Memory<Pointer> NewPointer(Type elem)
// Island
static Memory<Pointer> NewPointer(Type elem)

// .NET, .NET Standard 2.0
static func NewPointer(_ elem: Type) -> Memory<Pointer>
// Island
static func NewPointer(_ elem: Type) -> Memory<Pointer>

// .NET, .NET Standard 2.0
func NewPointer(elem Type) Memory<Pointer>
// Island
func NewPointer(elem Type) Memory<Pointer>

// .NET, .NET Standard 2.0
Shared Function NewPointer(elem As Type) As Memory<Pointer>
// Island
Shared Function NewPointer(elem As Type) As Memory<Pointer>

// .NET, .NET Standard 2.0
class method NewScope(parent: Memory<Scope>; pos: Pos; end: Pos; comment: string): Memory<Scope>
// Island
class method NewScope(parent: Memory<Scope>; pos: Pos; end: Pos; comment: string): Memory<Scope>

// .NET, .NET Standard 2.0
static Memory<Scope> NewScope(Memory<Scope> parent, Pos pos, Pos end, string comment)
// Island
static Memory<Scope> NewScope(Memory<Scope> parent, Pos pos, Pos end, string comment)

// .NET, .NET Standard 2.0
static func NewScope(_ parent: Memory<Scope>, _ pos: Pos, _ end: Pos, _ comment: string) -> Memory<Scope>
// Island
static func NewScope(_ parent: Memory<Scope>, _ pos: Pos, _ end: Pos, _ comment: string) -> Memory<Scope>

// .NET, .NET Standard 2.0
func NewScope(parent Memory<Scope>, pos Pos, end Pos, comment string) Memory<Scope>
// Island
func NewScope(parent Memory<Scope>, pos Pos, end Pos, comment string) Memory<Scope>

// .NET, .NET Standard 2.0
Shared Function NewScope(parent As Memory<Scope>, pos As Pos, end As Pos, comment As string) As Memory<Scope>
// Island
Shared Function NewScope(parent As Memory<Scope>, pos As Pos, end As Pos, comment As string) As Memory<Scope>

// .NET, .NET Standard 2.0
class method NewSignature(recv: Memory<Var>; params: Memory<Tuple>; results: Memory<Tuple>; variadic: bool): Memory<Signature>
// Island
class method NewSignature(recv: Memory<Var>; params: Memory<Tuple>; results: Memory<Tuple>; variadic: bool): Memory<Signature>

// .NET, .NET Standard 2.0
static Memory<Signature> NewSignature(Memory<Var> recv, Memory<Tuple> params, Memory<Tuple> results, bool variadic)
// Island
static Memory<Signature> NewSignature(Memory<Var> recv, Memory<Tuple> params, Memory<Tuple> results, bool variadic)

// .NET, .NET Standard 2.0
static func NewSignature(_ recv: Memory<Var>, _ params: Memory<Tuple>, _ results: Memory<Tuple>, _ variadic: bool) -> Memory<Signature>
// Island
static func NewSignature(_ recv: Memory<Var>, _ params: Memory<Tuple>, _ results: Memory<Tuple>, _ variadic: bool) -> Memory<Signature>

// .NET, .NET Standard 2.0
func NewSignature(recv Memory<Var>, params Memory<Tuple>, results Memory<Tuple>, variadic bool) Memory<Signature>
// Island
func NewSignature(recv Memory<Var>, params Memory<Tuple>, results Memory<Tuple>, variadic bool) Memory<Signature>

// .NET, .NET Standard 2.0
Shared Function NewSignature(recv As Memory<Var>, params As Memory<Tuple>, results As Memory<Tuple>, variadic As bool) As Memory<Signature>
// Island
Shared Function NewSignature(recv As Memory<Var>, params As Memory<Tuple>, results As Memory<Tuple>, variadic As bool) As Memory<Signature>

// .NET, .NET Standard 2.0
class method NewSlice(elem: Type): Memory<Slice>
// Island
class method NewSlice(elem: Type): Memory<Slice>

// .NET, .NET Standard 2.0
static Memory<Slice> NewSlice(Type elem)
// Island
static Memory<Slice> NewSlice(Type elem)

// .NET, .NET Standard 2.0
static func NewSlice(_ elem: Type) -> Memory<Slice>
// Island
static func NewSlice(_ elem: Type) -> Memory<Slice>

// .NET, .NET Standard 2.0
func NewSlice(elem Type) Memory<Slice>
// Island
func NewSlice(elem Type) Memory<Slice>

// .NET, .NET Standard 2.0
Shared Function NewSlice(elem As Type) As Memory<Slice>
// Island
Shared Function NewSlice(elem As Type) As Memory<Slice>

// .NET, .NET Standard 2.0
class method NewStruct(fields: Slice<Memory<Var>>; tags: Slice<string>): Memory<Struct>
// Island
class method NewStruct(fields: Slice<Memory<Var>>; tags: Slice<string>): Memory<Struct>

// .NET, .NET Standard 2.0
static Memory<Struct> NewStruct(Slice<Memory<Var>> fields, Slice<string> tags)
// Island
static Memory<Struct> NewStruct(Slice<Memory<Var>> fields, Slice<string> tags)

// .NET, .NET Standard 2.0
static func NewStruct(_ fields: Slice<Memory<Var>>, _ tags: Slice<string>) -> Memory<Struct>
// Island
static func NewStruct(_ fields: Slice<Memory<Var>>, _ tags: Slice<string>) -> Memory<Struct>

// .NET, .NET Standard 2.0
func NewStruct(fields Slice<Memory<Var>>, tags Slice<string>) Memory<Struct>
// Island
func NewStruct(fields Slice<Memory<Var>>, tags Slice<string>) Memory<Struct>

// .NET, .NET Standard 2.0
Shared Function NewStruct(fields As Slice<Memory<Var>>, tags As Slice<string>) As Memory<Struct>
// Island
Shared Function NewStruct(fields As Slice<Memory<Var>>, tags As Slice<string>) As Memory<Struct>

// .NET, .NET Standard 2.0
class method NewTuple(params x: array of Memory<Var>): Memory<Tuple>
// Island
class method NewTuple(params x: array of Memory<Var>): Memory<Tuple>

// .NET, .NET Standard 2.0
static Memory<Tuple> NewTuple(params Memory<Var>[] x)
// Island
static Memory<Tuple> NewTuple(params Memory<Var>[] x)

// .NET, .NET Standard 2.0
static func NewTuple(_ x: Memory<Var>...) -> Memory<Tuple>
// Island
static func NewTuple(_ x: Memory<Var>...) -> Memory<Tuple>

// .NET, .NET Standard 2.0
func NewTuple(x []Memory<Var>) Memory<Tuple>
// Island
func NewTuple(x []Memory<Var>) Memory<Tuple>

// .NET, .NET Standard 2.0
Shared Function NewTuple(ParamArray x As Memory<Var>()) As Memory<Tuple>
// Island
Shared Function NewTuple(ParamArray x As Memory<Var>()) As Memory<Tuple>

// .NET, .NET Standard 2.0
class method NewTypeName(pos: Pos; pkg: Memory<Package>; name: string; typ: Type): Memory<TypeName>
// Island
class method NewTypeName(pos: Pos; pkg: Memory<Package>; name: string; typ: Type): Memory<TypeName>

// .NET, .NET Standard 2.0
static Memory<TypeName> NewTypeName(Pos pos, Memory<Package> pkg, string name, Type typ)
// Island
static Memory<TypeName> NewTypeName(Pos pos, Memory<Package> pkg, string name, Type typ)

// .NET, .NET Standard 2.0
static func NewTypeName(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type) -> Memory<TypeName>
// Island
static func NewTypeName(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type) -> Memory<TypeName>

// .NET, .NET Standard 2.0
func NewTypeName(pos Pos, pkg Memory<Package>, name string, typ Type) Memory<TypeName>
// Island
func NewTypeName(pos Pos, pkg Memory<Package>, name string, typ Type) Memory<TypeName>

// .NET, .NET Standard 2.0
Shared Function NewTypeName(pos As Pos, pkg As Memory<Package>, name As string, typ As Type) As Memory<TypeName>
// Island
Shared Function NewTypeName(pos As Pos, pkg As Memory<Package>, name As string, typ As Type) As Memory<TypeName>

// .NET, .NET Standard 2.0
class method NewVar(pos: Pos; pkg: Memory<Package>; name: string; typ: Type): Memory<Var>
// Island
class method NewVar(pos: Pos; pkg: Memory<Package>; name: string; typ: Type): Memory<Var>

// .NET, .NET Standard 2.0
static Memory<Var> NewVar(Pos pos, Memory<Package> pkg, string name, Type typ)
// Island
static Memory<Var> NewVar(Pos pos, Memory<Package> pkg, string name, Type typ)

// .NET, .NET Standard 2.0
static func NewVar(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type) -> Memory<Var>
// Island
static func NewVar(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type) -> Memory<Var>

// .NET, .NET Standard 2.0
func NewVar(pos Pos, pkg Memory<Package>, name string, typ Type) Memory<Var>
// Island
func NewVar(pos Pos, pkg Memory<Package>, name string, typ Type) Memory<Var>

// .NET, .NET Standard 2.0
Shared Function NewVar(pos As Pos, pkg As Memory<Package>, name As string, typ As Type) As Memory<Var>
// Island
Shared Function NewVar(pos As Pos, pkg As Memory<Package>, name As string, typ As Type) As Memory<Var>

class method ObjectString(obj: Object; qf: Qualifier): string

static string ObjectString(Object obj, Qualifier qf)

static func ObjectString(_ obj: Object, _ qf: Qualifier) -> string

func ObjectString(obj Object, qf Qualifier) string

Shared Function ObjectString(obj As Object, qf As Qualifier) As string

const RecvOnly: ChanDir = 2;

const ChanDir RecvOnly = 2

static let RecvOnly: ChanDir = 2

const RecvOnly ChanDir = 2

Dim RecvOnly As ChanDir = 2

// .NET, .NET Standard 2.0
class method RelativeTo(pkg: Memory<Package>): Qualifier
// Island
class method RelativeTo(pkg: Memory<Package>): Qualifier

// .NET, .NET Standard 2.0
static Qualifier RelativeTo(Memory<Package> pkg)
// Island
static Qualifier RelativeTo(Memory<Package> pkg)

// .NET, .NET Standard 2.0
static func RelativeTo(_ pkg: Memory<Package>) -> Qualifier
// Island
static func RelativeTo(_ pkg: Memory<Package>) -> Qualifier

// .NET, .NET Standard 2.0
func RelativeTo(pkg Memory<Package>) Qualifier
// Island
func RelativeTo(pkg Memory<Package>) Qualifier

// .NET, .NET Standard 2.0
Shared Function RelativeTo(pkg As Memory<Package>) As Qualifier
// Island
Shared Function RelativeTo(pkg As Memory<Package>) As Qualifier

const Rune: BasicKind = 5;

const BasicKind Rune = 5

static let Rune: BasicKind = 5

const Rune BasicKind = 5

Dim Rune As BasicKind = 5

// .NET, .NET Standard 2.0
class method SelectionString(s: Memory<Selection>; qf: Qualifier): string
// Island
class method SelectionString(s: Memory<Selection>; qf: Qualifier): string

// .NET, .NET Standard 2.0
static string SelectionString(Memory<Selection> s, Qualifier qf)
// Island
static string SelectionString(Memory<Selection> s, Qualifier qf)

// .NET, .NET Standard 2.0
static func SelectionString(_ s: Memory<Selection>, _ qf: Qualifier) -> string
// Island
static func SelectionString(_ s: Memory<Selection>, _ qf: Qualifier) -> string

// .NET, .NET Standard 2.0
func SelectionString(s Memory<Selection>, qf Qualifier) string
// Island
func SelectionString(s Memory<Selection>, qf Qualifier) string

// .NET, .NET Standard 2.0
Shared Function SelectionString(s As Memory<Selection>, qf As Qualifier) As string
// Island
Shared Function SelectionString(s As Memory<Selection>, qf As Qualifier) As string

const SendOnly: ChanDir = 1;

const ChanDir SendOnly = 1

static let SendOnly: ChanDir = 1

const SendOnly ChanDir = 1

Dim SendOnly As ChanDir = 1

const SendRecv: ChanDir = 0;

const ChanDir SendRecv = 0

static let SendRecv: ChanDir = 0

const SendRecv ChanDir = 0

Dim SendRecv As ChanDir = 0

class method SizesFor(compiler: string; arch: string): Sizes

static Sizes SizesFor(string compiler, string arch)

static func SizesFor(_ compiler: string, _ arch: string) -> Sizes

func SizesFor(compiler string, arch string) Sizes

Shared Function SizesFor(compiler As string, arch As string) As Sizes

const String: BasicKind = 17;

const BasicKind String = 17

static let String: BasicKind = 17

const String BasicKind = 17

Dim String As BasicKind = 17

// .NET, .NET Standard 2.0
class var Typ: Slice<Memory<Basic>>;
// Island
class var Typ: Slice<Memory<Basic>>;

// .NET, .NET Standard 2.0
static Slice<Memory<Basic>> Typ
// Island
static Slice<Memory<Basic>> Typ

// .NET, .NET Standard 2.0
static var Typ: Slice<Memory<Basic>>
// Island
static var Typ: Slice<Memory<Basic>>

// .NET, .NET Standard 2.0
Typ Slice<Memory<Basic>>
// Island
Typ Slice<Memory<Basic>>

// .NET, .NET Standard 2.0
Shared FIELD Typ() As Slice<Memory<Basic>>
// Island
Shared FIELD Typ() As Slice<Memory<Basic>>

class method TypeString(typ: Type; qf: Qualifier): string

static string TypeString(Type typ, Qualifier qf)

static func TypeString(_ typ: Type, _ qf: Qualifier) -> string

func TypeString(typ Type, qf Qualifier) string

Shared Function TypeString(typ As Type, qf As Qualifier) As string

const Uint: BasicKind = 7;

const BasicKind Uint = 7

static let Uint: BasicKind = 7

const Uint BasicKind = 7

Dim Uint As BasicKind = 7

const Uint16: BasicKind = 9;

const BasicKind Uint16 = 9

static let Uint16: BasicKind = 9

const Uint16 BasicKind = 9

Dim Uint16 As BasicKind = 9

const Uint32: BasicKind = 10;

const BasicKind Uint32 = 10

static let Uint32: BasicKind = 10

const Uint32 BasicKind = 10

Dim Uint32 As BasicKind = 10

const Uint64: BasicKind = 11;

const BasicKind Uint64 = 11

static let Uint64: BasicKind = 11

const Uint64 BasicKind = 11

Dim Uint64 As BasicKind = 11

const Uint8: BasicKind = 8;

const BasicKind Uint8 = 8

static let Uint8: BasicKind = 8

const Uint8 BasicKind = 8

Dim Uint8 As BasicKind = 8

const Uintptr: BasicKind = 12;

const BasicKind Uintptr = 12

static let Uintptr: BasicKind = 12

const Uintptr BasicKind = 12

Dim Uintptr As BasicKind = 12

// .NET, .NET Standard 2.0
class var Universe: Memory<Scope>;
// Island
class var Universe: Memory<Scope>;

// .NET, .NET Standard 2.0
static Memory<Scope> Universe
// Island
static Memory<Scope> Universe

// .NET, .NET Standard 2.0
static var Universe: Memory<Scope>
// Island
static var Universe: Memory<Scope>

// .NET, .NET Standard 2.0
Universe Memory<Scope>
// Island
Universe Memory<Scope>

// .NET, .NET Standard 2.0
Shared FIELD Universe() As Memory<Scope>
// Island
Shared FIELD Universe() As Memory<Scope>

// .NET, .NET Standard 2.0
class var Unsafe: Memory<Package>;
// Island
class var Unsafe: Memory<Package>;

// .NET, .NET Standard 2.0
static Memory<Package> Unsafe
// Island
static Memory<Package> Unsafe

// .NET, .NET Standard 2.0
static var Unsafe: Memory<Package>
// Island
static var Unsafe: Memory<Package>

// .NET, .NET Standard 2.0
Unsafe Memory<Package>
// Island
Unsafe Memory<Package>

// .NET, .NET Standard 2.0
Shared FIELD Unsafe() As Memory<Package>
// Island
Shared FIELD Unsafe() As Memory<Package>

const UnsafePointer: BasicKind = 18;

const BasicKind UnsafePointer = 18

static let UnsafePointer: BasicKind = 18

const UnsafePointer BasicKind = 18

Dim UnsafePointer As BasicKind = 18

const UntypedBool: BasicKind = 19;

const BasicKind UntypedBool = 19

static let UntypedBool: BasicKind = 19

const UntypedBool BasicKind = 19

Dim UntypedBool As BasicKind = 19

const UntypedComplex: BasicKind = 23;

const BasicKind UntypedComplex = 23

static let UntypedComplex: BasicKind = 23

const UntypedComplex BasicKind = 23

Dim UntypedComplex As BasicKind = 23

const UntypedFloat: BasicKind = 22;

const BasicKind UntypedFloat = 22

static let UntypedFloat: BasicKind = 22

const UntypedFloat BasicKind = 22

Dim UntypedFloat As BasicKind = 22

const UntypedInt: BasicKind = 20;

const BasicKind UntypedInt = 20

static let UntypedInt: BasicKind = 20

const UntypedInt BasicKind = 20

Dim UntypedInt As BasicKind = 20

const UntypedNil: BasicKind = 25;

const BasicKind UntypedNil = 25

static let UntypedNil: BasicKind = 25

const UntypedNil BasicKind = 25

Dim UntypedNil As BasicKind = 25

const UntypedRune: BasicKind = 21;

const BasicKind UntypedRune = 21

static let UntypedRune: BasicKind = 21

const UntypedRune BasicKind = 21

Dim UntypedRune As BasicKind = 21

const UntypedString: BasicKind = 24;

const BasicKind UntypedString = 24

static let UntypedString: BasicKind = 24

const UntypedString BasicKind = 24

Dim UntypedString As BasicKind = 24

// .NET, .NET Standard 2.0
class method WriteExpr(buf: Memory<Buffer>; x: Expr)
// Island
class method WriteExpr(buf: Memory<Buffer>; x: Expr)

// .NET, .NET Standard 2.0
static void WriteExpr(Memory<Buffer> buf, Expr x)
// Island
static void WriteExpr(Memory<Buffer> buf, Expr x)

// .NET, .NET Standard 2.0
static func WriteExpr(_ buf: Memory<Buffer>, _ x: Expr)
// Island
static func WriteExpr(_ buf: Memory<Buffer>, _ x: Expr)

// .NET, .NET Standard 2.0
func WriteExpr(buf Memory<Buffer>, x Expr) 
// Island
func WriteExpr(buf Memory<Buffer>, x Expr) void

// .NET, .NET Standard 2.0
Shared Sub WriteExpr(buf As Memory<Buffer>, x As Expr)
// Island
Shared Sub WriteExpr(buf As Memory<Buffer>, x As Expr)

// .NET, .NET Standard 2.0
class method WriteSignature(buf: Memory<Buffer>; sig: Memory<Signature>; qf: Qualifier)
// Island
class method WriteSignature(buf: Memory<Buffer>; sig: Memory<Signature>; qf: Qualifier)

// .NET, .NET Standard 2.0
static void WriteSignature(Memory<Buffer> buf, Memory<Signature> sig, Qualifier qf)
// Island
static void WriteSignature(Memory<Buffer> buf, Memory<Signature> sig, Qualifier qf)

// .NET, .NET Standard 2.0
static func WriteSignature(_ buf: Memory<Buffer>, _ sig: Memory<Signature>, _ qf: Qualifier)
// Island
static func WriteSignature(_ buf: Memory<Buffer>, _ sig: Memory<Signature>, _ qf: Qualifier)

// .NET, .NET Standard 2.0
func WriteSignature(buf Memory<Buffer>, sig Memory<Signature>, qf Qualifier) 
// Island
func WriteSignature(buf Memory<Buffer>, sig Memory<Signature>, qf Qualifier) void

// .NET, .NET Standard 2.0
Shared Sub WriteSignature(buf As Memory<Buffer>, sig As Memory<Signature>, qf As Qualifier)
// Island
Shared Sub WriteSignature(buf As Memory<Buffer>, sig As Memory<Signature>, qf As Qualifier)

// .NET, .NET Standard 2.0
class method WriteType(buf: Memory<Buffer>; typ: Type; qf: Qualifier)
// Island
class method WriteType(buf: Memory<Buffer>; typ: Type; qf: Qualifier)

// .NET, .NET Standard 2.0
static void WriteType(Memory<Buffer> buf, Type typ, Qualifier qf)
// Island
static void WriteType(Memory<Buffer> buf, Type typ, Qualifier qf)

// .NET, .NET Standard 2.0
static func WriteType(_ buf: Memory<Buffer>, _ typ: Type, _ qf: Qualifier)
// Island
static func WriteType(_ buf: Memory<Buffer>, _ typ: Type, _ qf: Qualifier)

// .NET, .NET Standard 2.0
func WriteType(buf Memory<Buffer>, typ Type, qf Qualifier) 
// Island
func WriteType(buf Memory<Buffer>, typ Type, qf Qualifier) void

// .NET, .NET Standard 2.0
Shared Sub WriteType(buf As Memory<Buffer>, typ As Type, qf As Qualifier)
// Island
Shared Sub WriteType(buf As Memory<Buffer>, typ As Type, qf As Qualifier)

const Bool: BasicKind = 1;

const BasicKind Bool = 1

static let Bool: BasicKind = 1

const Bool BasicKind = 1

Dim Bool As BasicKind = 1

const Byte: BasicKind = 8;

const BasicKind Byte = 8

static let Byte: BasicKind = 8

const Byte BasicKind = 8

Dim Byte As BasicKind = 8

const Complex128: BasicKind = 16;

const BasicKind Complex128 = 16

static let Complex128: BasicKind = 16

const Complex128 BasicKind = 16

Dim Complex128 As BasicKind = 16

const Complex64: BasicKind = 15;

const BasicKind Complex64 = 15

static let Complex64: BasicKind = 15

const Complex64 BasicKind = 15

Dim Complex64 As BasicKind = 15

const FieldVal: SelectionKind = 0;

const SelectionKind FieldVal = 0

static let FieldVal: SelectionKind = 0

const FieldVal SelectionKind = 0

Dim FieldVal As SelectionKind = 0

const Float32: BasicKind = 13;

const BasicKind Float32 = 13

static let Float32: BasicKind = 13

const Float32 BasicKind = 13

Dim Float32 As BasicKind = 13

const Float64: BasicKind = 14;

const BasicKind Float64 = 14

static let Float64: BasicKind = 14

const Float64 BasicKind = 14

Dim Float64 As BasicKind = 14

const Int: BasicKind = 2;

const BasicKind Int = 2

static let Int: BasicKind = 2

const Int BasicKind = 2

Dim Int As BasicKind = 2

const Int16: BasicKind = 4;

const BasicKind Int16 = 4

static let Int16: BasicKind = 4

const Int16 BasicKind = 4

Dim Int16 As BasicKind = 4

const Int32: BasicKind = 5;

const BasicKind Int32 = 5

static let Int32: BasicKind = 5

const Int32 BasicKind = 5

Dim Int32 As BasicKind = 5

const Int64: BasicKind = 6;

const BasicKind Int64 = 6

static let Int64: BasicKind = 6

const Int64 BasicKind = 6

Dim Int64 As BasicKind = 6

const Int8: BasicKind = 3;

const BasicKind Int8 = 3

static let Int8: BasicKind = 3

const Int8 BasicKind = 3

Dim Int8 As BasicKind = 3

const Invalid: BasicKind = 0;

const BasicKind Invalid = 0

static let Invalid: BasicKind = 0

const Invalid BasicKind = 0

Dim Invalid As BasicKind = 0

const IsBoolean: BasicInfo = 1;

const BasicInfo IsBoolean = 1

static let IsBoolean: BasicInfo = 1

const IsBoolean BasicInfo = 1

Dim IsBoolean As BasicInfo = 1

const IsComplex: BasicInfo = 16;

const BasicInfo IsComplex = 16

static let IsComplex: BasicInfo = 16

const IsComplex BasicInfo = 16

Dim IsComplex As BasicInfo = 16

const IsConstType: BasicInfo = 59;

const BasicInfo IsConstType = 59

static let IsConstType: BasicInfo = 59

const IsConstType BasicInfo = 59

Dim IsConstType As BasicInfo = 59

const IsFloat: BasicInfo = 8;

const BasicInfo IsFloat = 8

static let IsFloat: BasicInfo = 8

const IsFloat BasicInfo = 8

Dim IsFloat As BasicInfo = 8

const IsInteger: BasicInfo = 2;

const BasicInfo IsInteger = 2

static let IsInteger: BasicInfo = 2

const IsInteger BasicInfo = 2

Dim IsInteger As BasicInfo = 2

const IsNumeric: BasicInfo = 26;

const BasicInfo IsNumeric = 26

static let IsNumeric: BasicInfo = 26

const IsNumeric BasicInfo = 26

Dim IsNumeric As BasicInfo = 26

const IsOrdered: BasicInfo = 42;

const BasicInfo IsOrdered = 42

static let IsOrdered: BasicInfo = 42

const IsOrdered BasicInfo = 42

Dim IsOrdered As BasicInfo = 42

const IsString: BasicInfo = 32;

const BasicInfo IsString = 32

static let IsString: BasicInfo = 32

const IsString BasicInfo = 32

Dim IsString As BasicInfo = 32

const IsUnsigned: BasicInfo = 4;

const BasicInfo IsUnsigned = 4

static let IsUnsigned: BasicInfo = 4

const IsUnsigned BasicInfo = 4

Dim IsUnsigned As BasicInfo = 4

const IsUntyped: BasicInfo = 64;

const BasicInfo IsUntyped = 64

static let IsUntyped: BasicInfo = 64

const IsUntyped BasicInfo = 64

Dim IsUntyped As BasicInfo = 64

const MethodExpr: SelectionKind = 2;

const SelectionKind MethodExpr = 2

static let MethodExpr: SelectionKind = 2

const MethodExpr SelectionKind = 2

Dim MethodExpr As SelectionKind = 2

const MethodVal: SelectionKind = 1;

const SelectionKind MethodVal = 1

static let MethodVal: SelectionKind = 1

const MethodVal SelectionKind = 1

Dim MethodVal As SelectionKind = 1

const RecvOnly: ChanDir = 2;

const ChanDir RecvOnly = 2

static let RecvOnly: ChanDir = 2

const RecvOnly ChanDir = 2

Dim RecvOnly As ChanDir = 2

const Rune: BasicKind = 5;

const BasicKind Rune = 5

static let Rune: BasicKind = 5

const Rune BasicKind = 5

Dim Rune As BasicKind = 5

const SendOnly: ChanDir = 1;

const ChanDir SendOnly = 1

static let SendOnly: ChanDir = 1

const SendOnly ChanDir = 1

Dim SendOnly As ChanDir = 1

const SendRecv: ChanDir = 0;

const ChanDir SendRecv = 0

static let SendRecv: ChanDir = 0

const SendRecv ChanDir = 0

Dim SendRecv As ChanDir = 0

const String: BasicKind = 17;

const BasicKind String = 17

static let String: BasicKind = 17

const String BasicKind = 17

Dim String As BasicKind = 17

const Uint: BasicKind = 7;

const BasicKind Uint = 7

static let Uint: BasicKind = 7

const Uint BasicKind = 7

Dim Uint As BasicKind = 7

const Uint16: BasicKind = 9;

const BasicKind Uint16 = 9

static let Uint16: BasicKind = 9

const Uint16 BasicKind = 9

Dim Uint16 As BasicKind = 9

const Uint32: BasicKind = 10;

const BasicKind Uint32 = 10

static let Uint32: BasicKind = 10

const Uint32 BasicKind = 10

Dim Uint32 As BasicKind = 10

const Uint64: BasicKind = 11;

const BasicKind Uint64 = 11

static let Uint64: BasicKind = 11

const Uint64 BasicKind = 11

Dim Uint64 As BasicKind = 11

const Uint8: BasicKind = 8;

const BasicKind Uint8 = 8

static let Uint8: BasicKind = 8

const Uint8 BasicKind = 8

Dim Uint8 As BasicKind = 8

const Uintptr: BasicKind = 12;

const BasicKind Uintptr = 12

static let Uintptr: BasicKind = 12

const Uintptr BasicKind = 12

Dim Uintptr As BasicKind = 12

const UnsafePointer: BasicKind = 18;

const BasicKind UnsafePointer = 18

static let UnsafePointer: BasicKind = 18

const UnsafePointer BasicKind = 18

Dim UnsafePointer As BasicKind = 18

const UntypedBool: BasicKind = 19;

const BasicKind UntypedBool = 19

static let UntypedBool: BasicKind = 19

const UntypedBool BasicKind = 19

Dim UntypedBool As BasicKind = 19

const UntypedComplex: BasicKind = 23;

const BasicKind UntypedComplex = 23

static let UntypedComplex: BasicKind = 23

const UntypedComplex BasicKind = 23

Dim UntypedComplex As BasicKind = 23

const UntypedFloat: BasicKind = 22;

const BasicKind UntypedFloat = 22

static let UntypedFloat: BasicKind = 22

const UntypedFloat BasicKind = 22

Dim UntypedFloat As BasicKind = 22

const UntypedInt: BasicKind = 20;

const BasicKind UntypedInt = 20

static let UntypedInt: BasicKind = 20

const UntypedInt BasicKind = 20

Dim UntypedInt As BasicKind = 20

const UntypedNil: BasicKind = 25;

const BasicKind UntypedNil = 25

static let UntypedNil: BasicKind = 25

const UntypedNil BasicKind = 25

Dim UntypedNil As BasicKind = 25

const UntypedRune: BasicKind = 21;

const BasicKind UntypedRune = 21

static let UntypedRune: BasicKind = 21

const UntypedRune BasicKind = 21

Dim UntypedRune As BasicKind = 21

const UntypedString: BasicKind = 24;

const BasicKind UntypedString = 24

static let UntypedString: BasicKind = 24

const UntypedString BasicKind = 24

Dim UntypedString As BasicKind = 24

// .NET, .NET Standard 2.0
class var Typ: Slice<Memory<Basic>>;
// Island
class var Typ: Slice<Memory<Basic>>;

// .NET, .NET Standard 2.0
static Slice<Memory<Basic>> Typ
// Island
static Slice<Memory<Basic>> Typ

// .NET, .NET Standard 2.0
static var Typ: Slice<Memory<Basic>>
// Island
static var Typ: Slice<Memory<Basic>>

// .NET, .NET Standard 2.0
Typ Slice<Memory<Basic>>
// Island
Typ Slice<Memory<Basic>>

// .NET, .NET Standard 2.0
Shared FIELD Typ() As Slice<Memory<Basic>>
// Island
Shared FIELD Typ() As Slice<Memory<Basic>>

// .NET, .NET Standard 2.0
class var Universe: Memory<Scope>;
// Island
class var Universe: Memory<Scope>;

// .NET, .NET Standard 2.0
static Memory<Scope> Universe
// Island
static Memory<Scope> Universe

// .NET, .NET Standard 2.0
static var Universe: Memory<Scope>
// Island
static var Universe: Memory<Scope>

// .NET, .NET Standard 2.0
Universe Memory<Scope>
// Island
Universe Memory<Scope>

// .NET, .NET Standard 2.0
Shared FIELD Universe() As Memory<Scope>
// Island
Shared FIELD Universe() As Memory<Scope>

// .NET, .NET Standard 2.0
class var Unsafe: Memory<Package>;
// Island
class var Unsafe: Memory<Package>;

// .NET, .NET Standard 2.0
static Memory<Package> Unsafe
// Island
static Memory<Package> Unsafe

// .NET, .NET Standard 2.0
static var Unsafe: Memory<Package>
// Island
static var Unsafe: Memory<Package>

// .NET, .NET Standard 2.0
Unsafe Memory<Package>
// Island
Unsafe Memory<Package>

// .NET, .NET Standard 2.0
Shared FIELD Unsafe() As Memory<Package>
// Island
Shared FIELD Unsafe() As Memory<Package>

// .NET, .NET Standard 2.0
class method AssertableTo(V: Memory<Interface>; T: Type): bool
// Island
class method AssertableTo(V: Memory<Interface>; T: Type): bool

// .NET, .NET Standard 2.0
static bool AssertableTo(Memory<Interface> V, Type T)
// Island
static bool AssertableTo(Memory<Interface> V, Type T)

// .NET, .NET Standard 2.0
static func AssertableTo(_ V: Memory<Interface>, _ T: Type) -> bool
// Island
static func AssertableTo(_ V: Memory<Interface>, _ T: Type) -> bool

// .NET, .NET Standard 2.0
func AssertableTo(V Memory<Interface>, T Type) bool
// Island
func AssertableTo(V Memory<Interface>, T Type) bool

// .NET, .NET Standard 2.0
Shared Function AssertableTo(V As Memory<Interface>, T As Type) As bool
// Island
Shared Function AssertableTo(V As Memory<Interface>, T As Type) As bool

class method AssignableTo(V: Type; T: Type): bool

static bool AssignableTo(Type V, Type T)

static func AssignableTo(_ V: Type, _ T: Type) -> bool

func AssignableTo(V Type, T Type) bool

Shared Function AssignableTo(V As Type, T As Type) As bool

// .NET, .NET Standard 2.0
class method CheckExpr(fset: Memory<FileSet>; pkg: Memory<Package>; pos: Pos; expr: Expr; info: Memory<Info>): error
// Island
class method CheckExpr(fset: Memory<FileSet>; pkg: Memory<Package>; pos: Pos; expr: Expr; info: Memory<Info>): error

// .NET, .NET Standard 2.0
static error CheckExpr(Memory<FileSet> fset, Memory<Package> pkg, Pos pos, Expr expr, Memory<Info> info)
// Island
static error CheckExpr(Memory<FileSet> fset, Memory<Package> pkg, Pos pos, Expr expr, Memory<Info> info)

// .NET, .NET Standard 2.0
static func CheckExpr(_ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ pos: Pos, _ expr: Expr, _ info: Memory<Info>) -> error
// Island
static func CheckExpr(_ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ pos: Pos, _ expr: Expr, _ info: Memory<Info>) -> error

// .NET, .NET Standard 2.0
func CheckExpr(fset Memory<FileSet>, pkg Memory<Package>, pos Pos, expr Expr, info Memory<Info>) error
// Island
func CheckExpr(fset Memory<FileSet>, pkg Memory<Package>, pos Pos, expr Expr, info Memory<Info>) error

// .NET, .NET Standard 2.0
Shared Function CheckExpr(fset As Memory<FileSet>, pkg As Memory<Package>, pos As Pos, expr As Expr, info As Memory<Info>) As error
// Island
Shared Function CheckExpr(fset As Memory<FileSet>, pkg As Memory<Package>, pos As Pos, expr As Expr, info As Memory<Info>) As error

class method Comparable(T: Type): bool

static bool Comparable(Type T)

static func Comparable(_ T: Type) -> bool

func Comparable(T Type) bool

Shared Function Comparable(T As Type) As bool

class method ConvertibleTo(V: Type; T: Type): bool

static bool ConvertibleTo(Type V, Type T)

static func ConvertibleTo(_ V: Type, _ T: Type) -> bool

func ConvertibleTo(V Type, T Type) bool

Shared Function ConvertibleTo(V As Type, T As Type) As bool

class method Default(typ: Type): Type

static Type Default(Type typ)

static func Default(_ typ: Type) -> Type

func Default(typ Type) Type

Shared Function Default(typ As Type) As Type

class method DefPredeclaredTestFuncs

static void DefPredeclaredTestFuncs()

static func DefPredeclaredTestFuncs()

// .NET, .NET Standard 2.0
func DefPredeclaredTestFuncs() 
// Island
func DefPredeclaredTestFuncs() void

Shared Sub DefPredeclaredTestFuncs()

// .NET, .NET Standard 2.0
class method Eval(fset: Memory<FileSet>; pkg: Memory<Package>; pos: Pos; expr: string): tuple of (: TypeAndValue, err: error)
// Island
class method Eval(fset: Memory<FileSet>; pkg: Memory<Package>; pos: Pos; expr: string): tuple of (: TypeAndValue, err: error)

// .NET, .NET Standard 2.0
static (TypeAndValue _, error err) Eval(Memory<FileSet> fset, Memory<Package> pkg, Pos pos, string expr)
// Island
static (TypeAndValue _, error err) Eval(Memory<FileSet> fset, Memory<Package> pkg, Pos pos, string expr)

// .NET, .NET Standard 2.0
static func Eval(_ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ pos: Pos, _ expr: string) -> (TypeAndValue, error)
// Island
static func Eval(_ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ pos: Pos, _ expr: string) -> (TypeAndValue, error)

// .NET, .NET Standard 2.0
func Eval(fset Memory<FileSet>, pkg Memory<Package>, pos Pos, expr string) tuple of (|name=| TypeAndValue, |name=err| error)
// Island
func Eval(fset Memory<FileSet>, pkg Memory<Package>, pos Pos, expr string) tuple of (|name=| TypeAndValue, |name=err| error)

// .NET, .NET Standard 2.0
Shared Function Eval(fset As Memory<FileSet>, pkg As Memory<Package>, pos As Pos, expr As string) As Tuple (Of TypeAndValue, error)
// Island
Shared Function Eval(fset As Memory<FileSet>, pkg As Memory<Package>, pos As Pos, expr As string) As Tuple (Of TypeAndValue, error)

class method ExprString(x: Expr): string

static string ExprString(Expr x)

static func ExprString(_ x: Expr) -> string

func ExprString(x Expr) string

Shared Function ExprString(x As Expr) As string

// .NET, .NET Standard 2.0
class method Id(pkg: Memory<Package>; name: string): string
// Island
class method Id(pkg: Memory<Package>; name: string): string

// .NET, .NET Standard 2.0
static string Id(Memory<Package> pkg, string name)
// Island
static string Id(Memory<Package> pkg, string name)

// .NET, .NET Standard 2.0
static func Id(_ pkg: Memory<Package>, _ name: string) -> string
// Island
static func Id(_ pkg: Memory<Package>, _ name: string) -> string

// .NET, .NET Standard 2.0
func Id(pkg Memory<Package>, name string) string
// Island
func Id(pkg Memory<Package>, name string) string

// .NET, .NET Standard 2.0
Shared Function Id(pkg As Memory<Package>, name As string) As string
// Island
Shared Function Id(pkg As Memory<Package>, name As string) As string

class method Identical(x: Type; y: Type): bool

static bool Identical(Type x, Type y)

static func Identical(_ x: Type, _ y: Type) -> bool

func Identical(x Type, y Type) bool

Shared Function Identical(x As Type, y As Type) As bool

class method IdenticalIgnoreTags(x: Type; y: Type): bool

static bool IdenticalIgnoreTags(Type x, Type y)

static func IdenticalIgnoreTags(_ x: Type, _ y: Type) -> bool

func IdenticalIgnoreTags(x Type, y Type) bool

Shared Function IdenticalIgnoreTags(x As Type, y As Type) As bool

// .NET, .NET Standard 2.0
class method Implements(V: Type; T: Memory<Interface>): bool
// Island
class method Implements(V: Type; T: Memory<Interface>): bool

// .NET, .NET Standard 2.0
static bool Implements(Type V, Memory<Interface> T)
// Island
static bool Implements(Type V, Memory<Interface> T)

// .NET, .NET Standard 2.0
static func Implements(_ V: Type, _ T: Memory<Interface>) -> bool
// Island
static func Implements(_ V: Type, _ T: Memory<Interface>) -> bool

// .NET, .NET Standard 2.0
func Implements(V Type, T Memory<Interface>) bool
// Island
func Implements(V Type, T Memory<Interface>) bool

// .NET, .NET Standard 2.0
Shared Function Implements(V As Type, T As Memory<Interface>) As bool
// Island
Shared Function Implements(V As Type, T As Memory<Interface>) As bool

class method IsInterface(typ: Type): bool

static bool IsInterface(Type typ)

static func IsInterface(_ typ: Type) -> bool

func IsInterface(typ Type) bool

Shared Function IsInterface(typ As Type) As bool

// .NET, .NET Standard 2.0
class method LookupFieldOrMethod(T: Type; addressable: bool; pkg: Memory<Package>; name: string): tuple of (obj: Object, index: Slice<Int64>, indirect: Boolean)
// Island
class method LookupFieldOrMethod(T: Type; addressable: bool; pkg: Memory<Package>; name: string): tuple of (obj: Object, index: Slice<Int64>, indirect: Boolean)

// .NET, .NET Standard 2.0
static (Object obj, Slice<Int64>index, Boolean indirect) LookupFieldOrMethod(Type T, bool addressable, Memory<Package> pkg, string name)
// Island
static (Object obj, Slice<Int64>index, Boolean indirect) LookupFieldOrMethod(Type T, bool addressable, Memory<Package> pkg, string name)

// .NET, .NET Standard 2.0
static func LookupFieldOrMethod(_ T: Type, _ addressable: bool, _ pkg: Memory<Package>, _ name: string) -> (Object, Slice<Int64>, Boolean)
// Island
static func LookupFieldOrMethod(_ T: Type, _ addressable: bool, _ pkg: Memory<Package>, _ name: string) -> (Object, Slice<Int64>, Boolean)

// .NET, .NET Standard 2.0
func LookupFieldOrMethod(T Type, addressable bool, pkg Memory<Package>, name string) tuple of (|name=obj| Object, |name=index| Slice<Int64>, |name=indirect| Boolean)
// Island
func LookupFieldOrMethod(T Type, addressable bool, pkg Memory<Package>, name string) tuple of (|name=obj| Object, |name=index| Slice<Int64>, |name=indirect| Boolean)

// .NET, .NET Standard 2.0
Shared Function LookupFieldOrMethod(T As Type, addressable As bool, pkg As Memory<Package>, name As string) As Tuple (Of Object, Slice<Int64>, Boolean)
// Island
Shared Function LookupFieldOrMethod(T As Type, addressable As bool, pkg As Memory<Package>, name As string) As Tuple (Of Object, Slice<Int64>, Boolean)

// .NET, .NET Standard 2.0
class method MissingMethod(V: Type; T: Memory<Interface>; static: bool): tuple of (method: Memory<Func>, wrongType: Boolean)
// Island
class method MissingMethod(V: Type; T: Memory<Interface>; static: bool): tuple of (method: Memory<Func>, wrongType: Boolean)

// .NET, .NET Standard 2.0
static (Memory<Func>method, Boolean wrongType) MissingMethod(Type V, Memory<Interface> T, bool static)
// Island
static (Memory<Func>method, Boolean wrongType) MissingMethod(Type V, Memory<Interface> T, bool static)

// .NET, .NET Standard 2.0
static func MissingMethod(_ V: Type, _ T: Memory<Interface>, _ static: bool) -> (Memory<Func>, Boolean)
// Island
static func MissingMethod(_ V: Type, _ T: Memory<Interface>, _ static: bool) -> (Memory<Func>, Boolean)

// .NET, .NET Standard 2.0
func MissingMethod(V Type, T Memory<Interface>, static bool) tuple of (|name=method| Memory<Func>, |name=wrongType| Boolean)
// Island
func MissingMethod(V Type, T Memory<Interface>, static bool) tuple of (|name=method| Memory<Func>, |name=wrongType| Boolean)

// .NET, .NET Standard 2.0
Shared Function MissingMethod(V As Type, T As Memory<Interface>, static As bool) As Tuple (Of Memory<Func>, Boolean)
// Island
Shared Function MissingMethod(V As Type, T As Memory<Interface>, static As bool) As Tuple (Of Memory<Func>, Boolean)

// .NET, .NET Standard 2.0
class method NewArray(elem: Type; len: int64): Memory<Array>
// Island
class method NewArray(elem: Type; len: int64): Memory<Array>

// .NET, .NET Standard 2.0
static Memory<Array> NewArray(Type elem, int64 len)
// Island
static Memory<Array> NewArray(Type elem, int64 len)

// .NET, .NET Standard 2.0
static func NewArray(_ elem: Type, _ len: int64) -> Memory<Array>
// Island
static func NewArray(_ elem: Type, _ len: int64) -> Memory<Array>

// .NET, .NET Standard 2.0
func NewArray(elem Type, len int64) Memory<Array>
// Island
func NewArray(elem Type, len int64) Memory<Array>

// .NET, .NET Standard 2.0
Shared Function NewArray(elem As Type, len As int64) As Memory<Array>
// Island
Shared Function NewArray(elem As Type, len As int64) As Memory<Array>

// .NET, .NET Standard 2.0
class method NewChan(dir: ChanDir; elem: Type): Memory<Chan>
// Island
class method NewChan(dir: ChanDir; elem: Type): Memory<Chan>

// .NET, .NET Standard 2.0
static Memory<Chan> NewChan(ChanDir dir, Type elem)
// Island
static Memory<Chan> NewChan(ChanDir dir, Type elem)

// .NET, .NET Standard 2.0
static func NewChan(_ dir: ChanDir, _ elem: Type) -> Memory<Chan>
// Island
static func NewChan(_ dir: ChanDir, _ elem: Type) -> Memory<Chan>

// .NET, .NET Standard 2.0
func NewChan(dir ChanDir, elem Type) Memory<Chan>
// Island
func NewChan(dir ChanDir, elem Type) Memory<Chan>

// .NET, .NET Standard 2.0
Shared Function NewChan(dir As ChanDir, elem As Type) As Memory<Chan>
// Island
Shared Function NewChan(dir As ChanDir, elem As Type) As Memory<Chan>

// .NET, .NET Standard 2.0
class method NewChecker(conf: Memory<Config>; fset: Memory<FileSet>; pkg: Memory<Package>; info: Memory<Info>): Memory<Checker>
// Island
class method NewChecker(conf: Memory<Config>; fset: Memory<FileSet>; pkg: Memory<Package>; info: Memory<Info>): Memory<Checker>

// .NET, .NET Standard 2.0
static Memory<Checker> NewChecker(Memory<Config> conf, Memory<FileSet> fset, Memory<Package> pkg, Memory<Info> info)
// Island
static Memory<Checker> NewChecker(Memory<Config> conf, Memory<FileSet> fset, Memory<Package> pkg, Memory<Info> info)

// .NET, .NET Standard 2.0
static func NewChecker(_ conf: Memory<Config>, _ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ info: Memory<Info>) -> Memory<Checker>
// Island
static func NewChecker(_ conf: Memory<Config>, _ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ info: Memory<Info>) -> Memory<Checker>

// .NET, .NET Standard 2.0
func NewChecker(conf Memory<Config>, fset Memory<FileSet>, pkg Memory<Package>, info Memory<Info>) Memory<Checker>
// Island
func NewChecker(conf Memory<Config>, fset Memory<FileSet>, pkg Memory<Package>, info Memory<Info>) Memory<Checker>

// .NET, .NET Standard 2.0
Shared Function NewChecker(conf As Memory<Config>, fset As Memory<FileSet>, pkg As Memory<Package>, info As Memory<Info>) As Memory<Checker>
// Island
Shared Function NewChecker(conf As Memory<Config>, fset As Memory<FileSet>, pkg As Memory<Package>, info As Memory<Info>) As Memory<Checker>