Global

Location

  • Reference:
    • Go.dll  .NET, .NET Standard 2.0
    • Go.fx  Island
  • Namespace: go.types
  • Platforms: .NET, .NET Standard 2.0, Island

 

AssertableTo

 

// .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

Parameters:

  • V:
  • T:

AssignableTo

 

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

Parameters:

  • V:
  • T:

Bool

 

const Bool: BasicKind = 1;

 

const BasicKind Bool = 1

 

static let Bool: BasicKind = 1

 

const Bool BasicKind = 1

 

Dim Bool As BasicKind = 1

Byte

 

const Byte: BasicKind = 8;

 

const BasicKind Byte = 8

 

static let Byte: BasicKind = 8

 

const Byte BasicKind = 8

 

Dim Byte As BasicKind = 8

CheckExpr

 

// .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

Parameters:

  • fset:
  • pkg:
  • pos:
  • expr:
  • info:

Comparable

 

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

Parameters:

  • T:

Complex128

 

const Complex128: BasicKind = 16;

 

const BasicKind Complex128 = 16

 

static let Complex128: BasicKind = 16

 

const Complex128 BasicKind = 16

 

Dim Complex128 As BasicKind = 16

Complex64

 

const Complex64: BasicKind = 15;

 

const BasicKind Complex64 = 15

 

static let Complex64: BasicKind = 15

 

const Complex64 BasicKind = 15

 

Dim Complex64 As BasicKind = 15

ConvertibleTo

 

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

Parameters:

  • V:
  • T:

Default

 

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

Parameters:

  • typ:

DefPredeclaredTestFuncs

 

class method DefPredeclaredTestFuncs

 

static void DefPredeclaredTestFuncs()

 

static func DefPredeclaredTestFuncs()

 

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

 

Shared Sub DefPredeclaredTestFuncs()

Eval

 

// .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)

Parameters:

  • fset:
  • pkg:
  • pos:
  • expr:

ExprString

 

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

Parameters:

  • x:

FieldVal

 

const FieldVal: SelectionKind = 0;

 

const SelectionKind FieldVal = 0

 

static let FieldVal: SelectionKind = 0

 

const FieldVal SelectionKind = 0

 

Dim FieldVal As SelectionKind = 0

Float32

 

const Float32: BasicKind = 13;

 

const BasicKind Float32 = 13

 

static let Float32: BasicKind = 13

 

const Float32 BasicKind = 13

 

Dim Float32 As BasicKind = 13

Float64

 

const Float64: BasicKind = 14;

 

const BasicKind Float64 = 14

 

static let Float64: BasicKind = 14

 

const Float64 BasicKind = 14

 

Dim Float64 As BasicKind = 14

Id

 

// .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

Parameters:

  • pkg:
  • name:

Identical

 

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

Parameters:

  • x:
  • y:

IdenticalIgnoreTags

 

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

Parameters:

  • x:
  • y:

Implements

 

// .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

Parameters:

  • V:
  • T:

Int

 

const Int: BasicKind = 2;

 

const BasicKind Int = 2

 

static let Int: BasicKind = 2

 

const Int BasicKind = 2

 

Dim Int As BasicKind = 2

Int16

 

const Int16: BasicKind = 4;

 

const BasicKind Int16 = 4

 

static let Int16: BasicKind = 4

 

const Int16 BasicKind = 4

 

Dim Int16 As BasicKind = 4

Int32

 

const Int32: BasicKind = 5;

 

const BasicKind Int32 = 5

 

static let Int32: BasicKind = 5

 

const Int32 BasicKind = 5

 

Dim Int32 As BasicKind = 5

Int64

 

const Int64: BasicKind = 6;

 

const BasicKind Int64 = 6

 

static let Int64: BasicKind = 6

 

const Int64 BasicKind = 6

 

Dim Int64 As BasicKind = 6

Int8

 

const Int8: BasicKind = 3;

 

const BasicKind Int8 = 3

 

static let Int8: BasicKind = 3

 

const Int8 BasicKind = 3

 

Dim Int8 As BasicKind = 3

Invalid

 

const Invalid: BasicKind = 0;

 

const BasicKind Invalid = 0

 

static let Invalid: BasicKind = 0

 

const Invalid BasicKind = 0

 

Dim Invalid As BasicKind = 0

IsBoolean

 

const IsBoolean: BasicInfo = 1;

 

const BasicInfo IsBoolean = 1

 

static let IsBoolean: BasicInfo = 1

 

const IsBoolean BasicInfo = 1

 

Dim IsBoolean As BasicInfo = 1

IsComplex

 

const IsComplex: BasicInfo = 16;

 

const BasicInfo IsComplex = 16

 

static let IsComplex: BasicInfo = 16

 

const IsComplex BasicInfo = 16

 

Dim IsComplex As BasicInfo = 16

IsConstType

 

const IsConstType: BasicInfo = 59;

 

const BasicInfo IsConstType = 59

 

static let IsConstType: BasicInfo = 59

 

const IsConstType BasicInfo = 59

 

Dim IsConstType As BasicInfo = 59

IsFloat

 

const IsFloat: BasicInfo = 8;

 

const BasicInfo IsFloat = 8

 

static let IsFloat: BasicInfo = 8

 

const IsFloat BasicInfo = 8

 

Dim IsFloat As BasicInfo = 8

IsInteger

 

const IsInteger: BasicInfo = 2;

 

const BasicInfo IsInteger = 2

 

static let IsInteger: BasicInfo = 2

 

const IsInteger BasicInfo = 2

 

Dim IsInteger As BasicInfo = 2

IsInterface

 

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

Parameters:

  • typ:

IsNumeric

 

const IsNumeric: BasicInfo = 26;

 

const BasicInfo IsNumeric = 26

 

static let IsNumeric: BasicInfo = 26

 

const IsNumeric BasicInfo = 26

 

Dim IsNumeric As BasicInfo = 26

IsOrdered

 

const IsOrdered: BasicInfo = 42;

 

const BasicInfo IsOrdered = 42

 

static let IsOrdered: BasicInfo = 42

 

const IsOrdered BasicInfo = 42

 

Dim IsOrdered As BasicInfo = 42

IsString

 

const IsString: BasicInfo = 32;

 

const BasicInfo IsString = 32

 

static let IsString: BasicInfo = 32

 

const IsString BasicInfo = 32

 

Dim IsString As BasicInfo = 32

IsUnsigned

 

const IsUnsigned: BasicInfo = 4;

 

const BasicInfo IsUnsigned = 4

 

static let IsUnsigned: BasicInfo = 4

 

const IsUnsigned BasicInfo = 4

 

Dim IsUnsigned As BasicInfo = 4

IsUntyped

 

const IsUntyped: BasicInfo = 64;

 

const BasicInfo IsUntyped = 64

 

static let IsUntyped: BasicInfo = 64

 

const IsUntyped BasicInfo = 64

 

Dim IsUntyped As BasicInfo = 64

LookupFieldOrMethod

 

// .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)

Parameters:

  • T:
  • addressable:
  • pkg:
  • name:

MethodExpr

 

const MethodExpr: SelectionKind = 2;

 

const SelectionKind MethodExpr = 2

 

static let MethodExpr: SelectionKind = 2

 

const MethodExpr SelectionKind = 2

 

Dim MethodExpr As SelectionKind = 2

MethodVal

 

const MethodVal: SelectionKind = 1;

 

const SelectionKind MethodVal = 1

 

static let MethodVal: SelectionKind = 1

 

const MethodVal SelectionKind = 1

 

Dim MethodVal As SelectionKind = 1

MissingMethod

 

// .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>methodmethod, 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)

Parameters:

  • V:
  • T:
  • static:

NewArray

 

// .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>

Parameters:

  • elem:
  • len:

NewChan

 

// .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>

Parameters:

  • dir:
  • elem:

NewChecker

 

// .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>

Parameters:

  • conf:
  • fset:
  • pkg:
  • info:

NewConst

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • typ:
  • val:

NewField

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • typ:
  • embedded:

NewFunc

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • sig:

NewInterface

 

// .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>

Parameters:

  • methods:
  • embeddeds:

NewInterfaceType

 

// .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>

Parameters:

  • methods:
  • embeddeds:

NewLabel

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:

NewMap

 

// .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>

Parameters:

  • key:
  • elem:

NewMethodSet

 

// .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>

Parameters:

  • T:

NewNamed

 

// .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>

Parameters:

  • obj:
  • underlying:
  • methods:

NewPackage

 

// .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>

Parameters:

  • path:
  • name:

NewParam

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • typ:

NewPkgName

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • imported:

NewPointer

 

// .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>

Parameters:

  • elem:

NewScope

 

// .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>

Parameters:

  • parent:
  • pos:
  • end:
  • comment:

NewSignature

 

// .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>

Parameters:

  • recv:
  • params:
  • results:
  • variadic:

NewSlice

 

// .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>

Parameters:

  • elem:

NewStruct

 

// .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>

Parameters:

  • fields:
  • tags:

NewTuple

 

// .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>

Parameters:

  • x:

NewTypeName

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • typ:

NewVar

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • typ:

ObjectString

 

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

Parameters:

  • obj:
  • qf:

RecvOnly

 

const RecvOnly: ChanDir = 2;

 

const ChanDir RecvOnly = 2

 

static let RecvOnly: ChanDir = 2

 

const RecvOnly ChanDir = 2

 

Dim RecvOnly As ChanDir = 2

RelativeTo

 

// .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

Parameters:

  • pkg:

Rune

 

const Rune: BasicKind = 5;

 

const BasicKind Rune = 5

 

static let Rune: BasicKind = 5

 

const Rune BasicKind = 5

 

Dim Rune As BasicKind = 5

SelectionString

 

// .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

Parameters:

  • s:
  • qf:

SendOnly

 

const SendOnly: ChanDir = 1;

 

const ChanDir SendOnly = 1

 

static let SendOnly: ChanDir = 1

 

const SendOnly ChanDir = 1

 

Dim SendOnly As ChanDir = 1

SendRecv

 

const SendRecv: ChanDir = 0;

 

const ChanDir SendRecv = 0

 

static let SendRecv: ChanDir = 0

 

const SendRecv ChanDir = 0

 

Dim SendRecv As ChanDir = 0

SizesFor

 

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

Parameters:

  • compiler:
  • arch:

String

 

const String: BasicKind = 17;

 

const BasicKind String = 17

 

static let String: BasicKind = 17

 

const String BasicKind = 17

 

Dim String As BasicKind = 17

Typ

 

// .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>>

TypeString

 

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

Parameters:

  • typ:
  • qf:

Uint

 

const Uint: BasicKind = 7;

 

const BasicKind Uint = 7

 

static let Uint: BasicKind = 7

 

const Uint BasicKind = 7

 

Dim Uint As BasicKind = 7

Uint16

 

const Uint16: BasicKind = 9;

 

const BasicKind Uint16 = 9

 

static let Uint16: BasicKind = 9

 

const Uint16 BasicKind = 9

 

Dim Uint16 As BasicKind = 9

Uint32

 

const Uint32: BasicKind = 10;

 

const BasicKind Uint32 = 10

 

static let Uint32: BasicKind = 10

 

const Uint32 BasicKind = 10

 

Dim Uint32 As BasicKind = 10

Uint64

 

const Uint64: BasicKind = 11;

 

const BasicKind Uint64 = 11

 

static let Uint64: BasicKind = 11

 

const Uint64 BasicKind = 11

 

Dim Uint64 As BasicKind = 11

Uint8

 

const Uint8: BasicKind = 8;

 

const BasicKind Uint8 = 8

 

static let Uint8: BasicKind = 8

 

const Uint8 BasicKind = 8

 

Dim Uint8 As BasicKind = 8

Uintptr

 

const Uintptr: BasicKind = 12;

 

const BasicKind Uintptr = 12

 

static let Uintptr: BasicKind = 12

 

const Uintptr BasicKind = 12

 

Dim Uintptr As BasicKind = 12

Universe

 

// .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>

Unsafe

 

// .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>

UnsafePointer

 

const UnsafePointer: BasicKind = 18;

 

const BasicKind UnsafePointer = 18

 

static let UnsafePointer: BasicKind = 18

 

const UnsafePointer BasicKind = 18

 

Dim UnsafePointer As BasicKind = 18

UntypedBool

 

const UntypedBool: BasicKind = 19;

 

const BasicKind UntypedBool = 19

 

static let UntypedBool: BasicKind = 19

 

const UntypedBool BasicKind = 19

 

Dim UntypedBool As BasicKind = 19

UntypedComplex

 

const UntypedComplex: BasicKind = 23;

 

const BasicKind UntypedComplex = 23

 

static let UntypedComplex: BasicKind = 23

 

const UntypedComplex BasicKind = 23

 

Dim UntypedComplex As BasicKind = 23

UntypedFloat

 

const UntypedFloat: BasicKind = 22;

 

const BasicKind UntypedFloat = 22

 

static let UntypedFloat: BasicKind = 22

 

const UntypedFloat BasicKind = 22

 

Dim UntypedFloat As BasicKind = 22

UntypedInt

 

const UntypedInt: BasicKind = 20;

 

const BasicKind UntypedInt = 20

 

static let UntypedInt: BasicKind = 20

 

const UntypedInt BasicKind = 20

 

Dim UntypedInt As BasicKind = 20

UntypedNil

 

const UntypedNil: BasicKind = 25;

 

const BasicKind UntypedNil = 25

 

static let UntypedNil: BasicKind = 25

 

const UntypedNil BasicKind = 25

 

Dim UntypedNil As BasicKind = 25

UntypedRune

 

const UntypedRune: BasicKind = 21;

 

const BasicKind UntypedRune = 21

 

static let UntypedRune: BasicKind = 21

 

const UntypedRune BasicKind = 21

 

Dim UntypedRune As BasicKind = 21

UntypedString

 

const UntypedString: BasicKind = 24;

 

const BasicKind UntypedString = 24

 

static let UntypedString: BasicKind = 24

 

const UntypedString BasicKind = 24

 

Dim UntypedString As BasicKind = 24

WriteExpr

 

// .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)

Parameters:

  • buf:
  • x:

WriteSignature

 

// .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)

Parameters:

  • buf:
  • sig:
  • qf:

WriteType

 

// .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)

Parameters:

  • buf:
  • typ:
  • qf:

 

Bool

 

const Bool: BasicKind = 1;

 

const BasicKind Bool = 1

 

static let Bool: BasicKind = 1

 

const Bool BasicKind = 1

 

Dim Bool As BasicKind = 1

Byte

 

const Byte: BasicKind = 8;

 

const BasicKind Byte = 8

 

static let Byte: BasicKind = 8

 

const Byte BasicKind = 8

 

Dim Byte As BasicKind = 8

Complex128

 

const Complex128: BasicKind = 16;

 

const BasicKind Complex128 = 16

 

static let Complex128: BasicKind = 16

 

const Complex128 BasicKind = 16

 

Dim Complex128 As BasicKind = 16

Complex64

 

const Complex64: BasicKind = 15;

 

const BasicKind Complex64 = 15

 

static let Complex64: BasicKind = 15

 

const Complex64 BasicKind = 15

 

Dim Complex64 As BasicKind = 15

FieldVal

 

const FieldVal: SelectionKind = 0;

 

const SelectionKind FieldVal = 0

 

static let FieldVal: SelectionKind = 0

 

const FieldVal SelectionKind = 0

 

Dim FieldVal As SelectionKind = 0

Float32

 

const Float32: BasicKind = 13;

 

const BasicKind Float32 = 13

 

static let Float32: BasicKind = 13

 

const Float32 BasicKind = 13

 

Dim Float32 As BasicKind = 13

Float64

 

const Float64: BasicKind = 14;

 

const BasicKind Float64 = 14

 

static let Float64: BasicKind = 14

 

const Float64 BasicKind = 14

 

Dim Float64 As BasicKind = 14

Int

 

const Int: BasicKind = 2;

 

const BasicKind Int = 2

 

static let Int: BasicKind = 2

 

const Int BasicKind = 2

 

Dim Int As BasicKind = 2

Int16

 

const Int16: BasicKind = 4;

 

const BasicKind Int16 = 4

 

static let Int16: BasicKind = 4

 

const Int16 BasicKind = 4

 

Dim Int16 As BasicKind = 4

Int32

 

const Int32: BasicKind = 5;

 

const BasicKind Int32 = 5

 

static let Int32: BasicKind = 5

 

const Int32 BasicKind = 5

 

Dim Int32 As BasicKind = 5

Int64

 

const Int64: BasicKind = 6;

 

const BasicKind Int64 = 6

 

static let Int64: BasicKind = 6

 

const Int64 BasicKind = 6

 

Dim Int64 As BasicKind = 6

Int8

 

const Int8: BasicKind = 3;

 

const BasicKind Int8 = 3

 

static let Int8: BasicKind = 3

 

const Int8 BasicKind = 3

 

Dim Int8 As BasicKind = 3

Invalid

 

const Invalid: BasicKind = 0;

 

const BasicKind Invalid = 0

 

static let Invalid: BasicKind = 0

 

const Invalid BasicKind = 0

 

Dim Invalid As BasicKind = 0

IsBoolean

 

const IsBoolean: BasicInfo = 1;

 

const BasicInfo IsBoolean = 1

 

static let IsBoolean: BasicInfo = 1

 

const IsBoolean BasicInfo = 1

 

Dim IsBoolean As BasicInfo = 1

IsComplex

 

const IsComplex: BasicInfo = 16;

 

const BasicInfo IsComplex = 16

 

static let IsComplex: BasicInfo = 16

 

const IsComplex BasicInfo = 16

 

Dim IsComplex As BasicInfo = 16

IsConstType

 

const IsConstType: BasicInfo = 59;

 

const BasicInfo IsConstType = 59

 

static let IsConstType: BasicInfo = 59

 

const IsConstType BasicInfo = 59

 

Dim IsConstType As BasicInfo = 59

IsFloat

 

const IsFloat: BasicInfo = 8;

 

const BasicInfo IsFloat = 8

 

static let IsFloat: BasicInfo = 8

 

const IsFloat BasicInfo = 8

 

Dim IsFloat As BasicInfo = 8

IsInteger

 

const IsInteger: BasicInfo = 2;

 

const BasicInfo IsInteger = 2

 

static let IsInteger: BasicInfo = 2

 

const IsInteger BasicInfo = 2

 

Dim IsInteger As BasicInfo = 2

IsNumeric

 

const IsNumeric: BasicInfo = 26;

 

const BasicInfo IsNumeric = 26

 

static let IsNumeric: BasicInfo = 26

 

const IsNumeric BasicInfo = 26

 

Dim IsNumeric As BasicInfo = 26

IsOrdered

 

const IsOrdered: BasicInfo = 42;

 

const BasicInfo IsOrdered = 42

 

static let IsOrdered: BasicInfo = 42

 

const IsOrdered BasicInfo = 42

 

Dim IsOrdered As BasicInfo = 42

IsString

 

const IsString: BasicInfo = 32;

 

const BasicInfo IsString = 32

 

static let IsString: BasicInfo = 32

 

const IsString BasicInfo = 32

 

Dim IsString As BasicInfo = 32

IsUnsigned

 

const IsUnsigned: BasicInfo = 4;

 

const BasicInfo IsUnsigned = 4

 

static let IsUnsigned: BasicInfo = 4

 

const IsUnsigned BasicInfo = 4

 

Dim IsUnsigned As BasicInfo = 4

IsUntyped

 

const IsUntyped: BasicInfo = 64;

 

const BasicInfo IsUntyped = 64

 

static let IsUntyped: BasicInfo = 64

 

const IsUntyped BasicInfo = 64

 

Dim IsUntyped As BasicInfo = 64

MethodExpr

 

const MethodExpr: SelectionKind = 2;

 

const SelectionKind MethodExpr = 2

 

static let MethodExpr: SelectionKind = 2

 

const MethodExpr SelectionKind = 2

 

Dim MethodExpr As SelectionKind = 2

MethodVal

 

const MethodVal: SelectionKind = 1;

 

const SelectionKind MethodVal = 1

 

static let MethodVal: SelectionKind = 1

 

const MethodVal SelectionKind = 1

 

Dim MethodVal As SelectionKind = 1

RecvOnly

 

const RecvOnly: ChanDir = 2;

 

const ChanDir RecvOnly = 2

 

static let RecvOnly: ChanDir = 2

 

const RecvOnly ChanDir = 2

 

Dim RecvOnly As ChanDir = 2

Rune

 

const Rune: BasicKind = 5;

 

const BasicKind Rune = 5

 

static let Rune: BasicKind = 5

 

const Rune BasicKind = 5

 

Dim Rune As BasicKind = 5

SendOnly

 

const SendOnly: ChanDir = 1;

 

const ChanDir SendOnly = 1

 

static let SendOnly: ChanDir = 1

 

const SendOnly ChanDir = 1

 

Dim SendOnly As ChanDir = 1

SendRecv

 

const SendRecv: ChanDir = 0;

 

const ChanDir SendRecv = 0

 

static let SendRecv: ChanDir = 0

 

const SendRecv ChanDir = 0

 

Dim SendRecv As ChanDir = 0

String

 

const String: BasicKind = 17;

 

const BasicKind String = 17

 

static let String: BasicKind = 17

 

const String BasicKind = 17

 

Dim String As BasicKind = 17

Uint

 

const Uint: BasicKind = 7;

 

const BasicKind Uint = 7

 

static let Uint: BasicKind = 7

 

const Uint BasicKind = 7

 

Dim Uint As BasicKind = 7

Uint16

 

const Uint16: BasicKind = 9;

 

const BasicKind Uint16 = 9

 

static let Uint16: BasicKind = 9

 

const Uint16 BasicKind = 9

 

Dim Uint16 As BasicKind = 9

Uint32

 

const Uint32: BasicKind = 10;

 

const BasicKind Uint32 = 10

 

static let Uint32: BasicKind = 10

 

const Uint32 BasicKind = 10

 

Dim Uint32 As BasicKind = 10

Uint64

 

const Uint64: BasicKind = 11;

 

const BasicKind Uint64 = 11

 

static let Uint64: BasicKind = 11

 

const Uint64 BasicKind = 11

 

Dim Uint64 As BasicKind = 11

Uint8

 

const Uint8: BasicKind = 8;

 

const BasicKind Uint8 = 8

 

static let Uint8: BasicKind = 8

 

const Uint8 BasicKind = 8

 

Dim Uint8 As BasicKind = 8

Uintptr

 

const Uintptr: BasicKind = 12;

 

const BasicKind Uintptr = 12

 

static let Uintptr: BasicKind = 12

 

const Uintptr BasicKind = 12

 

Dim Uintptr As BasicKind = 12

UnsafePointer

 

const UnsafePointer: BasicKind = 18;

 

const BasicKind UnsafePointer = 18

 

static let UnsafePointer: BasicKind = 18

 

const UnsafePointer BasicKind = 18

 

Dim UnsafePointer As BasicKind = 18

UntypedBool

 

const UntypedBool: BasicKind = 19;

 

const BasicKind UntypedBool = 19

 

static let UntypedBool: BasicKind = 19

 

const UntypedBool BasicKind = 19

 

Dim UntypedBool As BasicKind = 19

UntypedComplex

 

const UntypedComplex: BasicKind = 23;

 

const BasicKind UntypedComplex = 23

 

static let UntypedComplex: BasicKind = 23

 

const UntypedComplex BasicKind = 23

 

Dim UntypedComplex As BasicKind = 23

UntypedFloat

 

const UntypedFloat: BasicKind = 22;

 

const BasicKind UntypedFloat = 22

 

static let UntypedFloat: BasicKind = 22

 

const UntypedFloat BasicKind = 22

 

Dim UntypedFloat As BasicKind = 22

UntypedInt

 

const UntypedInt: BasicKind = 20;

 

const BasicKind UntypedInt = 20

 

static let UntypedInt: BasicKind = 20

 

const UntypedInt BasicKind = 20

 

Dim UntypedInt As BasicKind = 20

UntypedNil

 

const UntypedNil: BasicKind = 25;

 

const BasicKind UntypedNil = 25

 

static let UntypedNil: BasicKind = 25

 

const UntypedNil BasicKind = 25

 

Dim UntypedNil As BasicKind = 25

UntypedRune

 

const UntypedRune: BasicKind = 21;

 

const BasicKind UntypedRune = 21

 

static let UntypedRune: BasicKind = 21

 

const UntypedRune BasicKind = 21

 

Dim UntypedRune As BasicKind = 21

UntypedString

 

const UntypedString: BasicKind = 24;

 

const BasicKind UntypedString = 24

 

static let UntypedString: BasicKind = 24

 

const UntypedString BasicKind = 24

 

Dim UntypedString As BasicKind = 24

 

Typ

 

// .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>>

Universe

 

// .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>

Unsafe

 

// .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>

 

AssertableTo

 

// .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

Parameters:

  • V:
  • T:

AssignableTo

 

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

Parameters:

  • V:
  • T:

CheckExpr

 

// .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

Parameters:

  • fset:
  • pkg:
  • pos:
  • expr:
  • info:

Comparable

 

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

Parameters:

  • T:

ConvertibleTo

 

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

Parameters:

  • V:
  • T:

Default

 

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

Parameters:

  • typ:

DefPredeclaredTestFuncs

 

class method DefPredeclaredTestFuncs

 

static void DefPredeclaredTestFuncs()

 

static func DefPredeclaredTestFuncs()

 

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

 

Shared Sub DefPredeclaredTestFuncs()

Eval

 

// .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)

Parameters:

  • fset:
  • pkg:
  • pos:
  • expr:

ExprString

 

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

Parameters:

  • x:

Id

 

// .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

Parameters:

  • pkg:
  • name:

Identical

 

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

Parameters:

  • x:
  • y:

IdenticalIgnoreTags

 

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

Parameters:

  • x:
  • y:

Implements

 

// .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

Parameters:

  • V:
  • T:

IsInterface

 

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

Parameters:

  • typ:

LookupFieldOrMethod

 

// .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)

Parameters:

  • T:
  • addressable:
  • pkg:
  • name:

MissingMethod

 

// .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>methodmethod, 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)

Parameters:

  • V:
  • T:
  • static:

NewArray

 

// .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>

Parameters:

  • elem:
  • len:

NewChan

 

// .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>

Parameters:

  • dir:
  • elem:

NewChecker

 

// .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>

Parameters:

  • conf:
  • fset:
  • pkg:
  • info:

NewConst

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • typ:
  • val:

NewField

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • typ:
  • embedded:

NewFunc

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • sig:

NewInterface

 

// .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>

Parameters:

  • methods:
  • embeddeds:

NewInterfaceType

 

// .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>

Parameters:

  • methods:
  • embeddeds:

NewLabel

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:

NewMap

 

// .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>

Parameters:

  • key:
  • elem:

NewMethodSet

 

// .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>

Parameters:

  • T:

NewNamed

 

// .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>

Parameters:

  • obj:
  • underlying:
  • methods:

NewPackage

 

// .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>

Parameters:

  • path:
  • name:

NewParam

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • typ:

NewPkgName

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • imported:

NewPointer

 

// .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>

Parameters:

  • elem:

NewScope

 

// .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>

Parameters:

  • parent:
  • pos:
  • end:
  • comment:

NewSignature

 

// .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>

Parameters:

  • recv:
  • params:
  • results:
  • variadic:

NewSlice

 

// .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>

Parameters:

  • elem:

NewStruct

 

// .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>

Parameters:

  • fields:
  • tags:

NewTuple

 

// .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>

Parameters:

  • x:

NewTypeName

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • typ:

NewVar

 

// .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>

Parameters:

  • pos:
  • pkg:
  • name:
  • typ:

ObjectString

 

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

Parameters:

  • obj:
  • qf:

RelativeTo

 

// .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

Parameters:

  • pkg:

SelectionString

 

// .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

Parameters:

  • s:
  • qf:

SizesFor

 

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

Parameters:

  • compiler:
  • arch:

TypeString

 

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

Parameters:

  • typ:
  • qf:

WriteExpr

 

// .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)

Parameters:

  • buf:
  • x:

WriteSignature

 

// .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)

Parameters:

  • buf:
  • sig:
  • qf:

WriteType

 

// .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)

Parameters:

  • buf:
  • typ:
  • qf: