File: .ocp-indent

package info (click to toggle)
ocp-indent 1.4.2-1
  • links: PTS, VCS
  • area: main
  • in suites: jessie, jessie-kfreebsd
  • size: 1,304 kB
  • ctags: 1,256
  • sloc: ml: 7,010; sh: 315; makefile: 106; lisp: 77
file content (122 lines) | stat: -rw-r--r-- 3,937 bytes parent folder | download
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
# -*- conf -*-
# This is an example configuration file for ocp-indent
#
# Copy to the root of your project with name ".ocp-indent", customise, and
# transparently get consistent indentation on all your ocaml source files.

# Starting the configuration file with a preset ensures you won't fallback to
# definitions from "~/.ocp/ocp-indent.conf".
# These are `normal`, `apprentice` and `JaneStreet` and set different defaults.
normal

#
#    INDENTATION VALUES
#

# Number of spaces used in all base cases, for example:
#    let foo =
#    ^^bar
base = 2

# Indent for type definitions:
#    type t =
#    ^^int
type = 2

# Indent after `let in` (unless followed by another `let`):
#    let foo = () in
#    ^^bar
in = 0

# Indent after `match/try with` or `function`:
#    match foo with
#    ^^| _ -> bar
with = 0

# Indent for clauses inside a pattern-match (after the arrow):
#    match foo with
#    | _ ->
#    ^^^^bar
# the default is 2, which aligns the pattern and the expression
match_clause = 4 # this is non-default

# When nesting expressions on the same line, their indentation are in
# some cases stacked, so that it remains correct if you close them one
# at a line. This may lead to large indents in complex code though, so
# this parameter can be used to set a maximum value. Note that it only
# affects indentation after function arrows and opening parens at end
# of line.
#
# for example (left: `none`; right: `4`)
#    let f = g (h (i (fun x ->     #    let f = g (h (i (fun x ->
#          x)                      #        x)
#        )                         #      )
#      )                           #    )
max_indent = 4


#
#    INDENTATION TOGGLES
#

# Wether the `with` parameter should be applied even when in a sub-block.
# Can be `always`, `never` or `auto`.
# if `always`, there are no exceptions
# if `auto`, the `with` parameter is superseded when seen fit (most of the time,
#            but not after `begin match` for example)
# if `never`, `with` is only applied if the match block starts a line.
#
# For example, the following is not indented if set to `always`:
#    let f = function
#    ^^| Foo -> bar
strict_with = never

# Controls indentation after the `else` keyword. `always` indents after the
# `else` keyword normally, like after `then`.
# If set to `never', the `else` keyword won't indent when followed by a newline.
# `auto` indents after `else` unless in a few "unclosable" cases (`let in`,
# `match`...).
#
# For example, with `strict_else=never`:
#    if cond then
#      foo
#    else
#    bar;
#    baz
# `never` is discouraged if you may encounter code like this example,
# because it hides the scoping error (`baz` is always executed)
strict_else = always

# Ocp-indent will normally try to preserve your in-comment indentation, as long
# as it respects the left-margin or starts with `(*\n`. Setting this to `true`
# forces alignment within comments.
strict_comments = false

# Toggles preference of column-alignment over line indentation for most
# of the common operators and after mid-line opening parentheses.
#
# for example (left: `false'; right: `true')
#    let f x = x            #    let f x = x
#      + y                  #              + y
align_ops = true

# Function parameters are normally indented one level from the line containing
# the function. This option can be used to have them align relative to the
# column of the function body instead.
# if set to `always`, always align below the function
# if `auto`, only do that when seen fit (mainly, after arrows)
# if `never`, no alignment whatsoever
#
# for example (left: `never`; right: `always or `auto)
#    match foo with         #    match foo with
#    | _ -> some_fun        #    | _ -> some_fun
#      ^^parameter          #           ^^parameter
align_params = auto


#
#    SYNTAX EXTENSIONS
#

# You can also add syntax extensions (as per the --syntax command-line option):
# syntax = mll lwt