├── .gitattributes
├── .github
└── workflows
│ └── ink.yml
├── .gitignore
├── .ink-version
├── LICENSE
├── Makefile
├── README.md
├── examples.ink
├── examples
├── control-flow.ink
├── execing-processes.ink
├── files.ink
├── functions.ink
├── hello-world.ink
├── http.ink
├── io.ink
├── lists.ink
├── loops.ink
├── maps.ink
├── random.ink
├── sorting.ink
└── values.ink
├── netlify.toml
├── src
├── build.ink
├── highlight.ink
├── ink-darwin-1.9
├── ink-linux-1.9
└── test.ink
├── static
├── 404.html
├── favicon.ico
├── preview.png
└── site.css
├── templates
├── example.html
└── index.html
└── vendor
├── iota.ink
├── quicksort.ink
├── std.ink
├── str.ink
└── tokenize.ink
/.gitattributes:
--------------------------------------------------------------------------------
1 | public/* linguist-generated=true
2 | vendor/* linguist-vendored=true
3 |
4 |
--------------------------------------------------------------------------------
/.github/workflows/ink.yml:
--------------------------------------------------------------------------------
1 | # This is a basic workflow to help you get started with Actions
2 |
3 | name: CI
4 |
5 | # Controls when the workflow will run
6 | on:
7 | # Triggers the workflow on push or pull request events but only for the main branch
8 | push:
9 | branches: [ main ]
10 | pull_request:
11 | branches: [ main ]
12 |
13 | # Allows you to run this workflow manually from the Actions tab
14 | workflow_dispatch:
15 |
16 | # A workflow run is made up of one or more jobs that can run sequentially or in parallel
17 | jobs:
18 | # This workflow contains a single job called "build"
19 | build:
20 | # The type of runner that the job will run on
21 | runs-on: ubuntu-latest
22 |
23 | # Steps represent a sequence of tasks that will be executed as part of the job
24 | steps:
25 | # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
26 | - uses: actions/checkout@v2
27 |
28 | # Runs a single command using the runners shell
29 | - name: Run examples
30 | run: make test-linux
31 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | .idea
3 | .vscode
4 | tmp/
5 | public/
--------------------------------------------------------------------------------
/.ink-version:
--------------------------------------------------------------------------------
1 | v0.1.9
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2020 Andrew Healey
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | build-linux:
2 | cd ./src && chmod +x ./ink-linux-1.9 && ./ink-linux-1.9 ./build.ink
3 |
4 | build-mac:
5 | cd ./src && chmod +x ./ink-darwin-1.9 && ./ink-darwin-1.9 ./build.ink
6 |
7 | test-linux:
8 | cd ./src && chmod +x ./ink-linux-1.9 && ./ink-linux-1.9 ./build.ink && ./ink-linux-1.9 test.ink
9 |
10 | test-mac:
11 | cd ./src && chmod +x ./ink-darwin-1.9 && ./ink-darwin-1.9 ./build.ink && ./ink-darwin-1.9 test.ink
12 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | [](https://github.com/healeycodes/inkbyexample/actions/workflows/ink.yml)
2 |
3 | # Ink by Example
4 |
5 | Content and build toolchain for [Ink by Example](https://inkbyexample.com), a site that teaches [Ink](https://dotink.co/) via annotated example programs.
6 |
7 | All tooling is written in Ink and the programs are evaluated as part of the build process.
8 |
9 | Syntax highlighting powered by [September](https://github.com/thesephist/september).
10 |
11 | if/else branching, match expressions are used for control flow.'
2 |
3 | rows := [
4 | {
5 | docs: ''
6 | code: 'std := load(\'../vendor/std\')
7 | filter := std.filter
8 | log := std.log
9 |
10 |
11 | '
12 | },
13 | {
14 | docs: 'Like the switch expression from other programming languages, the case clauses are checked from top to bottom. The checking stops when there\'s a match.'
15 | code: 'error := true
16 | error :: {
17 | false -> log(\'No problem!\')
18 | true -> log(\'There is a problem..\')
19 | }
20 |
21 | '
22 | },
23 | {
24 | docs: 'The default, or else, branch is signified with the underscore character. This will match anything.'
25 | code: 'device := \'windows\'
26 | device :: {
27 | \'linux\' -> log(\'Linux!\')
28 | \'macOS\' -> log(\'Mac!\')
29 | _ -> log(\'Neither Linux or Mac.\')
30 | }
31 |
32 | '
33 | },
34 | {
35 | docs: 'A match target can be an expression.'
36 | code: 'greeting := \'Hello!\'
37 | greeting :: {
38 | \'Hello\' -> log(\'They greeted us.\')
39 | \'Hello\' + \'!\' -> log(\'They greeted us loudly.\')
40 | }
41 |
42 | '
43 | },
44 | {
45 | docs: 'Composite values are deep compared so the underscore can be used to catch complex objects that, while different, have a similar characteristic.'
46 | code: 'first := {
47 | code: 2,
48 | user: \'alice@google\'
49 | }
50 | second := {
51 | code: 2,
52 | user: \'claire@amazon\'
53 | }
54 |
55 | checkEvent := event => event :: {
56 | {code: 2, user: _} -> log(\'All good!\')
57 | _ -> log(\'Bad event..\')
58 | }
59 | checkEvent(first)
60 | checkEvent(second)
61 |
62 | '
63 | },
64 | {
65 | docs: 'std.filter can be passed a match expression. Here we use it to filter out odd numbers.'
66 | code: 'numbers := [1, 2, 3, 4, 5, 6]
67 | onlyEven := num => num % 2 :: {
68 | 0 -> true
69 | _ -> false
70 | }
71 | even := filter(numbers, onlyEven)
72 | log(even)
73 |
74 | '
75 | }
76 | ]
77 |
78 | end := ''
79 |
--------------------------------------------------------------------------------
/examples/execing-processes.ink:
--------------------------------------------------------------------------------
1 | intro := 'Ink can spawn child processes. The stdout data is passed to a callback when the process ends.'
2 |
3 | rows := [
4 | {
5 | docs: ''
6 | code: 'std := load(\'../vendor/std\')
7 | each := std.each
8 | log := std.log
9 |
10 |
11 | '
12 | },
13 | {
14 | docs: 'Let\'s take a look at the files in the directory relative to the executing file (in this instance, this website\'s build script).'
15 | code: 'path := \'ls\' `` path to executable
16 | arguments := []
17 | stdin := \'\'
18 | stdoutFn := out => log(out)
19 | exec(path, arguments, stdin, stdoutFn)
20 |
21 | '
22 | },
23 | {
24 | docs: 'args gives us the command-line arguments for the current context. This can be useful if you\'re chaining Ink programs.'
25 | code: '
26 | log(\'Arguments:\')
27 | each(args(), arg => log(\' \' + arg))
28 | '
29 | }
30 | ]
31 |
32 | end := ''
33 |
--------------------------------------------------------------------------------
/examples/files.ink:
--------------------------------------------------------------------------------
1 | intro := 'You will usually interact with files through two standard library APIs — std.readFile and std.writeFile. The runtimes and builtins documentation lists the operating system interfaces.'
2 |
3 | rows := [
4 | {
5 | docs: ''
6 | code: 'std := load(\'../vendor/std\')
7 | writeFile := std.writeFile
8 | readFile := std.readFile
9 | slice := std.slice
10 | log := std.log
11 |
12 |
13 | '
14 | },
15 | {
16 | docs: 'Let\'s read in the README for this project.'
17 | code: '
18 | readFile(\'../README.md\', data => (
19 | log(\'Read:\')
20 | log(
21 | ` data is the entire file content `
22 | slice(data, 0, 16))
23 | ))
24 |
25 | '
26 | },
27 | {
28 | docs: 'If the read fails, null is passed to the callback. The read can fail if you try to access a file that doesn\'t exist. So we should handle that.'
29 | code: '
30 | readFile(\'../doesnt-exist.md\', data => data :: {
31 | () -> log(\'The read failed.\')
32 | _ -> log(\'The read succeeded.\')
33 | })
34 |
35 | '
36 | },
37 | {
38 | docs: 'Here we write content to a file. If the file exists, it\'s truncated — otherwise the file is created. The path is relative to the executing file.'
39 | code: '
40 | path := \'../tmp/_writeExample.txt\'
41 | data := \'Some data. \'
42 | writeFile(path, data, cb => cb :: {
43 | ` either true or null `
44 | true -> log(\'The write succeeded.\')
45 | _ -> log(\'The write failed.\')
46 | })
47 |
48 | '
49 | },
50 | {
51 | docs: 'make can be used to recursively create directories.'
52 | code: '
53 | make(\'../tmp/_makeExample/\', cb => cb.type :: {
54 | \'error\' -> (
55 | log(\'Make:\')
56 | log(\' \' + string(cb.message))
57 | )
58 | _ -> log(\'Make succeeded.\')
59 | })
60 |
61 | '
62 | },
63 | {
64 | docs: 'We can get directory information with dir.'
65 | code: '
66 | dir(\'../src/\', cb => cb.type :: {
67 | \'error\' -> log(\'Dir failed.\')
68 | ` cb.data is a list of files and directories`
69 | _ -> (
70 | log(\'Dir:\')
71 | log(\' \' + string(cb.data.0))
72 | )
73 | })
74 |
75 | '
76 | },
77 | {
78 | docs: 'Similarly, stat returns metadata about an object in the file tree.'
79 | code: '
80 |
81 | stat(\'../README.md\', cb => cb.type :: {
82 | \'error\' -> log(\'Stat failed.\')
83 | _ -> (
84 | log(\'Stat:\')
85 | log(\' \' + string(cb))
86 | )
87 | })
88 |
89 | '
90 | }
91 | ]
92 |
93 | end := 'We\'re not using ordered callbacks so the order of the logs will be dependant on the system calls when this website was last built and the code was evaluated. This is an example of Ink\'s event loop!'
94 |
--------------------------------------------------------------------------------
/examples/functions.ink:
--------------------------------------------------------------------------------
1 | intro := 'Functions are the building blocks of Ink and enable us to write terse functional code.'
2 |
3 | rows := [
4 | {
5 | docs: ''
6 | code: 'std := load(\'../vendor/std\')
7 | log := std.log
8 |
9 |
10 | '
11 | },
12 | {
13 | docs: 'Functions are created with the arrow => symbol.'
14 | code: '
15 | shout := (word) => word + \'!\'
16 | log(shout(\'Hello\'))
17 |
18 | multiply := (x, y) => x * y
19 | log(multiply(2, 8))
20 |
21 | '
22 | },
23 | {
24 | docs: 'When a group of expressions follow the arrow symbol, the result of the final expression is the return value.'
25 | code: '` single argument parentheses are optional`
26 | sayAndMultiply := num => (
27 | log(\'About to multiply \' + string(num) + \':\')
28 |
29 | ` the return value `
30 | num * num
31 | )
32 | log(sayAndMultiply(8))
33 |
34 | '
35 | },
36 | {
37 | docs: 'Function invocation () takes precedence over property-access . — instead of obj.func(argument), we use (obj.func)(argument).'
38 | code: 'math := {
39 | swapSign: n => 0 - n
40 | }
41 | weight := (math.swapSign)(100)
42 | log(weight)
43 |
44 | '
45 | },
46 | {
47 | docs: 'Here\'s an example of tail recursion.'
48 | code: 'factorial := n => n :: {
49 | 0 -> 1
50 | _ -> n * factorial(n-1)
51 | }
52 | log(factorial(5))
53 |
54 | '
55 | },
56 | {
57 | docs: 'It\'s natural to use closures — functions that have access to the parent scope after the parent function has closed.'
58 | code: 'makeMultiplier := x => (
59 | y := y => x * y
60 | )
61 | multiplySeven := makeMultiplier(7)
62 | multiplyTwenty := makeMultiplier(20)
63 | log(multiplySeven(2))
64 | log(multiplyTwenty(4))
65 |
66 | '
67 | },
68 | {
69 | docs: 'Functions that immediately evalute and return another function is called currying in functional programming land.'
70 | code: 'greeting := a => b => a + \' \' + b
71 | message := greeting(\'Hello there,\')(\'General Kenobi\')
72 | log(message)
73 | '
74 | }
75 | ]
76 |
77 | end := ''
78 |
--------------------------------------------------------------------------------
/examples/hello-world.ink:
--------------------------------------------------------------------------------
1 | intro := 'Our first program will print the classic "hello world" message. Here\'s the full source code.'
2 |
3 | rows := [
4 | {
5 | docs: 'Ink programs are imported by calling load and passing the relative path without .ink. Top level values are brought in as a map.'
6 | code: 'std := load(\'../vendor/std\')
7 | log := std.log
8 |
9 |
10 | log(\'hello world\')
11 | '
12 | },
13 | {
14 | docs: 'We can add comments using the grave accent (U+0060).'
15 | code: '` a single line comment `
16 |
17 | `
18 | a multi-line comment
19 | `
20 |
21 | '
22 | },
23 | {
24 | docs: 'A double accent comments the rest of the line.'
25 | code: '`` log(\'This should not run!\')
26 | '
27 | }
28 | ]
29 |
30 | end := 'To run the program, put the code in hello-world.ink and run it with the interpreter.'
31 |
--------------------------------------------------------------------------------
/examples/http.ink:
--------------------------------------------------------------------------------
1 | intro := 'Ink can both send and receive HTTP requests.'
2 |
3 | rows := [
4 | {
5 | docs: ''
6 | code: 'std := load(\'../vendor/std\')
7 | log := std.log
8 |
9 |
10 | '
11 | },
12 | {
13 | docs: 'We can initiate an HTTP request with req. It returns a function that aborts the request. Let\'s also time this request.'
14 | code: '
15 | t := time()
16 | data := {
17 | method: \'GET\'
18 | url: \'https://example.org\'
19 | headers: {}
20 | body: \'\'
21 | }
22 |
23 | close := req(data, evt => evt.type :: {
24 | ` this matches during a request fail
25 | or if the request is aborted `
26 | \'error\' -> log(\'Error: \' + evt.message)
27 | _ -> (
28 | log(\'Req: \')
29 | elasped := string(time() - t)
30 | log(\' elapsed time: \' + elasped)
31 | log(\' \' + string(keys(evt.data)))
32 | )
33 | })
34 | log(\'This code runs while we request.\')
35 | `` close() would abort the request
36 |
37 |
38 | '
39 | },
40 | {
41 | docs: 'A HTTP web server can be started with listen. Similar to req, it returns a function that stops the server.'
42 | code: '
43 | resp := {
44 | status: 200
45 | headers: {\'Content-Type\': \'text/plain\'}
46 | body: \'Hello from Ink land!\'
47 | }
48 | close := listen(\'0.0.0.0:80\', evt => evt.type :: {
49 | \'error\' -> log(\'Error: \' + evt.message)
50 | \'req\' -> (evt.end)(resp)
51 | })
52 | log(\'This code runs while we listen.\')
53 |
54 | ` stop the server `
55 | close()
56 | '
57 | }
58 | ]
59 |
60 | end := 'listen errors in this project\'s deploy pipeline due to permissions but will work locally.'
61 |
--------------------------------------------------------------------------------
/examples/io.ink:
--------------------------------------------------------------------------------
1 | intro := 'Ink has access to standard input (stdin) and standard output (stdout). You can pipe input to an Ink program in the form echo "Hello, World!" | ink program.ink.'
2 |
3 | rows := [
4 | {
5 | docs: ''
6 | code: 'std := load(\'../vendor/std\')
7 | scan := std.scan
8 | log := std.log
9 | f := std.format
10 |
11 |
12 | '
13 | },
14 | {
15 | docs: 'To send data to standard output we can use the builtin out, which accepts a string, or the helper std.log which accepts strings and non-strings and adds a linebreak.'
16 | code: 'out(\'Hello, with a manual linebreak.
17 | \')
18 | log(7) `` print a number
19 | log([1, 2]) `` a composite
20 | log(() => ()) `` a function
21 | log(()) `` or null
22 | '
23 | },
24 | {
25 | docs: 'For reading in data from standard input, there is the builtin in as well as the helper std.scan which reads in a line.'
26 | code: 'prompt := (msg, cb) => (
27 | log(msg)
28 | scan(cb)
29 | )
30 | ` usage:
31 | prompt(\'Are you sure?\', msg => (
32 | log(msg)
33 | ))`
34 |
35 | '
36 | },
37 | {
38 | docs: 'std.format allows us to build template strings and pass in a map of values.'
39 | code: 'log(f(\'A message without any passed in values.\', {}))
40 | log(f(\'The time is: {{ time }}.\', {time: time()}))
41 | '
42 | }
43 | ]
44 |
45 | end := ''
46 |
--------------------------------------------------------------------------------
/examples/lists.ink:
--------------------------------------------------------------------------------
1 | intro := 'Lists and maps share the same data structure — the composite value. At runtime, lists are hashmaps with string keys representing indices.'
2 |
3 | rows := [
4 | {
5 | docs: ''
6 | code: 'std := load(\'../vendor/std\')
7 | log := std.log
8 | reverse := std.reverse
9 | slice := std.slice
10 | range := std.range
11 | each := std.each
12 | join := std.join
13 |
14 |
15 | '
16 | },
17 | {
18 | docs: 'Lists can be declared with array syntax.'
19 | code: 'names := [\'Alice\', \'Andrew\']
20 | log(names)
21 |
22 | '
23 | },
24 | {
25 | docs: 'To access or mutate an element we use the dot syntax.'
26 | code: 'log(names.0) `` first element
27 | log(names.(len(names) - 1)) `` last element
28 |
29 | names.0 := \'Madeline\'
30 | log(names)
31 |
32 | '
33 | },
34 | {
35 | docs: 'Like strings, we can append to the end of a list by mutating the next index value.'
36 | code: 'names.len(names) := \'Francisca\'
37 | log(names)
38 |
39 | '
40 | },
41 | {
42 | docs: ''
43 | code: '
44 | indexer := (name, index) => (
45 | log(index)
46 | log(name)
47 | )
48 | each(names, indexer)
49 |
50 | '
51 | },
52 | {
53 | docs: 'std.range works similar to Python\'s range. It takes start, end, and step values and returns a list.'
54 | code: '
55 | numbers := range(0, 6, 1)
56 | log(numbers)
57 |
58 | '
59 | },
60 | {
61 | docs: 'We can get a sublist with std.slice, and join two lists to create a third with std.join.'
62 | code: '
63 | half := slice(numbers, 0, 3)
64 | log(half)
65 |
66 | first := [98, 99]
67 | second := [100, 101]
68 | third := join(first, second)
69 | log(third)
70 |
71 | '
72 | },
73 | {
74 | docs: 'To reverse, use std.reverse. For other list utilities, refer to the standard library .'
75 | code: '
76 | log(reverse([\'one\', \'two\', \'three\', ]))
77 | '
78 | }
79 | ]
80 |
81 | end := ''
82 |
--------------------------------------------------------------------------------
/examples/loops.ink:
--------------------------------------------------------------------------------
1 | intro := 'Instead of a for loop construct, we use tail recursion .
2 | The standard library contains utility functions — like std.each, std.map, and std.reduce — that can be used in place of a for loop.'
3 |
4 | rows := [
5 | {
6 | docs: ''
7 | code: 'std := load(\'../vendor/std\')
8 | log := std.log
9 | reduce := std.reduce
10 | each := std.each
11 | map := std.map
12 |
13 |
14 | '
15 | },
16 | {
17 | docs: ''
18 | code: 'numbers := [0, 1, 2, 3, 4, 5, 6]
19 |
20 | '
21 | },
22 | {
23 | docs: 'We can loop over a list with std.each, which accepts a list and a function as arguments.'
24 | code: 'logger := num => log(num)
25 | each(numbers, logger)
26 |
27 | '
28 | },
29 | {
30 | docs: 'Let\'s create a new list with the squares of these numbers with std.map.'
31 | code: 'squares := map(numbers, num => num * num)
32 | log(squares)
33 |
34 | '
35 | },
36 | {
37 | docs: 'We can get the sum of these squares by using std.reduce.'
38 | code: 'sum := reduce(squares, (acc, num) => acc + num, 0)
39 | log(sum)'
40 | }
41 | ]
42 |
43 | end := ''
44 |
--------------------------------------------------------------------------------
/examples/maps.ink:
--------------------------------------------------------------------------------
1 | intro := 'Like lists, maps use the composite value — Ink\'s single built-in data structure. At runtime, maps are hashmaps with string keys.'
2 |
3 | rows := [
4 | {
5 | docs: ''
6 | code: 'std := load(\'../vendor/std\')
7 | clone := std.clone
8 | each := std.each
9 | log := std.log
10 |
11 |
12 | '
13 | },
14 | {
15 | docs: ''
16 | code: 'observation := {
17 | weather: \'Sunny\'
18 | \'observedAt\': {
19 | time: time()
20 | }
21 | }
22 | log(observation)
23 |
24 | '
25 | },
26 | {
27 | docs: 'Like lists, we use the dot syntax to access and mutate.'
28 | code: 'observation.(\'weather\') := \'Raining\'
29 |
30 | '
31 | },
32 | {
33 | docs: 'If we know the key before runtime, we can use a shortcut and just write it out.'
34 | code: 'observation.weather := \'Raining\'
35 | log(observation)
36 |
37 | '
38 | },
39 | {
40 | docs: 'std.clone can be used to create a copy of a map.'
41 | code: 'cloned := clone(observation)
42 |
43 | '
44 | },
45 | {
46 | docs: 'We can iterate through the keys by calling keys.'
47 | code: 'each(keys(observation), (key) => (
48 | log(observation.(key))
49 | ))
50 | '
51 | }
52 | ]
53 |
54 | end := ''
55 |
--------------------------------------------------------------------------------
/examples/random.ink:
--------------------------------------------------------------------------------
1 | intro := 'We can access randomness through two builtins — rand and urand. On Linux they typically map to /dev/random and /dev/urandom.'
2 |
3 | rows := [
4 | {
5 | docs: ''
6 | code: 'std := load(\'../vendor/std\')
7 | range := std.range
8 | each := std.each
9 | log := std.log
10 |
11 |
12 | '
13 | },
14 | {
15 | docs: 'For a random number in the range [0, 1) — including zero but excluding one — we use rand.'
16 | code: 'choices := [rand(), rand(), rand()]
17 | log(choices)
18 |
19 | '
20 | },
21 | {
22 | docs: 'We can use this to shuffle a list using the Fisher-Yates algorithm.'
23 | code: '
24 | ` an ordered list `
25 | numbers := range(0, 10, 1)
26 |
27 | shuffle := list => (
28 | each(list, (val, i) => (
29 | pick := floor(rand() * (len(list) - i - 1))
30 | current := len(list) - 1 - i
31 | tmp := list.(current)
32 | list.(current) := list.(pick)
33 | list.(pick) := tmp
34 | ))
35 | list
36 | )
37 | log(shuffle(numbers))
38 |
39 | '
40 | },
41 | {
42 | docs: 'For cryptographically secure randomness, use urand. This uses the most secure random number generation interface your system provides to generate a string of random data.'
43 | code: '
44 | length := 10
45 | log(urand(10))
46 |
47 | '
48 | }
49 | ]
50 |
51 | end := ''
52 |
--------------------------------------------------------------------------------
/examples/sorting.ink:
--------------------------------------------------------------------------------
1 | intro := 'The quicksort library provides a minimal Quicksort implementation that uses Hoare\'s partitioning.'
2 |
3 | rows := [
4 | {
5 | docs: ''
6 | code: 'std := load(\'../vendor/std\')
7 | log := std.log
8 |
9 | qs := load(\'../vendor/quicksort\')
10 | sortBy := qs.sortBy
11 | sort! := qs.sort!
12 | sort := qs.sort
13 |
14 |
15 | '
16 | },
17 | {
18 | docs: 'We can sort a list in ascending order with quicksort.sort.'
19 | code: 'numbers := [921, 14, 0, 0.002]
20 | log(sort(numbers))
21 |
22 | '
23 | },
24 | {
25 | docs: 'Function definitions that end in ! mutate their arguments — like quicksort.sort!.'
26 | code: 'temperatures := [33, 1, 5, 22]
27 | sort!(temperatures)
28 |
29 | ` the existing list has changed `
30 | log(temperatures)
31 |
32 | '
33 | },
34 | {
35 | docs: 'quicksort.sortBy allows us to pass a predicate — a function that each item should be measured with.'
36 | code: 'menu := {
37 | apples: 1.50
38 | oranges: 2.00
39 | coconut: 3.50
40 | grapes: 1.75
41 | }
42 | items := [\'apples\', \'oranges\', \'coconut\', \'grapes\']
43 |
44 | ` sort items by their menu price `
45 | log(sortBy(items, item => menu.(item)))
46 |
47 | '
48 | }
49 | ]
50 |
51 | end := ''
52 |
--------------------------------------------------------------------------------
/examples/values.ink:
--------------------------------------------------------------------------------
1 | intro := 'Ink has number, string, boolean, null, and composite values. Here are a few basic examples.'
2 |
3 | rows := [
4 | {
5 | docs: ''
6 | code: 'std := load(\'../vendor/std\')
7 | log := std.log
8 |
9 |
10 | '
11 | },
12 | {
13 | docs: 'Numbers, which support arithmetic operations, and more advanced functions using built-in native functions.'
14 | code: 'length := (0.5 + 2 * 3 / 4 - 5) + ~6 % 7
15 | log(length)
16 |
17 | ` a negative literal `
18 | temperature := ~5
19 | log(temperature)
20 |
21 | year := pow(10, 3) * 2 + 20
22 | log(year)
23 |
24 | '
25 | },
26 | {
27 | docs: 'Strings, which can be added together with +, and appended to by mutating the next index value.'
28 | code: 'name := \'ada\' + \' \' + \'lovelace\'
29 | log(name)
30 | name.0 := \'A\'
31 | name.len(name) := \'!\'
32 | log(name)
33 |
34 | '
35 | },
36 | {
37 | docs: 'Boolean.'
38 | code: 'authed := true
39 | log(authed)
40 | log(~authed)
41 | log(true | false)
42 | log(true & false)
43 |
44 | '
45 | },
46 | {
47 | docs: 'Null.'
48 | code: 'exists := ()
49 | log(exists)
50 |
51 | '
52 | },
53 | {
54 | docs: 'Composite values, which are used for lists and maps.'
55 | code: 'primes := [2, 3, 5, 7]
56 | log(primes)
57 |
58 | menu := {
59 | apples: 1.00
60 | oranges: 1.50
61 | }
62 | log(menu)
63 |
64 | '
65 | },
66 | {
67 | docs: 'We can get the value of a type with type.'
68 | code: 'log(type(0))
69 |
70 | '
71 | }
72 | ]
73 |
74 | end := ''
--------------------------------------------------------------------------------
/netlify.toml:
--------------------------------------------------------------------------------
1 | [build]
2 | publish = "public/"
3 | command = "make build-linux"
4 |
--------------------------------------------------------------------------------
/src/build.ink:
--------------------------------------------------------------------------------
1 | std := load('../vendor/std')
2 | writeFile := std.writeFile
3 | readFile := std.readFile
4 | append := std.append
5 | reduce := std.reduce
6 | each := std.each
7 | f := std.format
8 | map := std.map
9 | cat := std.cat
10 | log := std.log
11 |
12 | str := load('../vendor/str')
13 | replace := str.replace
14 | lower := str.lower
15 | split := str.split
16 |
17 | highlight := load('highlight').main
18 |
19 | ` in order to execute the code examples, they need to be written to disk `
20 | evaluate := (fileName, source, cb) => (
21 | writeFile('../tmp/' + fileName + '.ink', source, result => result :: {
22 | () -> log('error creating source code file for: ' + example)
23 | _ -> (
24 | exec(args().0, ['../tmp/' + fileName + '.ink'], '', output => output :: {
25 | () -> log('error executing program for: ' + example)
26 | _ -> cb(output)
27 | })
28 | )
29 | })
30 | )
31 |
32 | renderIndexPage := (template, examples, inkVersion) => (
33 | ` render the index page with the list of examples and links `
34 | exampleList := reduce(examples, (acc, item) => (
35 | acc := acc + f('
36 | {{ name }}
37 | ', {
38 | name: item
39 | path: replace(lower(item), ' ', '-') + '.html'
40 | })
41 | ), '')
42 |
43 | page := f(template, {
44 | firstExample: replace(lower(examples.0), ' ', '-') + '.html'
45 | exampleList: exampleList
46 | inkVersion: inkVersion
47 | })
48 | writeFile('../public/index.html', page, result => result :: {
49 | () -> log('error writing index.html')
50 | })
51 | )
52 |
53 | renderExamplePages := (template, examples) => (
54 | each(examples, (example, i) => (
55 | fileName := replace(lower(example), ' ', '-')
56 | data := load('../examples/' + fileName)
57 | source := reduce(data.rows, (acc, item) => acc := acc + '
58 | ' + item.code, '')
59 |
60 | evaluate(fileName, source, result => (
61 | ` pages link to the next example if one exists `
62 | len(examples) :: {
63 | (i + 1) -> next := ''
64 | _ -> next := f('
65 | Next example: {{ example }} .
66 |
',
67 | {
68 | path: replace(lower(examples.(i + 1)), ' ', '-') + '.html'
69 | example: examples.(i + 1)
70 | })
71 | }
72 |
73 | page := f(template, {
74 | name: example
75 | rows: reduce(data.rows, (acc, item) => (
76 | class := (len(item.code) :: {
77 | 0 -> 'empty'
78 | _ -> ''
79 | })
80 | acc := acc + f('
81 | {{ docs }}
83 | {{ code }}
84 |
85 | ',
86 | {
87 | docs: item.docs
88 | code: highlight(item.code)
89 | class: class
90 | })
91 | ), f('
92 | {{ intro }}
',
95 | {
96 | intro: data.intro
97 | })
98 | )
99 | program: f('
100 |
101 | {{ end }}
103 | $ ink {{ fileName }}
104 | {{ result }}
106 |
107 |
',
108 | {
109 | fileName: fileName + '.ink'
110 | result: result.data
111 | end: data.end
112 | })
113 | next: next
114 | })
115 |
116 | writeFile('../public/' + fileName + '.html', page, result => result :: {
117 | () -> log('error creating example: ' + example)
118 | })
119 | ))
120 | ))
121 | )
122 |
123 | ` move over static content `
124 | moveStatic := () => dir('../static', item => (
125 | each(item.data, file => (
126 | readFile('../static/' + file.name, data => (
127 | writeFile('../public/' + file.name, data, result => result :: {
128 | () -> log('error creating static file: ' + file.name)
129 | })
130 | ))
131 | ))
132 | ))
133 |
134 | ` setup folders `
135 | createPublic := cb => make('../public', result => result :: {
136 | () -> log('error creating public folder')
137 | _ -> (
138 | moveStatic()
139 | cb()
140 | )
141 | })
142 | createTmp := () => make('../tmp', result => result :: {
143 | () -> log('error creating tmp folder')
144 | })
145 |
146 | examples := load('../examples').all
147 | createPublic(() => (
148 |
149 | ` grab the ink version `
150 | readFile('../.ink-version', inkVersion => inkVersion :: {
151 | () -> log('error reading .ink-version')
152 | _ -> (
153 |
154 | ` render index page `
155 | readFile('../templates/index.html', template => template :: {
156 | () -> log('error reading index template')
157 | _ -> renderIndexPage(template, examples, inkVersion)
158 | })
159 | )
160 | })
161 |
162 | ` render example pages `
163 | readFile('../templates/example.html', template => template :: {
164 | () -> log('error reading example template')
165 | _ -> renderExamplePages(template, examples)
166 | })
167 | ))
168 | createTmp()
169 |
--------------------------------------------------------------------------------
/src/highlight.ink:
--------------------------------------------------------------------------------
1 | ` adapted from https://github.com/thesephist/september to enabled HTML syntax highlighting `
2 |
3 | std := load('../vendor/std')
4 |
5 | log := std.log
6 | map := std.map
7 | each := std.each
8 | slice := std.slice
9 | cat := std.cat
10 |
11 | Tokenize := load('../vendor/tokenize')
12 | Tok := Tokenize.Tok
13 | tokenize := Tokenize.tokenizeWithComments
14 |
15 | ` associating token types with their highlight colors `
16 | colorFn := tok => tok.type :: {
17 | (Tok.Separator) -> s => s
18 |
19 | (Tok.Comment) -> s => '' + s + ' '
20 |
21 | (Tok.Ident) -> s => s
22 | (Tok.EmptyIdent) -> s => s
23 |
24 | (Tok.NumberLiteral) -> s => '' + s + ' '
25 | (Tok.StringLiteral) -> s => '' + s + ' '
26 | (Tok.TrueLiteral) -> s => '' + s + ' '
27 | (Tok.FalseLiteral) -> s => '' + s + ' '
28 |
29 | (Tok.AccessorOp) -> s => '' + s + ' '
30 | (Tok.EqOp) -> s => '' + s + ' '
31 |
32 | (Tok.FunctionArrow) -> s => '' + s + ' '
33 |
34 | ` operators are all Name.Function color `
35 | (Tok.KeyValueSeparator) -> s => '' + s + ' '
36 | (Tok.DefineOp) -> s => '' + s + ' '
37 | (Tok.MatchColon) -> s => '' + s + ' '
38 | (Tok.CaseArrow) -> s => '' + s + ' '
39 | (Tok.SubOp) -> s => '' + s + ' '
40 | (Tok.NegOp) -> s => '' + s + ' '
41 | (Tok.AddOp) -> s => '' + s + ' '
42 | (Tok.MulOp) -> s => '' + s + ' '
43 | (Tok.DivOp) -> s => '' + s + ' '
44 | (Tok.ModOp) -> s => '' + s + ' '
45 | (Tok.GtOp) -> s => '' + s + ' '
46 | (Tok.LtOp) -> s => '' + s + ' '
47 | (Tok.AndOp) -> s => '' + s + ' '
48 | (Tok.OrOp) -> s => '' + s + ' '
49 | (Tok.XorOp) -> s => '' + s + ' '
50 |
51 | (Tok.LParen) -> s => '' + s + ' '
52 | (Tok.RParen) -> s => '' + s + ' '
53 | (Tok.LBracket) -> s => '' + s + ' '
54 | (Tok.RBracket) -> s => '' + s + ' '
55 | (Tok.LBrace) -> s => '' + s + ' '
56 | (Tok.RBrace) -> s => '' + s + ' '
57 |
58 | _ -> () `` should error, unreachable
59 | }
60 |
61 | main := prog => (
62 | tokens := tokenize(prog)
63 | spans := map(tokens, (tok, i) => {
64 | colorFn: [tok.type, tokens.(i + 1)] :: {
65 | ` direct function calls are marked Name.Function color
66 | on a best-effort basis `
67 | [
68 | Tok.Ident
69 | {type: Tok.LParen, val: _, line: _, col: _, i: _}
70 | ] -> s => '' + s + ' '
71 | _ -> colorFn(tok)
72 | }
73 | start: tok.i
74 | end: tokens.(i + 1) :: {
75 | () -> len(prog)
76 | _ -> tokens.(i + 1).i
77 | }
78 | })
79 | pcs := map(
80 | spans
81 | span => (span.colorFn)(slice(prog, span.start, span.end))
82 | )
83 | cat(pcs, '')
84 | )
85 |
--------------------------------------------------------------------------------
/src/ink-darwin-1.9:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/healeycodes/inkbyexample/661fa148161b488b8dba2b63ea8b669a6c2580f2/src/ink-darwin-1.9
--------------------------------------------------------------------------------
/src/ink-linux-1.9:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/healeycodes/inkbyexample/661fa148161b488b8dba2b63ea8b669a6c2580f2/src/ink-linux-1.9
--------------------------------------------------------------------------------
/src/test.ink:
--------------------------------------------------------------------------------
1 | std := load('../vendor/std')
2 | each := std.each
3 | log := std.log
4 |
5 | str := load('../vendor/str')
6 | split := str.split
7 |
8 |
9 | dir('../examples/', files => each(files.data, file => file.dir :: {
10 | false -> (
11 | example := split(file.name, '.ink').0
12 | load('../tmp/' + example)
13 | )
14 | _ -> 'skip directory'
15 | }))
16 |
--------------------------------------------------------------------------------
/static/404.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Ink by Example: Not Found
6 |
10 |
13 |
Sorry, we couldn't find that! Check out the home page ?
14 |
Ping @healeycodes and I'll fix this ASAP!
15 |
18 |
8 |
10 |
11 | Ink by Example — {{ name }}
13 |
31 |
33 |
34 |
35 | {{ rows }}
36 | {{ program }}
37 |
38 |
39 | {{ next }}
40 |
41 |
44 |
8 |
10 |
11 | Ink by Example
14 |
32 |
35 |
36 | Ink is a minimal programming language inspired by modern JavaScript and Go, with a functional style.
37 |
38 |
39 |
40 | Ink by Example is a hands-on introduction
41 | to Ink using annotated example programs. Check out
42 | the first example or
43 | browse the full list below.
44 |
45 |
46 |
47 | {{ exampleList }}
48 |
49 |
50 |
51 | This website's toolchain is powered by Ink {{ inkVersion }}
52 |
53 |
56 |