Global

class method AssignArray<T>(aDest: array of T; aSource: array of T)

static void AssignArray<T>(T[] aDest, T[] aSource)

static func AssignArray<T>(_ aDest: T..., _ aSource: T...)

// .NET, .NET Standard 2.0
func AssignArray<T>(aDest []T, aSource []T) 
// Island
func AssignArray<T>(aDest []T, aSource []T) void

Shared Sub AssignArray<T>(aDest As T(), aSource As T())

class method Channel_Select(aHandles: array of IWaitMessage; aBlock: Boolean): Int32

static Int32 Channel_Select(IWaitMessage[] aHandles, Boolean aBlock)

static func Channel_Select(_ aHandles: IWaitMessage..., _ aBlock: Boolean) -> Int32

func Channel_Select(aHandles []IWaitMessage, aBlock Boolean) Int32

Shared Function Channel_Select(aHandles As IWaitMessage(), aBlock As Boolean) As Int32

class method Receive<T>(aChannel: ReceivingChannel<T>): tuple of (T, Boolean)

static (T, Boolean) Receive<T>(ReceivingChannel<T> aChannel)

static func Receive<T>(_ aChannel: ReceivingChannel<T>) -> (T, Boolean)

func Receive<T>(aChannel ReceivingChannel<T>) tuple of (T, Boolean)

Shared Function Receive<T>(aChannel As ReceivingChannel<T>) As Tuple (Of T, Boolean)

class method Send<T>(aChannel: SendingChannel<T>; aVal: T)

static void Send<T>(SendingChannel<T> aChannel, T aVal)

static func Send<T>(_ aChannel: SendingChannel<T>, _ aVal: T)

// .NET, .NET Standard 2.0
func Send<T>(aChannel SendingChannel<T>, aVal T) 
// Island
func Send<T>(aChannel SendingChannel<T>, aVal T) void

Shared Sub Send<T>(aChannel As SendingChannel<T>, aVal As T)

class method Slice(aSlice: string; aStart: nullable Int32; aEnd: nullable Int32): string

static string Slice(string aSlice, Int32? aStart, Int32? aEnd)

static func Slice(_ aSlice: string, _ aStart: Int32!, _ aEnd: Int32!) -> string

func Slice(aSlice string, aStart Int32, aEnd Int32) string

Shared Function Slice(aSlice As string, aStart As Int32?, aEnd As Int32?) As string

class method Slice<T>(aSlice: array of T; aStart: nullable Int32; aEnd: nullable Int32): Slice<T>

static Slice<T> Slice<T>(T[] aSlice, Int32? aStart, Int32? aEnd)

static func Slice<T>(_ aSlice: T..., _ aStart: Int32!, _ aEnd: Int32!) -> Slice<T>

func Slice<T>(aSlice []T, aStart Int32, aEnd Int32) Slice<T>

Shared Function Slice<T>(aSlice As T(), aStart As Int32?, aEnd As Int32?) As Slice<T>

class method Slice<T>(aSlice: array of T; aStart: nullable Int32; aEnd: nullable Int32; aCap: Int32): Slice<T>

static Slice<T> Slice<T>(T[] aSlice, Int32? aStart, Int32? aEnd, Int32 aCap)

static func Slice<T>(_ aSlice: T..., _ aStart: Int32!, _ aEnd: Int32!, _ aCap: Int32) -> Slice<T>

func Slice<T>(aSlice []T, aStart Int32, aEnd Int32, aCap Int32) Slice<T>

Shared Function Slice<T>(aSlice As T(), aStart As Int32?, aEnd As Int32?, aCap As Int32) As Slice<T>

class method Slice<T>(aSlice: Slice<T>; aStart: nullable Int32; aEnd: nullable Int32): Slice<T>

static Slice<T> Slice<T>(Slice<T> aSlice, Int32? aStart, Int32? aEnd)

static func Slice<T>(_ aSlice: Slice<T>, _ aStart: Int32!, _ aEnd: Int32!) -> Slice<T>

func Slice<T>(aSlice Slice<T>, aStart Int32, aEnd Int32) Slice<T>

Shared Function Slice<T>(aSlice As Slice<T>, aStart As Int32?, aEnd As Int32?) As Slice<T>

class method Slice<T>(aSlice: Slice<T>; aStart: nullable Int32; aEnd: nullable Int32; aCap: Int32): Slice<T>

static Slice<T> Slice<T>(Slice<T> aSlice, Int32? aStart, Int32? aEnd, Int32 aCap)

static func Slice<T>(_ aSlice: Slice<T>, _ aStart: Int32!, _ aEnd: Int32!, _ aCap: Int32) -> Slice<T>

func Slice<T>(aSlice Slice<T>, aStart Int32, aEnd Int32, aCap Int32) Slice<T>

Shared Function Slice<T>(aSlice As Slice<T>, aStart As Int32?, aEnd As Int32?, aCap As Int32) As Slice<T>

class method Start(v: Action)

static void Start(Action v)

static func Start(_ v: Action)

// .NET, .NET Standard 2.0
func Start(v Action) 
// Island
func Start(v Action) void

Shared Sub Start(v As Action)

class method TypeAssert<T>(v: Object): tuple of (T, Boolean)

static (T, Boolean) TypeAssert<T>(Object v)

static func TypeAssert<T>(_ v: Object) -> (T, Boolean)

func TypeAssert<T>(v interface{}) tuple of (T, Boolean)

Shared Function TypeAssert<T>(v As Object) As Tuple (Of T, Boolean)

// .NET, .NET Standard 2.0
class method TypeAssertReference<T>(v: Object): tuple of (RemObjects.Elements.System.Memory<T>, Boolean)
// Island
class method TypeAssertReference<T>(v: Object): tuple of (RemObjects.Elements.System.Memory<T>, Boolean)

// .NET, .NET Standard 2.0
static (RemObjects.Elements.System.Memory<T>, Boolean) TypeAssertReference<T>(Object v)
// Island
static (RemObjects.Elements.System.Memory<T>, Boolean) TypeAssertReference<T>(Object v)

// .NET, .NET Standard 2.0
static func TypeAssertReference<T>(_ v: Object) -> (RemObjects.Elements.System.Memory<T>, Boolean)
// Island
static func TypeAssertReference<T>(_ v: Object) -> (RemObjects.Elements.System.Memory<T>, Boolean)

// .NET, .NET Standard 2.0
func TypeAssertReference<T>(v interface{}) tuple of (RemObjects.Elements.System.Memory<T>, Boolean)
// Island
func TypeAssertReference<T>(v interface{}) tuple of (RemObjects.Elements.System.Memory<T>, Boolean)

// .NET, .NET Standard 2.0
Shared Function TypeAssertReference<T>(v As Object) As Tuple (Of RemObjects.Elements.System.Memory<T>, Boolean)
// Island
Shared Function TypeAssertReference<T>(v As Object) As Tuple (Of RemObjects.Elements.System.Memory<T>, Boolean)