Toy project with the following goals in mind:
No tutorials, best practices, design patterns, clean architecture, or fancy frameworks
docker run -it nbittich/adanadocker build -t adana .docker run -it adanacargo install adanaadanacargo build --release./target/x86_64-unknown-linux-musl/release/adanaFirst we start with the traditional hello world:
```python
println("hello world!") # prints hello world ``` In the repl, you could also simply write:
```python
"hello world!" # prints hello world ```
Comments are defined like in python, starting with #.
You can put them after the last statement or before any useful code, for example:
```python
to go to the next line in the repl, press CTRL+x
this will be ignored by the repl
println("hello world!") # this is also ok
```
Semicolons are not needed, if you need multiline statements, you can use a multiline block:
python
fancy_string = multiline {
"this string" +
"is " +
"on several " +
"lines"
}
There are 14 operators & 3 constants:
| operator | description |
|----------------|-----------------|
| + | add |
| - | subtract |
| / | divide |
| * | multiply |
| % | modulo |
| ^ | pow |
| < | less than |
| > | greater than |
| <= | less or equal |
| >= | greater or equal|
| && | and |
| \|\| | or |
| == | equal |
| () | parenthesis |
| π | PI number |
| γ | EULER number |
| τ | TAU number |
```python
5 + 5 # 10 5 + 5.5 # 10.5 5 / 5 # 1 5 / 6 # 0 5 / 6. # 0.8333333333333334 -- we force it to make a float division by adding "." 5 % 6 # 5 -- modulo on int 5 % 4.1 # 0.9000000000000004 modulo on double 5 ^ 5 # 3125 5 * 5 # 25 5 * 5.1 # 25.5 5 * (5+ 1/ (3.1 ^2) * 9) ^3. # 1046.084549281999
```
To define a variable, simply type the name of the variable followed by "=". Variable must always start with a letter and can have numerics or "_" in it. Add and assign(+=), subtract and assign (-=), etc are not supported.
```python
vat = 1.21 # 1.21 subtotal1 = 10000 total = vat * subtotal1 # 12100 subtotal2 = 500 * vat # 605 subtotal1 = subtotal1 + subtotal2 # 10605 ```
There's only one loop, the while loop. Just like in plain old C:
```C count = 0
while(count < 10) { println(count) count = count + 1 } ```
You can break if you match a certain condition:
C
while(count < 10) {
println(count)
count = count + 1
if(count % 3 ==0) {
break
}
}
Same as C:
```C if(age > 12) { println("age > 12") } else if(age <9) { println("age < 9") }else { println("dunno") }
```
There is no type-checking in the language. You can add a string to an array, nothing will stop you!
In some cases though, you might get an error.
Below, is a list of types and how you declare them. You can also define your structure.
| type | examples |
|----------|---------------------------------------------------------------------------------------------------|
| null | null |
| bool | true / false |
| int | 5 |
| double | 12. / 12.2 |
| string | "hello" |
| array | [1,2,"3", true] |
| function | () => {"hello"}
(name) => {"hello" + name}
(n) => {
"hello"} |
| struct | struct {x: 8; y: ()=> {println("hello!")};}
You can define structs. Structs are a way of grouping related variables or functions together.
You can define function variables within a struct, but you cannot update the members of the function from within
the struct (there is no self or this).
The semicolon is required to separate each member, even the latest one.
Example of defining a struct:
```javascript person = struct { name: "hello"; age: 20; }
personservice = struct { sayhi: (person) => { println("hi " + person.name) }; check_age: (person) => { if (person.age < 18) { println("you are too young") } else { println("you are too old") } }; }
personservice.checkage(person)
```
Arrays are declared like in javascript but are "immutable". After declaration, you cannot (yet) push new data in them. to do that, you have to concatenate them with another array using the "+" operator.
```python
arr = [] # declare an empty array arr[0] = "kl" # Err: index out of range arr = arr + ["kl"] # arr now is ["kl"] ``` You can update a value in the array with the syntax above, as long as the array is greater than the index provided, e.g:
```python arr = ["this", "is", "ax", "array", true, 1, 2.3] arr[2] = "an" #fix the typo print(arr[2]) # an
```
To get the length of an array, you can use the built-in function length
```python
arr_len = length(arr) # 7
```
Characters within a string can be accessed & updated just like an array:
```python
s = "this is a strink" s[2] # i length(s) # 16 s[15] = "g" # fix the typo s # this is a string
```
Here are some other examples of what you can do with arrays:
```python count = 9 arr = null
while(count > 0) { arr = [count, arr] count = count -1 }
while(arr != null) { print(arr[0] +",") arr=arr[1] } print("done")
```
The function can be declared inline or as a block. In the case of a function parameter, you either assign the function to a variable or use an anonymous function block.
Parameters cannot be modified within a function. if you want to update something, you have to return it and reassign it.
```python
hello = () => { println("hello, world!") } hello()
helloname = (name) => { println("hello "+name) } helloname("Bachir")
for_each = (arr, consumer) => { count = 0 len = length(arr) while(count < len) { consumer(arr[count]) count = count + 1 } return "" # do not print the count as the repl will print the latest statement }
foreach(["Mohamed", "Hakim", "Sarah", "Yasmine", "Noah", "Sofia", "Sami"], helloname)
(name) => { println("hello "+name) }
)
``` Parameters cannot be modified within a function. if you want to update something, you have to return it and reassign it. Everything that changes within the scope of a function won't have any effect on the outer scope.
Some other examples of what you can do with functions:
```python arr = ["Mohamed", "Hakim", "Sarah", "Yasmine", "Noah", "Sofia", "Sami"]
acc = (arr, v) => {arr + [v]} # arr is immutable, thus you have to reassign it if you call that function
arr = acc(arr, "Malika")
find_first = (arr, predicate) => { len = length(arr) count = 0 while(count < len) { temp = arr[count] if(predicate(temp)) { return temp } count = count + 1 } return null }
find_first(arr, (v) => { v[0] == "S" || v[0] == "s" })
fact = (n) => { if(n>=1) { n * fact(n-1) }else { 1 } } fact(10) ```
You can dynamically load a script in the repl. Assuming you've cloned the repo and you use docker, here's an example of how to do it.
Note that the extension can be anything.
docker run -v $PWD/file_tests:/scripts -it adana
```python
include("scripts/testfn.adana") # the built-in function to include m = map() m = pushv("nordine", 34, m) get_v("nordine", m) ```
There are several built-in functions available.
You already have seen length to find the length of an array or string, include to include a script inside the repl and println to print something.
Here is a list of built-in functions available:
| name | description | example |
|--------------|-------------------------------------------------------|------------------------------------|
| sqrt | square root | sqrt(2) |
| abs | absolute value | abs(-2) |
| log | logarithm | log(2) |
| ln | natural logarithm | ln(2) |
| length | length of an array or string | length("azert") |
| sin | sine of a number | sin(2) |
| cos | cosine of a number | cos(2) |
| tan | tangent of a number | tan(2.2) |
| print | print without a newline | print("hello") |
| println | print with a newline | println("hello") |
| include | include a script | include("scripts/test_fn.adana") |
| readlines | read a file and returns an array
of each lines | read_lines("scripts/name.txt") |
| toint | cast to int | to_int("2")to_int(2.2) |
| todouble | cast to double | to_double("2.2") |
| tobool | cast to bool | to_bool("true") |
| drop | drop a variable from context | drop("myvar") |
| eval | Evaluate a string as code | eval("sqrt(9)") |
| type_of | Type of variable | type_of(true) |
Note that you can use the repl command script_ctx to see what variables are stored in the context.
You can alias useful commands in a separate namespace (e.g: "work", "git", "docker").
You can then run that command through the repl. They will be save in disk so you can backup them, restore them etc.
You can also add any kind of values (e.g, ssh keys) to store them.
There is no possible interaction with the scripting language yet.
https://user-images.githubusercontent.com/3816305/181606658-b01a0ca5-4507-4d58-8625-4ccf9a662b86.mp4
docker run -it -v $PWD/sample.json:/adanadb.json adana --inmemory
restore
use misc
ds
printenv
| name | alt | description |
|------------------|------------|---------------------------------------------------------------------------------------------------------------------------------|
| put | N/A | Put a new value to current namespace. can have multiple aliases with option '-a'. e.g put -a drc -a drcomp docker-compose |
| describe | ds | List values within the current namespace. |
| listns | lsns | List available namespaces. |
| currentns | currentns | Print current namespace. |
| backup | bckp | Backup the database of namespaces to the current directory |
| flush | flush | Flush database |
| restore | N/A | Restore the database from current directory |
| deletens | delns | Delete namespace or clear current namespace values. |
| mergens | merge | Merge current with a given namespace |
| delete | del | Remove value from namespace. Accept either a hashkey or an alias. e.g del drc |
| get | | Get value from namespace. Accept either a hashkey or an alias. e.g get drc |
| exec | | Run a value from the namespace as an OS command. Accept either a hashkey or an alias. It is completely optional, if you just write the alias, it will also works e.g exec drc or simply drc |
| cd | | Navigate to a directory in the filesystem |
| use | | Switch to another namespace. default ns is DEFAULT. e.g use linux |
| dump | | Dump namespace(s) as json. Take an optional parameter, the namespace name. e.g dump linux |
| clear | cls | Clear the terminal. |
| printscriptctx | script_ctx | Print script context |
| help | | Display help. |
CTRL + x => new line in the repl
CTRL + d => quit
CTRL + c => undo
CTRL + l => clear screen
CTRL + r => history search
RUST_LOG=info adana
```
adana --inmemory
```
```
adana --dbpath /tmp/mydb.db --historypath /tmp/myhistory.txt --nofb
```