CLR mapping

E# is a first-class CLR citizen: every construct lowers to ordinary metadata and IL, indistinguishable from what C# emits. This is that lowering, end to end. The IL column is what the primary backend emits; the C# column is the equivalent a reader (or the secondary transpiler) would write.

Types & members

E#	C#	IL
namespace Foo	public static partial class Foo	static class holding namespace methods
data Point { x: int, y: int }	struct Point or sealed class Point (compiler’s choice)	value type or reference type — value-semantic contract preserved either way
pub data Point { ... }	public variant of the above	public variant
readonly data R { ... }	readonly struct R (+ generated equality)	ValueType + [IsReadOnly]
let field: T	readonly T field	initonly field
expr with { f: v }	IIFE copy + assign	ldobj + stfld
ref data Config { ... }	sealed partial class Config	sealed class
open ref data Foo	class Foo (not sealed)	inheritable class
abstract ref data Foo	abstract class Foo	abstract class
choice Error { ... }	tag enum + partial struct with factories	ValueType + tag enum
ref choice Expr { ... }	abstract base + sealed subclass per case	abstract class + sealed subclasses
enum Direction { ... }	public enum Direction	System.Enum (int32)
interface IDrawable { ... }	public interface IDrawable	interface
delegate func BinOp(...)	delegate int BinOp(int, int)	sealed MulticastDelegate subclass
static func Foo { ... }	public static partial class Foo (sibling to the namespace class)	static class: const/static fields + static methods
T? (value type)	Nullable<T>	System.Nullable<T>
T? (ref type)	T? annotation	same reference type
nil (value context)	default(Nullable<T>)	initobj Nullable<T>
[Serializable]	[Serializable]	CLR custom attribute

Methods, inheritance & constructors

E#	C#	IL
func add(a: int, b: int) -> int	public static int add(int a, int b)	call (direct)
func describe(p: Point) -> string	instance method on Point	instance call
func move(p: *Point, dx: int)	static void move(ref Point p, int dx)	managed pointer &
func f() -> T = expr	T f() { return expr; }	expression-body desugar
virtual func name(...)	public virtual T name(...)	Virtual + NewSlot
abstract func name(...)	public abstract T name(...)	Virtual + NewSlot + Abstract, no body
: func name(...) (override of virtual)	public override T name(...)	Virtual (ReuseSlot) — same vtable slot
: func name(...) (fulfill of abstract)	public override T name(...)	Virtual (ReuseSlot)
init(args) { body } on ref data	parameterized constructor	.ctor with args
init(args) : base(b)	: base(b) chain	.ctor with explicit call BaseType::.ctor
init(...) on data	—	ES3012: use composite literal / factory
returns T clause	default return type for nested funcs missing -> T	—

Control flow, errors & match

E#	C#	IL
let x = 42	var x = 42; (immutable by E#)	stloc
var x = 0	var x = 0;	stloc
a ? b : c	a ? b : c	conditional branch
x ?? y	x ?? y	null check + branch
x?.Member	x?.Member	null-conditional access
match x { .a { } }	switch (x.Tag)	IL switch (jump table)
match x { .a(v1, v2) { } }	multi-field destructure	field loads after tag check
match x { .a(v) { } } (ref choice)	is type pattern	isinst + field extraction
let x = f()?	unwrap with early error return	conditional branch
let x = f() else { return }	null guard, early return	brfalse
defer { f() }	try { ... } finally { f(); }	exception handler block
"hello {name}"	$"hello {name}"	String.Concat (value types boxed)

Pointers, delegates & literals

E#	C#	IL
&funcName	delegate*<...>	ldftn + calli
&varName	ref varName	ldloca / ldarga / ldflda
var p = &x	ref var p = ref x	ByReferenceType local
&(int, int -> int)	delegate*<int, int, int>	FunctionPointerType
x: *T param	ref T	managed pointer
readonly *T param	in T	ByReferenceType + [In]
out x: T param	out T	[Out] T&
[1, 2, 3]	new List<int> { 1, 2, 3 }	List<T> + Add
(a, b)	new ValueTuple<T1, T2>(a, b)	System.ValueTuple
let (a, b) = expr	temp + .Item1/.Item2	field extraction
derive equality	Equals / GetHashCode / == / !=	generated methods
derive debug	ToString()	generated method

Concurrency & interop

E#	C#	IL
await expr	await expr	IAsyncStateMachine struct
spawn { ... }	Job.Spawn(_ => { ... })	Task.Run
chan<T>(n)	new Chan<T>(n)	Channel.CreateBounded<T>(n)
task func name() -> T	static Job<T> name() → Job.Spawn<T>(__inner)	Esharp.Stdlib.Job<T>
List<int>()	new List<int>()	newobj List1::.ctor`
Dictionary<string, T>	Dictionary<string, T>	GenericInstanceType
using static "System.Math"	using static System.Math;	static type import
data Foo(x: int)	positional sugar	fields + positional construction

Implicit BCL namespace search

These namespaces are searched for an unqualified type name as the last resolution tier (after exact names and explicit usings — see Names & resolution), so Dictionary<…>, StringBuilder, ObservableCollection<T>, and FormatException resolve with no using:

System                                System.Linq
System.Collections.Generic            System.Diagnostics
System.Collections.ObjectModel        System.Timers
System.Collections.Specialized        System.ComponentModel
System.Text                           System.Threading
System.Text.Json                      System.Threading.Tasks
System.Text.Json.Serialization        System.Threading.Channels
System.IO

Disable the whole tier with <ImplicitUsings>disable</ImplicitUsings>, after which only explicitly imported namespaces resolve.