Jule Manual

Appearance

std/jule/ast ​

Index ​

Variables
fn Unparen(mut e: &Expr): &Expr
struct AST
struct Node
struct Directive
struct ChanType
struct SliceType
struct ArrayType
    fn IsAutoSized(*self): bool
struct MapType
struct RetType
struct Expr
struct RangeExpr
struct UseExpr
struct TupleExpr
struct LitExpr
struct UnsafeExpr
struct NameExpr
    fn IsSelf(*self): bool
struct UnaryExpr
    fn IsUnsafePtr(*self): bool
struct VariadicExpr
struct TypeAssertionExpr
struct NamespaceExpr
struct SelectorExpr
struct BinaryExpr
struct CallExpr
    fn Unhandled(*self): bool
struct TypedBraceLit
struct BraceLit
    fn IsEmpty(*self): bool
struct KeyValueExpr
struct SliceExpr
    fn IsEmpty(*self): bool
struct IndexExpr
struct SlicingExpr
struct ConstraintMask
struct Constraint
struct Generic
struct Label
struct Goto
struct Fall
struct AssignLeft
struct Assign
struct Stmt
struct ScopeTree
struct ChanSend
struct Param
    fn IsSelf(*self): bool
    fn IsSmartptr(*self): bool
    fn IsRefptr(*self): bool
struct Func
    fn IsAnon(*self): bool
    fn IsShort(*self): bool
    fn IsDecl(*self): bool
struct Var
struct Ret
struct Iter
    fn IsInfinite(*self): bool
struct WhileKind
    fn IsWhileNext(*self): bool
struct RangeKind
struct Break
struct Continue
struct If
struct Else
struct Conditional
struct TypeAlias
struct Case
struct Match
struct Select
struct Use
struct EnumItem
    fn IsAutoExpr(*self): bool
struct Enum
    fn IsDefaultTyped(*self): bool
struct TypeEnumItem
struct TypeEnum
struct Field
struct Struct
struct Trait
struct Impl
    fn IsTraitImpl(*self): bool
    fn IsStructImpl(*self): bool
enum NodeData: type
enum ExprData: type
enum StmtData: type
enum IterKind: type

Variables ​

jule
const (
	SEND = 1 << iota
	RECV
)

Channel directions.

jule
let mut Ignored = new(ScopeTree)   // Exception is ignored, like foo()!
let mut Forwarded = new(ScopeTree) // Exception is forwarded, like foo()?

Special exceptional handler scopes.

Unparen ​

jule
fn Unparen(mut e: &Expr): &Expr

Returns the expression with any enclosing parentheses removed.

AST ​

jule
struct AST {
	File:          &token::FileSet
	TopDirectives: []&Directive
	UseDecls:      []&Use
	Nodes:         []Node
}

Abstract syntax tree.

Node ​

jule
struct Node {
	Token: &token::Token
	Data:  NodeData
}

AST Node.

Directive ​

jule
struct Directive {
	Tag:  &token::Token
	Args: []&token::Token
}

Directive.

ChanType ​

jule
struct ChanType {
	Arrow: &token::Token // Token of arrow.
	Dir:   int           // Direction.
	Value: &Expr         // Value type.
}

Channel type.

SliceType ​

jule
struct SliceType {
	Value: &Expr // Value type.
}

Slice type.

ArrayType ​

jule
struct ArrayType {
	Value: &Expr // Value type.
	Size:  &Expr
}

Array type. Size expression is nil for auto-sized array.

IsAutoSized ​

jule
fn IsAutoSized(*self): bool

Reports whether array is auto-sized.

MapType ​

jule
struct MapType {
	Key:   &Expr
	Value: &Expr
}

Map type.

RetType ​

jule
struct RetType {
	Type:  &Expr
	Names: []&token::Token
}

Return type. Field are nil for the void type.

Expr ​

jule
struct Expr {
	Token: &token::Token
	End:   &token::Token
	Data:  ExprData
}

Expression.

RangeExpr ​

jule
struct RangeExpr {
	X: &Expr // Expression.
}

Range expression represents an expression between parentheses.

UseExpr ​

jule
struct UseExpr {
	Token: &token::Token
	X:     &Expr // Expression.
}

Use expression.

TupleExpr ​

jule
struct TupleExpr {
	X: []&Expr // Expressions.
}

Tuple expression.

LitExpr ​

jule
struct LitExpr {
	Token: &token::Token
	Value: str
}

Literal expression.

UnsafeExpr ​

jule
struct UnsafeExpr {
	Token: &token::Token // Token of the unsafe keyword.
	X:     &Expr         // Expression.
}

Unsafe expression.

NameExpr ​

jule
struct NameExpr {
	Token: &token::Token // Token of identifier.
	Name:  str           // The name.
	Bind:  bool          // It is in the bind namespace.
}

Identifier expression.

IsSelf ​

jule
fn IsSelf(*self): bool

Reports whether identifier is self keyword.

UnaryExpr ​

jule
struct UnaryExpr {
	Op: &token::Token // Token of the operator.
	X:  &Expr         // Expression.
}

Unary expression. For the unsafe pointer (*unsafe) type, Op is star and Expr is nil.

IsUnsafePtr ​

jule
fn IsUnsafePtr(*self): bool

Reports whether the unary expression is the unsafe pointer type declaration.

VariadicExpr ​

jule
struct VariadicExpr {
	Token: &token::Token
	X:     &Expr // Expression to variadic.
}

Variadiced expression.

TypeAssertionExpr ​

jule
struct TypeAssertionExpr {
	Type: &Expr
	X:    &Expr // Expression to assert.
}

Type assertion expression.

NamespaceExpr ​

jule
struct NamespaceExpr {
	Namespace: &token::Token // Tokens of the namespace identifier.
	Name:      &token::Token // Token of the selected identifier.
}

Namespace identifier selection expression.

SelectorExpr ​

jule
struct SelectorExpr {
	X:    &Expr         // Memory selection based on.
	Name: &token::Token // Token of the selected identifier.
}

Identifier selector expression.

BinaryExpr ​

jule
struct BinaryExpr {
	X:  &Expr         // Left operand.
	Y:  &Expr         // Right operand.
	Op: &token::Token // Operator.
}

Binary operation.

CallExpr ​

jule
struct CallExpr {
	Token:     &token::Token
	Func:      &Expr      // Function expression.
	Args:      []&Expr    // Function arguments, or nil.
	Exception: &ScopeTree // Exception handling scope, or nil.
	IsCo:      bool       // Whether this is the concurrent call.
}

Function call expression kind.

Unhandled ​

jule
fn Unhandled(*self): bool

Reports whether exception is not handled.

TypedBraceLit ​

jule
struct TypedBraceLit {
	Type: &Expr
	Lit:  &BraceLit
}

Typed brace instantiating expression.

BraceLit ​

jule
struct BraceLit {
	Token: &token::Token
	End:   &token::Token
	X:     []&Expr // Expression.
}

Anonymous brace instantiating expression.

IsEmpty ​

jule
fn IsEmpty(*self): bool

Reports whether literal is empty ( {} ).

KeyValueExpr ​

jule
struct KeyValueExpr {
	Key:   &Expr
	Value: &Expr
	Colon: &token::Token
}

Key-value expression.

SliceExpr ​

jule
struct SliceExpr {
	Token: &token::Token
	End:   &token::Token
	X:     []&Expr // Elements.
}

Slice initiating expression. Also represents array initiating expression. For array-fill initiating expression; len(X)=2 and the second element is a VariadicExpr with nil expression.

IsEmpty ​

jule
fn IsEmpty(*self): bool

Reports whether slice is empty.

IndexExpr ​

jule
struct IndexExpr {
	Token: &token::Token
	End:   &token::Token
	X:     &Expr // Value expression to indexing.
	Index: &Expr // Index value expression.
}

Index expression.

SlicingExpr ​

jule
struct SlicingExpr {
	Token: &token::Token
	End:   &token::Token
	X:     &Expr // Value expression to slicing.
	Low:   &Expr // Low index value expression, or nil.
	High:  &Expr // High index value expression, or nil.
	Max:   &Expr // Max index value expression, or nil.
}

Slicing expression.

ConstraintMask ​

jule
struct ConstraintMask {
	Deep: bool // Whether the operator ~ used.
	Type: &Expr
}

Single mask value for a constraint.

Constraint ​

jule
struct Constraint {
	Mask: []ConstraintMask
}

Constraint.

Generic ​

jule
struct Generic {
	Token:      &token::Token
	Name:       str
	Constraint: &Constraint
}

Generic type declaration.

Label ​

jule
struct Label {
	Token: &token::Token
	Name:  str
}

Label statement.

Goto ​

jule
struct Goto {
	Token: &token::Token
	Label: &token::Token
}

Goto statement.

Fall ​

jule
struct Fall {
	Token: &token::Token
}

Fall statement.

AssignLeft ​

jule
struct AssignLeft {
	Token:     &token::Token
	Mutable:   bool
	Reference: bool
	Name:      str
	X:         &Expr // Expression.
}

Left expression of assign statement.

Assign ​

jule
struct Assign {
	Decl: bool          // Whether the assignment may declare variable.
	Op:   &token::Token // Setter operator.
	X:    []&AssignLeft // Lvalue expressions.
	Y:    &Expr         // Expression to be assigned.
}

Assign statement.

Stmt ​

jule
struct Stmt {
	Token: &token::Token
	End:   &token::Token
	Data:  StmtData
}

Statement.

ScopeTree ​

jule
struct ScopeTree {
	Parent:   &ScopeTree // Nil if scope is root.
	Unsafe:   bool
	Deferred: bool
	Stmts:    []Stmt
	End:      &token::Token
}

Scope tree.

ChanSend ​

jule
struct ChanSend {
	Chan: &Expr
	X:    &Expr // Expression.
}

Channel send data statement.

Param ​

jule
struct Param {
	Token:     &token::Token
	Mutable:   bool
	Variadic:  bool
	Reference: bool
	Type:      &Expr
	Name:      str
}

Parameter.

IsSelf ​

jule
fn IsSelf(*self): bool

Reports whether parameter is self (receiver) parameter.

IsSmartptr ​

jule
fn IsSmartptr(*self): bool

Reports whether self (receiver) parameter is smart pointer.

IsRefptr ​

jule
fn IsRefptr(*self): bool

Reports whether self (receiver) parameter is reference pointer.

Func ​

jule
struct Func {
	Token:       &token::Token
	Global:      bool
	Unsafe:      bool
	Public:      bool
	Bind:        bool
	Short:       bool // Whether this function is an anonymous function, defined by short literal.
	Static:      bool
	Exceptional: bool
	Name:        str
	Directives:  []&Directive
	Scope:       &ScopeTree
	Generics:    []&Generic
	Result:      &RetType
	Params:      []&Param
}

Function declaration. Also represents anonymous function expression and function type declarations.. For short function literals, Scope will be deferred to represent one-line body.

IsAnon ​

jule
fn IsAnon(*self): bool

Reports whether the function is anonymous.

IsShort ​

jule
fn IsShort(*self): bool

Reports whether the function is anonymous and defined in short way.

IsDecl ​

jule
fn IsDecl(*self): bool

Reports whether the function is type declaration.

Var ​

jule
struct Var {
	Scope:      &ScopeTree // nil for global scopes
	Token:      &token::Token
	Op:         &token::Token // Expression assign operator token.
	Name:       str
	Bind:       bool
	Public:     bool
	Mutable:    bool
	Const:      bool
	Static:     bool
	Reference:  bool
	Directives: []&Directive
	Type:       &Expr // Type declaration, or nil if type inferred.
	X:          &Expr // Initializer expression, or nil.

	// See developer reference (12).
	GroupIndex: int    // Index of variable in the group, if variable is grouped.
	Group:      []&Var // All variables of group in define order, if variable is grouped.
}

Variable declaration.

Ret ​

jule
struct Ret {
	Token: &token::Token
	X:     &Expr // Expression.
}

Return statement.

Iter ​

jule
struct Iter {
	Comptime: bool
	Token:    &token::Token
	Kind:     IterKind
	Scope:    &ScopeTree
}

Iteration.

IsInfinite ​

jule
fn IsInfinite(*self): bool

Reports whether iteration is infinite.

WhileKind ​

jule
struct WhileKind {
	X:         &Expr    // Condition expression.
	Next:      StmtData // Nil if kind is while-next iteration.
	NextToken: &token::Token
}

While iteration kind.

IsWhileNext ​

jule
fn IsWhileNext(*self): bool

Reports whether kind is while-next iteration.

RangeKind ​

jule
struct RangeKind {
	InToken: &token::Token // Token of "in" keyword
	X:       &Expr         // Range expression.
	A:       &Var          // First key of range.
	B:       &Var          // Second key of range.
}

Range iteration kind.

Break ​

jule
struct Break {
	Token: &token::Token
	Label: &token::Token // Label to break, or nil.
}

Break statement.

Continue ​

jule
struct Continue {
	Token: &token::Token
	Label: &token::Token // Label to continue, or nil.
}

Continue statement.

If ​

jule
struct If {
	Token: &token::Token
	Scope: &ScopeTree
	X:     &Expr
}

If condition.

Else ​

jule
struct Else {
	Token: &token::Token
	Scope: &ScopeTree
}

Else condition.

Conditional ​

jule
struct Conditional {
	Tail:    []&If // First one is the head condition.
	Default: &Else
}

Condition chain.

TypeAlias ​

jule
struct TypeAlias {
	Scope:    &ScopeTree
	Public:   bool
	Bind:     bool
	Token:    &token::Token
	Name:     str
	Strict:   bool
	Type:     &Expr
	Generics: []&Generic
}

Type alias declaration.

Case ​

jule
struct Case {
	Token: &token::Token
	Scope: &ScopeTree

	// Holds expression.
	// Expressions holds *Type if If type matching.
	X: []&Expr
}

Case of match-case.

Match ​

jule
struct Match {
	Comptime: bool
	Token:    &token::Token
	End:      &token::Token
	Type:     bool    // Type matching.
	X:        &Expr   // Expression to match.
	Cases:    []&Case // First one is the head case.
	Default:  &Else
}

Match statement.

Select ​

jule
struct Select {
	Token:   &token::Token
	End:     &token::Token
	Cases:   []&Case // First one is the head condition.
	Default: &Else
}

Select statement.

Use ​

jule
struct Use {
	Token: &token::Token
	Path:  &token::Token // Use declaration path token.
	Alias: &token::Token // Custom alias. Nil if not given.
	Bind:  bool          // Bind use declaration.
}

Use declaration statement.

EnumItem ​

jule
struct EnumItem {
	Token: &token::Token
	Name:  str
	X:     &Expr // Nil for auto expression.
}

Enum item.

IsAutoExpr ​

jule
fn IsAutoExpr(*self): bool

Reports whether item has auto expression.

Enum ​

jule
struct Enum {
	Token:  &token::Token
	Public: bool
	Name:   str
	Type:   &Expr
	Items:  []&EnumItem
	End:    &token::Token
}

Enum declaration.

IsDefaultTyped ​

jule
fn IsDefaultTyped(*self): bool

Reports whether enum's type is default.

TypeEnumItem ​

jule
struct TypeEnumItem {
	Token: &token::Token
	Type:  &Expr
}

TypeEnum item.

TypeEnum ​

jule
struct TypeEnum {
	Token:  &token::Token
	Public: bool
	Name:   str
	Items:  []&TypeEnumItem
	End:    &token::Token
}

TypeEnum declaration.

Field ​

jule
struct Field {
	Token:   &token::Token
	Public:  bool
	Mutable: bool // Interior mutability.
	Name:    str
	Type:    &Expr
	Tag:     &token::Token // Nil if not given.
}

Field declaration.

Struct ​

jule
struct Struct {
	Token:      &token::Token
	End:        &token::Token
	Name:       str
	Fields:     []&Field
	Public:     bool
	Bind:       bool
	Directives: []&Directive
	Generics:   []&Generic
}

Structure declaration.

Trait ​

jule
struct Trait {
	// Trait declaration.
	Token:    &token::Token
	End:      &token::Token
	Name:     str
	Public:   bool
	Inherits: []&Expr
	Methods:  []&Func
}

Impl ​

jule
struct Impl {
	End: &token::Token

	// This token available for these cases:
	//	- Implementation trait to structure, represents trait's type.
	Base: &Expr

	// This token available for these cases:
	//	- Implementation trait to structure, represents structure's type.
	//	- Implementation to structure, represents structure's type.
	Dest: &Expr

	// Given methods to implement.
	Methods: []&Func
}

Implementation.

IsTraitImpl ​

jule
fn IsTraitImpl(*self): bool

Reports whether implementation type is trait to structure.

IsStructImpl ​

jule
fn IsStructImpl(*self): bool

Reports whether implementation type is append to destination structure.

NodeData ​

jule
enum NodeData: type {
	&Enum,
	&TypeEnum,
	&Func,
	&Struct,
	&Trait,
	&TypeAlias,
	&Var,
	&Impl,
}

Type of AST Node's data.

ExprData ​

jule
enum ExprData: type {
	&RangeExpr,
	&TupleExpr,
	&LitExpr,
	&NameExpr,
	&UnaryExpr,
	&SelectorExpr,
	&NamespaceExpr,
	&VariadicExpr,
	&CallExpr,
	&TypedBraceLit,
	&BraceLit,
	&SlicingExpr,
	&SliceExpr,
	&BinaryExpr,
	&UnsafeExpr,
	&IndexExpr,
	&Func,
	&KeyValueExpr,
	&ChanSend,
	&TypeAssertionExpr,
	&ChanType,
	&ArrayType,
	&MapType,
	&SliceType,
}

Type of Expr's data.

StmtData ​

jule
enum StmtData: type {
	&Var,
	&Ret,
	&Goto,
	&Break,
	&Continue,
	&Expr,
	&Conditional,
	&Match,
	&Iter,
	&Assign,
	&Fall,
	&Label,
	&ScopeTree,
	&TypeAlias,
	&UseExpr,
	&Select,
}

Type of Stmt's data.

IterKind ​

jule
enum IterKind: type {
	&WhileKind,
	&RangeKind,
}

Type of Iter's kind.