Jule - Programming language

home edit

Jule is an open source programming language created in 2021 by Mertcan Davulcu.

#719on PLDB

3Years Old

Download source code:

git clone https://github.com/julelang/jule

Homepage · Source Code · Docs

Jule is the simple, efficient, statically typed and compiled system programming language.

Tags: programming language, lisp
Jule is developed on GitHub and has 127 stars
Early development of Jule happened in https://github.com/julelang
C and C++ and Rust and Go influenced the design of Jule
Jule is written in YAML, Markdown, Bourne shell, Dockerfile
jule.dev was registered in 2022

Example from the web:

 fn quicksort(mut s: []int) {
     if s.len <= 1 {
         ret
     }
 
     let mut i = -1
     let last = s[s.len-1]
     for j in s {
         let mut x = &s[j]
         if (unsafe{ *x <= last }) {
             i++
             let mut y = &s[i]
             unsafe { *x, *y = *y, *x }
         }
     }
 
     quicksort(s[:i])
     quicksort(s[i+1:])
 }
 
 fn main() {
     let mut my_slice = [1, 9, -2, 25, -24, 4623, 0, -1, 0xFD2]
     outln(my_slice)
     quicksort(my_slice)
     outln(my_slice)
 }

Example from the web:

fn main() {
    outln("Hello World")
}

Example from the web:

use std::math::{PI}

trait Shape {
    fn area(self): f32
}

struct Rectangle {
    width: int
    height: int
}

impl Shape for Rectangle {
    fn area(self): f32 {
        ret self.width * self.height
    }
}

struct Circle {
    r: f32
}

impl Shape for Circle {
    fn area(self): f32 {
        ret PI * self.r * self.r
    }
}

fn main() {
    let rect: Shape = Rectangle{90, 5}
    let circ: Shape = Circle{90.5}
    outln(rect.area())
    outln(circ.area())
}

Jule Keywords

fn pub struct enum unsafe const let mut self match if else for in impl trait break continue goto cpp i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 str int uint type any true false bool ret fall nil uintptr co

Language features

Feature	Supported	Example	Token
hasReservedWords	✓
hasSelfOrThisWord	✓	self
File Imports	✓	use std::fs use std::sys::{self, open, O_RDWR} use std::math::*	use
Multiline Strings	✓	`Multiline strings is available in Jule with raw strings`
hasStringConcatOperator	✓	+
Disk Output	✓	use std::fs::{open, O_WRONLY} fn main() { let (mut f, _) = open("myfile.txt", O_WRONLY, 0) let bytes = ([]byte)("Text to write") f.write(bytes) f.close() }
Static Typing	✓
Increment and decrement operators	✓	++ --
Conditionals	✓	if BOOLEAN_EXPRESSION { outln(""Condition is true) }
Manual Memory Management	✓	use std::mem::c::{malloc, free} fn main() { let mut ptr = malloc(8) free(ptr) ptr = nil }
Type Casting	✓	let x = (int)(3.14)
hasArraySlicingSyntax	✓	sliceable_expression[start_index:to_index]
Duck Typing	✓	fn lock_object[T](obj: T) { obj.lock() }
Switch Statements	✓	match X { \| Y: outln("X is Y") \| Z: outln("X is Z") \| A \| B \| C: outln("X is A, B, or C") \|: outln("X is not Y, Z, A, B and C") }
hasMemberVariables	✓
Access Modifiers	✓	pub
Type Annotations	✓	let x: f64 = 89
Assignment	✓	let mut x = 0 x = 20	=
Threads	✓	fn my_thread() { outln("Hello from thread") } fn main() { co my_thread() }
Statements	✓
hasStatementTerminatorCharacter	✓	;
hasBoundedCheckedArrays	✓	let arr: [5]byte = ['a', 'b', 'c', 'd', 'e']
hasRequiredMainFunction	✓	fn main() {}
Gotos	✓	goto a_label
Labels	✓	a_label:
hasDynamicSizedArrays	✓	let mut a_slice = [1, 2, 3, 4, 5, 6] a_slice = append(a_slice, 7, 8, 9, 10)
hasIfElses	✓
hasIfs	✓
Doc comments	✓	// Documentation comment for a_function fn a_function() {}
While Loops	✓	for my_condition { // ... }
hasForLoops	✓	// Jule has for loops with while-next iterations let mut i = 0 for i < 10; i++ { // ... }
hasForEachLoops	✓	for x, y in my_enumerable { // ... }
canReadCommandLineArgs	✓	use std::os::{ARGS} fn main() { outln(ARGS) }
Case Sensitivity	✓
hasFnArguments	✓
Dependent types	✓	int uint uintptr
Unary Operators	✓	* & - + ^ !
Variadic Functions	✓	fn average(x: ...f64): f64 { // ... }
Assert Statements	✓	use std::debug use std::debug::assert::{assert} fn main() { std::debug::ENABLE = true let x = 200 assert(x < 200) }
Bitwise Operators	✓	& \| ^ << >>
Directives	✓
hasValueReturnedFunctions	✓	fn get_pi(): f64 { ret 3.14159265359 }
hasGlobalScope	✓
Scientific Notation	✓	1E2 .12345E+6 1.e+0 0x15e-2 0x2.p10 0X.8p-0 0x1.Fp+0 0x1fffp-16 0x1p-2
hasVoidFunctions	✓	fn a_void_function() { // ... }
Binary Literals	✓	85
Decimals	✓	12345
Octals	✓	455
Hexadecimals	✓	917392
Structs	✓	struct Employee { first_name: str last_name: str salary: f32 }
Integers	✓	12345 0b0001010101 0455 0xDFF90
Floats	✓	3.14 32.60 032.60 3. 0.3 1E2 .12345E+6 1.e+0 0x1p-2 0x2.p10 0x1.Fp+0 0X.8p-0 0x1fffp-16 0x15e-2
Enums	✓	enum ExitCode { Success = 0, Failure = 1 }
hasContinue	✓	continue continue a_label
hasBreak	✓	break break a_label
Anonymous Functions	✓	let anonymous = fn() { outln("Anonymous Function") } anonymous()
Null	✓	nil
Constants	✓	const PI = 3.14159265359
Booleans	✓	true false	true false
Generics	✓	fn generic_function[T](s: []T) { // ... }
Traits	✓	trait Person { fn get_full_name(self): str fn get_age(self): byte }
Maps	✓	let my_map: [int:str] = { 0: "Key 0", 1: "Key 1", 2: "Key 2", }
Methods	✓	impl MyStruct { fn my_method(self) {} }
Functions	✓	fn a_function() { // ... }
Pointers	✓	let ptr: *int = nil
Print() Debugging	✓		outln
MultiLine Comments	✓	/* A multi line comment */	/* */
Comments	✓	// A comment /* A comment */
Line Comments	✓	// A comment	//
Strings	✓	"Jule String Literal" `Jule Raw String Literal`	"
Regular Expression Syntax Sugar	X
hasTryCatch	X
Async Await	X
canUseQuestionMarksAsPartOfIdentifier	X
Ternary operators	X
hasUserDefinedOperators	X
Operator Overloading	X
Polymorphism	X
Garbage Collection	X
hasMethodOverloading	X
Function Overloading	X
Semantic Indentation	X