Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/ogshawnlee/coral-lang
Simple and aesthetic programming language built with C++ that intends to turn programming a joyful experience. Currently transpiled to Python as I don't know how to compile to a lower level. Pretty much the same as my previous language Pino, might merge into it.
https://github.com/ogshawnlee/coral-lang
programming-language
Last synced: about 2 months ago
JSON representation
Simple and aesthetic programming language built with C++ that intends to turn programming a joyful experience. Currently transpiled to Python as I don't know how to compile to a lower level. Pretty much the same as my previous language Pino, might merge into it.
- Host: GitHub
- URL: https://github.com/ogshawnlee/coral-lang
- Owner: OGShawnLee
- Created: 2024-03-26T14:57:57.000Z (10 months ago)
- Default Branch: main
- Last Pushed: 2024-05-14T16:08:28.000Z (8 months ago)
- Last Synced: 2024-05-31T15:34:08.941Z (7 months ago)
- Topics: programming-language
- Language: C++
- Homepage:
- Size: 279 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
## Variables and Constants
```
var is_married = false
val name = "Shawn"
val last_name = "Lee"
val full_name = "#name #last_name" # String Injection
val country = "China"
var children = 0
var budget = 0.75
```
## Arrays
```
var collection = []int # Empty Array
# Optional Commas
collection = []int {
len: 12
init: it * 12 # len must be declared if init is present
}
# mapping
val string = []str {
len: collection:len
init: "#it: String"
}
val matrix = [][]int {
len: 9
init: []int { len: 9, init: it + 10 }
}
```
## Conditional
### If and Else Statements
```
val is_single = true
val has_self_love = true
val name = "Shawn"
if is_single {
println("#name is still single")
}
if is_single {
println("#name is still single")
} else {
println("#name got a girlfriend!")
}
if is_single {
println("#name is still single")
} else if has_self_love {
println("#name got a girlfriend and has achieved peak happiness!")
} else {
println("#name got a girlfriend!")
}
val age = 4
if age < 0 {
println("Huh?")
} else if age < 18 {
println("Get away you kiddo!")
} else if age < 21 {
println("Almost there!")
} else {
println("You can drink")
}
```
### Match
```
val name = "Shawn Lee"
match name {
# Optional Commas
when "Alexander" "Shawn" "Shawn Lee" {
println("Best name there is")
}
when
"Felipe"
"Hugo"
"Alberto"
"Roberto"
{
println("What is that goofy name?")
}
else {
println("OK, I guess...")
}
}
```
## Loop
```
for {
println("This will run forever!")
}
for 12 {
println("This will run 12 times")
}
for i in 12 {
println("This has run for the #i time a total of 12 times")
}
val int_arr = []int { len: 3, init: it + 1 }
for integer in int_arr {
println(integer)
}
```
## Functions
```
fn print {
println("This fn has no parameters")
}
fn greet(name str, planet str) {
return "Hello, #name! You live on planet #planet!"
}
# Optional Commas
fn get_message(
name str
planet = "Earth" # Default Value
is_married = false
) {
if is_married {
return "#name lives in planet #planet and is married"
} else {
return "#name lives in planet #planet and is not married"
}
}
# Optinal Commas
get_message(
"Shawn Lee"
"Mars"
false
)
```
### Lambdas (Anonymous Functions)
```
fn {
println("This is a lambda with no parameters")
}
val greet = fn (name str) {
println("Hello, #name!")
}
```
### Functional Programming
```
fn fold(
arr []int
initial int
fun fn(int, int)
) {
var acc = initial
for num in arr {
acc += fun(num, acc)
}
return acc
}
fn map(arr []int, fun fn(int)) {
return []int {
len: arr:len
init: fun(arr:at(it))
}
}
fn call(fun fn) {
fun()
}
val arr_int = []int { len: 6, init: it * 3 }
val arr_big = map(arr_int, fn (num int) {
return num * 10
})
val total = fold(arr_big, 0, fn (num int, acc int) {
return acc + num
})
call(fn {
println("Hello!")
})
```
## Enum and Struct
```
# Optional Commas
enum Hair {
BALD
VERY_SHORT
SHORT
MEDIUM
LONG
VERY_LONG
# Enum Method
fn get_hair(len_cm float) {
if len_cm < 1 {
return BALD
} else if len_cm <= 2.5 {
return VERY_SHORT
} else if len_cm <= 5 {
return SHORT
} else if len_cm <= 7 {
return MEDIUM
} else if len_cm <= 10 {
return LONG
} else {
return VERY_LONG
}
}
}
# Optional Commas
struct Person {
name str
country str
planet = "Earth" # Default Value
hair Hair
fn greet {
println("Hello, #name!")
}
# Struct Method
fn move(nation str) {
country = nation
println("#name has moved to #nation")
}
}
# Optional Commas
var character = Person {
name: "Shawn Lee"
country: "China"
hair: Hair:MEDIUM # Enum Accessing (might change in favour of double colon operator)
}
# Property Accessing (might change in favour of dot operator)
println(character:name, character:country)
var character = Person {
name: "Julia Lee",
country: "France",
hair: Hair:get_hair(15.75),
}
character:greet()
println(character)
```
## Block Expression
```
val name = str {
val name = readln("Enter a name")
match name {
when "Shawn Lee" "Shawn" "Alexander" "Lenore" {
println("#name is an awesome name!")
}
else {
println("#name is a good name")
}
}
give name
}
val num = int {
var num = readln("Enter an integer")
if num > 5 {
println("Integer is too large!")
println("Reducing to 5")
num = 5
}
give num
}
val multiply = block fn(int) {
val multiplier = int(
readln("Enter a multiplier")
)
give fn (amount int) {
return amount * multiplier
}
}
val collection = []int {
len: int {
var len = int(
readln("What is the length of the array?")
)
if len > 30 {
println("Too large! Reducing to 30!")
len = 30
}
give len
}
init: readln("Enter an integer")
}
```