Samples
Sample Rip source code.
System.IO.puts("Hello world")
can also be written as
System.IO puts "Hello world"
<figcaption>Comments and very basic IO</figcaption>
</figure>
---
<figure>
```language-rip
interesting_numbers = {
'Prime': [2, 3, 5, 7, 11, 13],
'Fibonacci': [1, 1, 2, 3, 5, 8],
'Square': [1, 4, 9, 16, 25],
}
interesting_numbers.fold(0, -> (largest, kind, numbers) {
(largest >> numbers)<System.Integer>.maximum()
})
filter = -> (sieve, items) {
fold(-> (memo, item) {
match (sieve(item)) {
when (true) { memo << item }
else { memo }
}
}, items.type.new(), items)
}
map = -> (mapper, items) {
fold(-> (memo, item) {
memo << mapper(item)
}, [], items)
}
@.fold = -> (initial, folder) {
@.type.fold(folder, initial, @)
}
@.filter = -> (sieve) {
@.type.filter(sieve, @)
}
@.map = -> (mapper) {
@.type.map(mapper, @)
}
}
<figcaption>list.rip</figcaption>
</figure>
<figure>
```language-rip
List = System.require('list')
numbers = [1, 2, 3, 4, 5]
is_even = -> (n) { n % 2 == 0 }
double = -> (n) { n * 2 }
square = -> (n) { n * n }
# object-oriented
numbers.filter(is_even) # [2, 4]
numbers.map(double) # [2, 4, 6, 8, 10]
numbers.map(square).filter(is_even) # [4, 16]
# procedural
List.filter(is_even, numbers) # [2, 4]
List.map(double, numbers) # [2, 4, 6, 8, 10]
List.filter(is_even, List.map(square, numbers)) # [4, 16]
# functional (combinative)
even_square = List.map(square) + List.filter(is_even)
even_square(numbers) # [4, 16]
# functional (pipeline)
numbers |> List.map(square) |> List.filter(is_even) # [4, 16]
_true = true
_false = false
integer = 42
decimal = 3.14
rational = 2 / 3
complex = <integer, decimal.i>
date = 1980-10-16
time = 13:59:00
datetime = 1980-10-16T13:59:00
pair = key : value
range = 1..5
list = []
map = {}
character = `c
regular_expression = /abc/
string_symbol = :rip
string_single = 'foo'
string_double = "b#{a}r"
string_heredoc = <<-RIP
hello, world!
RIP
Person = type {
@.initialize = -> (name) { @.name = name }
find = -> (id) { }
}
People = type (System.List
all = => {
-> { new([]) }
-> (filter) {
new([].where(filter))
}
}
}
<figcaption>Sample code used to develop a grammar for the <a href="http://prismjs.com/">Prism syntax highlighter</a>.</figcaption>
</figure>
---
<figure>
```language-rip
factorial1 = -> (n, accumulator = 1) {
match (n) {
when (0) { accumulator }
else { self(n - 1, n * accumulator) }
}
}
factorial2 = => {
-> (n, accumulator = 1) {
match (n) {
when (0) { accumulator }
else { self(n - 1, n * accumulator) }
}
}
}
factorial3 = => {
-> (n) {
self(n, 1)
}
-> (n, accumulator) {
match (n) {
when (0) { accumulator }
else { self(n - 1, n * accumulator) }
}
}
}
would love to implement division in such a way that if the number can
divide evenly, it just returns the integer, otherwise a rational
<figcaption>Real Numbers</figcaption>
</figure>
<figure>
```language-rip
# access the dynamic property `i` on real numbers for their imaginary counterparts
# (same as multiplying the real number by System.Math.i)
System.Integer #=> 1.i
System.Decimal #=> 3.14.i
System.Rational #=> (2 / 3).i
# Add a real number and an imaginary number to produce a complex number. Rip doesn't support higher-dimension numbers.
System.Complex #=> 42 + 3.i