Jule is an open source programming language created in 2021 by Mertcan Davulcu.
git clone https://github.com/julelang/jule| #547on PLDB | 3Years Old |
Jule is the simple, efficient, statically typed and compiled system programming language.
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)
}fn main() {
outln("Hello World")
}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())
}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| Feature | Supported | Token | Example |
|---|---|---|---|
| File Imports | ✓ | use | use std::fs
use std::sys::{self, open, O_RDWR}
use std::math::* |
| 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")
} |
|
| hasReservedWords | ✓ | ||
| 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'] |
|
| hasSelfOrThisWord | ✓ | self |
|
| 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 | ✓ | 0b0001010101 |
|
| Decimals | ✓ | 12345 |
|
| Octals | ✓ | 0455 |
|
| Hexadecimals | ✓ | 0xDFF90 |
|
| 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` |
| Lispy | X | ||
| 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 |