blob: a9621d7d0f4f0fa7385f99d09ff8b0062dc4707e (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
# Coding style
## Program
- Every function has to be delimited by one empty line.
- Every (non-scoped) function must have a comment directly above it.
- Tests must appear in a single block (no empty lines) one line under
the definition.
See the [standard library](/std/) for inspiration.
## Function naming
De Bruijn indices can be seen as a disadvantage to readability. It's
therefore much more important to name the functions appropriately.
For functions that return a boolean, we suggest using the suffix `?`. If
your function has different cases it's recommended to use the `case-`
prefix in scoped sub-terms.
``` bruijn
# from std/Ternary
zero? [0 case-end case-neg case-pos i] ⧗ Number → Boolean
case-end true
case-neg [false]
case-pos [false]
```
Appropriate [type signatures](../introduction/syntax.md#types) are also
encouraged.
## If/else
Since booleans are just lambda terms either returning its first or
second argument, the use of if/else procedures is generally redundant.
See [bit/boolean data
structure](data-structures.md#booleansbits-stdlogic).
``` bruijn
:test (true 'a' 'b') ('a')
:test (false 'a' 'b') ('b')
```
## Head/tail
The internal structure of the list encoding means that when a list is
applied to a function, the function is called with the head and tail of
the list.
``` bruijn
:test ("abc" [[1]]) ('a')
:test ("abc" [[0]]) ("bc")
```
Therefore the recommended style for coding with lists is to use
`head`{.bruijn}/`tail`{.bruijn} only when truly needed.
## Recursion
[Recursion](recursion.md) should almost always be achieved with the
`y`{.bruijn} or `z`{.bruijn} combinators.
A common coding style in bruijn's standard library is to use the scoped
`rec` function to indicate recursion. You would then use `n+1`
abstraction around `rec` to indicate `n` arguments and the additionally
induced recursive call.
Example of the `length`{.bruijn} function for lists:
``` bruijn
# 3 abstractions => two arguments
# 2 is recursive call
# 1 is accumulator (+0)
# 0 is argument (list)
length z [[[rec]]] (+0) ⧗ (List a) → Number
rec 0 [[[case-inc]]] case-end
case-inc 5 ++4 1
case-end 1
```
|
