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
123
124
125
126
|
let Void = ../imports/Void.dhall
let Option = ./Option/type.dhall
let Command = ./Command/package.dhall
let opt =
λ(long : Text)
→ λ(description : Text)
→ { long =
long
, short =
None Text
, description =
description
, takes-files =
False
}
let fileOpt =
opt "file" "Read expression from a file instead of standard input"
⫽ { takes-files = True }
let alphaOpt = opt "alpha" "α-normalize expression"
let inplaceOpt =
opt "inplace" "Modify the specified file in-place"
⫽ { takes-files = True }
let jsonOpt = opt "json" "Use JSON representation of CBOR"
let leafCommand =
λ(name : Text)
→ λ(description : Text)
→ { options =
[] : List Option
, arguments =
(Command.Arguments Void).Subcommands ([] : List Void)
, name =
name
, description =
description
}
in { toplevelCommandIsSubcommand =
True
, command =
{ name =
"dhall"
, description =
"Interpreter for the Dhall language"
, options =
[ fileOpt
, opt "annotate" "Add a type annotation to the output"
, alphaOpt
, opt "explain" "Explain error messages in more detail"
, opt "plain" "Disable syntax highlighting"
, opt "ascii" "Format code using only ASCII syntax"
, opt "standard-version" "The standard version to use"
]
, arguments =
( Command.Arguments
(Command.Type Void)
).Subcommands
[ leafCommand "version" "Display version"
, leafCommand "resolve" "Resolve an expression's imports"
⫽ { options =
[ fileOpt
, opt "dot" "Output import dependency graph in dot format"
, opt
"immediate-dependencies"
"List immediate import dependencies"
, opt
"transitive-dependencies"
"List transitive import dependencies"
]
}
, leafCommand "type" "Infer an expression's type"
⫽ { options = [ fileOpt ] }
, leafCommand "normalize" "Normalize an expression"
⫽ { options = [ fileOpt, alphaOpt ] }
, leafCommand "repl" "Interpret expressions in a REPL"
, leafCommand
"diff"
"Render the difference between the normal form of two expressions"
⫽ { arguments = (Command.Arguments Void).Files }
, leafCommand
"hash"
"Compute semantic hashes for Dhall expressions"
, leafCommand "lint" "Improve Dhall code"
⫽ { options = [ inplaceOpt ] }
, leafCommand "format" "Formatter for the Dhall language"
⫽ { options =
[ opt "check" "Only check if the input is formatted"
, inplaceOpt
]
}
, leafCommand
"freeze"
"Add integrity checks to remote import statements of an expression"
⫽ { options =
[ inplaceOpt
, opt
"all"
"Add integrity checks to all imports (not just remote imports)"
, opt
"cache"
"Add fallback unprotected imports when using integrity checks purely for caching purposes"
]
}
, leafCommand "encode" "Encode a Dhall expression to binary"
⫽ { options = [ fileOpt, jsonOpt ] }
, leafCommand "decode" "Decode a Dhall expression from binary"
⫽ { options = [ fileOpt, jsonOpt ] }
, leafCommand
"text"
"Render a Dhall expression that evaluates to a Text literal"
⫽ { options = [ fileOpt ] }
]
}
}
: { command :
Command.Type (Command.Type Void)
, toplevelCommandIsSubcommand :
Bool
}
|
