Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/jvmakine/shine
LLVM frontend for Shine
https://github.com/jvmakine/shine
compiler functional-programming golang llvm
Last synced: 12 days ago
JSON representation
LLVM frontend for Shine
- Host: GitHub
- URL: https://github.com/jvmakine/shine
- Owner: jvmakine
- Created: 2020-02-27T01:27:20.000Z (over 4 years ago)
- Default Branch: master
- Last Pushed: 2022-01-05T10:03:15.000Z (almost 3 years ago)
- Last Synced: 2024-10-10T16:10:12.017Z (29 days ago)
- Topics: compiler, functional-programming, golang, llvm
- Language: LLVM
- Size: 764 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 5
-
Metadata Files:
- Readme: readme.md
Awesome Lists containing this project
README
# Shine frontend for LLVM
An LLVM frontend for a simple language
## Pre-requirements
LLVM 9 needs to be installed to compile or interpret the IR generated by this compiler.
## Building the runtime
To build the runtime for the language, call
```
make
```
## Usage
Interpret
> ./run.sh examples/fibonacci.shi
Compile into executable and run it
> ./compile.sh examples/fibonacci.shi fibonacci
> ./fibonacci
## Language
Every script needs to end in an expression. The value of this expression is printed as the output of the program.
Example script:
```
fibonacci = (n) => if (n <= 2) 1 else fibonacci(n-2) + fibonacci(n-1)
fibonacci(40)
```
This prints out `102334155`
### Types
The language supports full type inference. Explicitly declaring the types is completely optional.
#### Primitive types
The primitive types supported are
integer values supporting arithmetic operations
```
a: int = 1 + 2
```
real numbers supporting arithmetic operations
```
a: real = 1.0 + 2.0
```
boolean values that can be used as conditions in if expressions. Supports and and or operations
```
a: bool = true || false
if (a) 1 else 2
```
strings can be used as output values
```
a: string = "Hello " + "world!"
a
```
#### Functions
Functions are composed or parameter types and the return type. Functions can be used as values themselves, and can capture values from the point of definition in their closures.
```
c = 3
f = (a, b) => a + b + c
f(1, 2)
```
prints out 6
Functions don't need to be named and anonymous functions can be defined within an expression.
```
op = (a, b, f) => f(a, b)
op(1, 2, (x, y) => { x + y })
```
prints out 3
Function parameters can be declared is several blocks to support currying.
```
f = (a) => (b) => a + b
x = f(1)
x(2)
```
prints out 3
#### Structures
Structures are used to combine several valuesinto a single value. These values can then be accessed with the dot operator. The structure is declared with type declaration operator "::" and consists of ordered list of fields and their types.
```
Person :: (age: int, height: real, weight: real)
p = Person(38, 1.73, 60.0)
p.weight
```
prints out 60.0
To specify free types to be used in the structure, a type variables can be used
```
Pair[A] :: (left: A, right: A)
```
Explicitly specifying that an expression is of a specific structure, the structure name can be used.
```
getAge = (p: Person) => p.age
```
If explicit structure is not defined, functions can take any structure as in input with required fields.
```
Person :: (age: int, height: real)
Animal :: (age: int, weight: real)
getAge = (x) => x.age
getAge(Person(30, 1.70)) + getAge(Animal(5, 0.3))
```
prints out 35