106 lines
1.9 KiB
Plaintext
106 lines
1.9 KiB
Plaintext
|
|
fn main() {
|
|
|
|
# comments are scripting-style
|
|
#{ but can also be
|
|
|
|
}# blocks
|
|
|
|
@annotations are with @-
|
|
|
|
# variable expressions
|
|
var a: I32 = 20
|
|
const b: String = 20
|
|
|
|
there(); can(); be(); multiple(); statements(); per_line();
|
|
|
|
#string interpolation
|
|
const yolo = "I have ${a + b} people in my house"
|
|
|
|
# let expressions ??? not sure if I want this
|
|
let a = 10, b = 20, c = 30 in a + b + c
|
|
|
|
#list literal
|
|
const q = [1,2,3,4]
|
|
|
|
#lambda literal ?? maybe? not sure how this should work
|
|
q.map(|item| { item * 100 })
|
|
|
|
fn yolo(a: MyType, b: YourType): ReturnType<Param1, Param2> {
|
|
if a == 20 {
|
|
return "early"
|
|
}
|
|
var sex = 20
|
|
sex
|
|
}
|
|
|
|
|
|
for {
|
|
# infinite loop
|
|
}
|
|
|
|
#iteration over a variable
|
|
for i <- [1..1000] {
|
|
|
|
} #return type is return type of block
|
|
|
|
#while loop
|
|
for a != 3 || fuckTard() {
|
|
break
|
|
} #return type is return type of block
|
|
|
|
#monadic decomposition
|
|
for {
|
|
a <- maybeInt();
|
|
s <- foo()
|
|
} return {
|
|
a + s
|
|
} #return type is Monad<return type of block>
|
|
|
|
# let statements too!!
|
|
for (a = 20
|
|
b = fuck) {
|
|
a + b
|
|
}
|
|
|
|
|
|
# pattern-matching
|
|
match <expr> {
|
|
Some(a) => {
|
|
|
|
},
|
|
None => {
|
|
|
|
},
|
|
}
|
|
|
|
#syntax is, I guess, for <expr> <brace-block>, where <expr> is a bool, or a <arrow-expr>
|
|
|
|
# type level alises
|
|
typealias <name> = <other type> #maybe thsi should be 'alias'?
|
|
|
|
#what if type A = B meant that you could had to create A's with A(B), but when you used A's the interface was exactly like B's?
|
|
# maybe introduce a 'newtype' keyword for this
|
|
|
|
#declaring types of all stripes
|
|
type MyData = { a: i32, b: String }
|
|
type MyType = MyType
|
|
type Option<a> = None | Some(a)
|
|
type Signal = Absence | SimplePresence(i32) | ComplexPresence {a: i32, b: MyCustomData}
|
|
|
|
#traits
|
|
|
|
trait Bashable { }
|
|
trait Luggable {
|
|
fn lug(self, a: Option<Self>)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
# lambdas
|
|
#
|
|
|x,y| { }() #is probably fine
|
|
const a = |x: Type, y|: RetType { <statementblock> }
|
|
const a: X -> Y -> Z = |x,y| { }
|