Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Switch to snake_case by convention for values #518

Merged
merged 4 commits into from Dec 29, 2021
Merged

Switch to snake_case by convention for values #518

Show file tree
Hide file tree
Changes from 2 commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
b0e0311
Switch to snake_case by convention for values
mboes Dec 28, 2021
db72002
Revert to camelCase names from Kubernetes schema
mboes Dec 29, 2021
644fc7f
Update examples/record-contract/record-contract.ncl
yannham Dec 29, 2021
c0c2fda
Update examples/record-contract/record-contract.ncl
yannham Dec 29, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
30 changes: 15 additions & 15 deletions examples/config-gcc/config-gcc.ncl
View file
Open in desktop
Expand Up @@ -9,40 +9,40 @@ let GccFlag =
lists.any (fun x => x == strings.substring 0 1 value) available then
value
else
contracts.blameWith "unknown flag #{value}" label
else if builtins.isRecord value then
if records.hasField "flag" value && records.hasField "arg" value then
contracts.blame_with "unknown flag #{value}" label
else if builtins.is_record value then
if records.has_field "flag" value && records.has_field "arg" value then
if lists.any (fun x => x == value.flag) available then
//Normalize the tag to a string
value.flag ++ value.arg
else
contracts.blameWith "unknown flag #{value.flag}" label
contracts.blame_with "unknown flag #{value.flag}" label
else
contracts.blameWith
contracts.blame_with
"bad record structure: missing field `flag` or `arg`"
label
else
contracts.blameWith "expected record or string" label in
contracts.blame_with "expected record or string" label in

let Path =
let pattern = m#"^(.+)/([^/]+)$"#m in
fun label value =>
if builtins.isStr value then
if strings.isMatch pattern value then
if strings.is_match pattern value then
value
else
contracts.blameWith "invalid path" label
contracts.blame_with "invalid path" label
else
contracts.blameWith "not a string" label in
contracts.blame_with "not a string" label in

let SharedObjectFile = fun label value =>
if builtins.isStr value then
if strings.isMatch m#"\.so$"#m value then
if strings.is_match m#"\.so$"#m value then
value
else
contracts.blameWith "not an .so file" label
contracts.blame_with "not an .so file" label
else
contracts.blameWith "not a string" label in
contracts.blame_with "not a string" label in

let OptLevel = fun label value =>
if value == 0 || value == 1 || value == 2 then
Expand All @@ -51,7 +51,7 @@ let OptLevel = fun label value =>
contracts.blame label in

let Contract = {
pathLibC | doc "Path to libc."
path_libc | doc "Path to libc."
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Should we apply the change to configuration option? In real life, their name is dictated by the consuming tool (say, Terraform), most commonly in camelCase than in snake_case.

| #Path
| #SharedObjectFile
| default = "/lib/x86_64-linux-gnu/libc.so",
Expand All @@ -63,7 +63,7 @@ let Contract = {
| List #GccFlag
| default = [],

optimizationLevel | doc "
optimization_level | doc "
Optimization level. Possible values:

- *0*: unoptimized
Expand All @@ -76,5 +76,5 @@ let Contract = {

{
flags = ["Wextra", {flag = "o", arg = "stuff.o"}],
optimizationLevel = 2,
optimization_level = 2,
} | #Contract
6 changes: 3 additions & 3 deletions examples/lists/lists.ncl
View file
Open in desktop
@@ -1,6 +1,6 @@
// Example list functions. This code is illustrative: prefer using the list
// stdlib functions `lists.map` and `lists.fold` instead.
let myListLib = {
let my_list_lib = {
// We have to wrap `head` and `tail` with the right annotations if we want our
// map and fold to be statically typed. This is due to a current issue with
// the how the stdlib is typed, see
Expand All @@ -24,5 +24,5 @@ let myListLib = {
f (head list) (fold f (tail list) first),
} in
// Compute `7!`
let l = myListLib.map (fun x => x+1) [1, 2, 3, 4, 5, 6] in
myListLib.fold (fun x acc => x * acc) l 1
let l = my_list_lib.map (fun x => x+1) [1, 2, 3, 4, 5, 6] in
my_list_lib.fold (fun x acc => x * acc) l 1
2 changes: 1 addition & 1 deletion examples/merge/security.ncl
View file
Open in desktop
Expand Up @@ -3,5 +3,5 @@

firewall.enabled | default = true,
firewall.type = "iptables",
firewall.openPorts = [21,80,443],
firewall.open_ports = [21, 80, 443],
}
9 changes: 5 additions & 4 deletions examples/record-contract/record-contract.ncl
View file
Open in desktop
@@ -1,8 +1,9 @@
// An illustrative (thus incomplete and maybe incorrect) contract example for a
// Kubernetes configuration.
// Schema and example derived from https://github.com/kubernetes/examples/blob/master/guestbook-go/guestbook-controller.json.

let Port | doc "A contract for a port number" = contracts.fromPred (fun value =>
builtins.isNum value &&
let Port | doc "A contract for a port number" = contracts.from_predicate (fun value =>
builtins.is_num value &&
value % 1 == 0 &&
value >= 0 &&
value <= 65535) in
Expand Down Expand Up @@ -37,7 +38,7 @@ let KubernetesConfig = {
| doc "The number of replicas"
| default = 1,

selector.matchLabels.app | Str,
selector.match_labels.app | Str,
yannham marked this conversation as resolved.
Show resolved Hide resolved

template = {
metadata.labels.app | Str,
Expand All @@ -60,7 +61,7 @@ let metadata_ = {
replicas = 3,
selector = {
app.name = name_,
matchLabels.app = name_,
match_labels.app = name_,
yannham marked this conversation as resolved.
Show resolved Hide resolved
},
template = {
metadata = metadata_,
Expand Down
6 changes: 3 additions & 3 deletions examples/simple-contracts/simple-contract-bool.ncl
View file
Open in desktop
@@ -1,8 +1,8 @@
// Example of simple custom contract, parametrized by a first argument.
// In practice, for this kind of simple predicate, one should rather use
// `contracts.fromPred`
let EqualsTo = fun referenceValue label value =>
if referenceValue == value then
// `contracts.from_predicate`
let EqualsTo = fun reference_value label value =>
if reference_value == value then
value
else
contracts.blame label in
Expand Down
4 changes: 2 additions & 2 deletions examples/simple-contracts/simple-contract-div.ncl
View file
Open in desktop
Expand Up @@ -2,12 +2,12 @@
// Illustrate a basic contract violation.

let Even = fun label value =>
if builtins.isNum value && value % 2 == 0 then
if builtins.is_num value && value % 2 == 0 then
value
else
contracts.blame label in
let DivBy3 = fun label value =>
if builtins.isNum value && value % 3 == 0 then
if builtins.is_num value && value % 3 == 0 then
value
else
contracts.blame label in
Expand Down
136 changes: 68 additions & 68 deletions src/grammar.lalrpop
View file
Open in desktop
Expand Up @@ -377,40 +377,40 @@ ChunkLiteralPart: ChunkLiteralPart<'input> = {
};

UOp: UnaryOp = {
"isNum" => UnaryOp::IsNum(),
"isBool" => UnaryOp::IsBool(),
"isStr" => UnaryOp::IsStr(),
"isFun" => UnaryOp::IsFun(),
"isList" => UnaryOp::IsList(),
"isRecord" => UnaryOp::IsRecord(),
"is_num" => UnaryOp::IsNum(),
"is_bool" => UnaryOp::IsBool(),
"is_str" => UnaryOp::IsStr(),
"is_fun" => UnaryOp::IsFun(),
"is_list" => UnaryOp::IsList(),
"is_record" => UnaryOp::IsRecord(),
"blame" => UnaryOp::Blame(),
"chngPol" => UnaryOp::ChangePolarity(),
"chng_pol" => UnaryOp::ChangePolarity(),
"polarity" => UnaryOp::Pol(),
"goDom" => UnaryOp::GoDom(),
"goCodom" => UnaryOp::GoCodom(),
"goList" => UnaryOp::GoList(),
"go_dom" => UnaryOp::GoDom(),
"go_codom" => UnaryOp::GoCodom(),
"go_list" => UnaryOp::GoList(),
"wrap" => UnaryOp::Wrap(),
"embed" <Ident> => UnaryOp::Embed(<>),
"map" => UnaryOp::ListMap(),
"generate" => UnaryOp::ListGen(),
"recordMap" => UnaryOp::RecordMap(),
"record_map" => UnaryOp::RecordMap(),
"seq" => UnaryOp::Seq(),
"deepSeq" => UnaryOp::DeepSeq(),
"deep_seq" => UnaryOp::DeepSeq(),
"head" => UnaryOp::ListHead(),
"tail" => UnaryOp::ListTail(),
"length" => UnaryOp::ListLength(),
"fieldsOf" => UnaryOp::FieldsOf(),
"valuesOf" => UnaryOp::ValuesOf(),
"strTrim" => UnaryOp::StrTrim(),
"strChars" => UnaryOp::StrChars(),
"charCode" => UnaryOp::CharCode(),
"charFromCode" => UnaryOp::CharFromCode(),
"strUppercase" => UnaryOp::StrUppercase(),
"strLowercase" => UnaryOp::StrLowercase(),
"strLength" => UnaryOp::StrLength(),
"strFrom" => UnaryOp::ToStr(),
"numFrom" => UnaryOp::NumFromStr(),
"enumFrom" => UnaryOp::EnumFromStr(),
"fields" => UnaryOp::FieldsOf(),
"values" => UnaryOp::ValuesOf(),
"str_trim" => UnaryOp::StrTrim(),
"str_chars" => UnaryOp::StrChars(),
"char_code" => UnaryOp::CharCode(),
"char_from_code" => UnaryOp::CharFromCode(),
"str_uppercase" => UnaryOp::StrUppercase(),
"str_lowercase" => UnaryOp::StrLowercase(),
"str_length" => UnaryOp::StrLength(),
"str_from" => UnaryOp::ToStr(),
"num_from" => UnaryOp::NumFromStr(),
"enum_from" => UnaryOp::EnumFromStr(),
};

switch_case: SwitchCase = {
Expand Down Expand Up @@ -551,26 +551,26 @@ InfixExpr: RichTerm = {

BOpPre: BinaryOp = {
"unwrap" => BinaryOp::Unwrap(),
"goField" => BinaryOp::GoField(),
"hasField" => BinaryOp::HasField(),
"elemAt" => BinaryOp::ListElemAt(),
"go_field" => BinaryOp::GoField(),
"has_field" => BinaryOp::HasField(),
"elem_at" => BinaryOp::ListElemAt(),
"tag" => BinaryOp::Tag(),
"hash" => BinaryOp::Hash(),
"serialize" => BinaryOp::Serialize(),
"deserialize" => BinaryOp::Deserialize(),
"pow" => BinaryOp::Pow(),
"strSplit" => BinaryOp::StrSplit(),
"strContains" => BinaryOp::StrContains(),
"strMatch" => BinaryOp::StrMatch(),
"strIsMatch" => BinaryOp::StrIsMatch(),
"str_split" => BinaryOp::StrSplit(),
"str_contains" => BinaryOp::StrContains(),
"str_match" => BinaryOp::StrMatch(),
"str_is_match" => BinaryOp::StrIsMatch(),
}

NOpPre<ArgRule>: RichTerm = {
"strReplace" <t1: ArgRule> <t2: ArgRule> <t3: ArgRule> =>
"str_replace" <t1: ArgRule> <t2: ArgRule> <t3: ArgRule> =>
mk_opn!(NAryOp::StrReplace(), t1, t2, t3),
"strReplaceRegex" <t1: ArgRule> <t2: ArgRule> <t3: ArgRule> =>
"str_replace_regex" <t1: ArgRule> <t2: ArgRule> <t3: ArgRule> =>
mk_opn!(NAryOp::StrReplaceRegex(), t1, t2, t3),
"strSubstr" <t1: ArgRule> <t2: ArgRule> <t3: ArgRule> =>
"str_substr" <t1: ArgRule> <t2: ArgRule> <t3: ArgRule> =>
mk_opn!(NAryOp::StrSubstr(), t1, t2, t3),
}

Expand Down Expand Up @@ -719,60 +719,60 @@ extern {
"List" => Token::Normal(NormalToken::List),

"tag" => Token::Normal(NormalToken::Tag),
"isNum" => Token::Normal(NormalToken::IsNum),
"isBool" => Token::Normal(NormalToken::IsBool),
"isStr" => Token::Normal(NormalToken::IsStr),
"isFun" => Token::Normal(NormalToken::IsFun),
"isList" => Token::Normal(NormalToken::IsList),
"isRecord" => Token::Normal(NormalToken::IsRecord),
"is_num" => Token::Normal(NormalToken::IsNum),
"is_bool" => Token::Normal(NormalToken::IsBool),
"is_str" => Token::Normal(NormalToken::IsStr),
"is_fun" => Token::Normal(NormalToken::IsFun),
"is_list" => Token::Normal(NormalToken::IsList),
"is_record" => Token::Normal(NormalToken::IsRecord),
"blame" => Token::Normal(NormalToken::Blame),
"chngPol" => Token::Normal(NormalToken::ChangePol),
"chng_pol" => Token::Normal(NormalToken::ChangePol),
"polarity" => Token::Normal(NormalToken::Polarity),
"goDom" => Token::Normal(NormalToken::GoDom),
"goCodom" => Token::Normal(NormalToken::GoCodom),
"goList" => Token::Normal(NormalToken::GoList),
"goField" => Token::Normal(NormalToken::GoField),
"go_dom" => Token::Normal(NormalToken::GoDom),
"go_codom" => Token::Normal(NormalToken::GoCodom),
"go_list" => Token::Normal(NormalToken::GoList),
"go_field" => Token::Normal(NormalToken::GoField),
"wrap" => Token::Normal(NormalToken::Wrap),
"unwrap" => Token::Normal(NormalToken::Unwrap),
"embed" => Token::Normal(NormalToken::Embed),
"recordMap" => Token::Normal(NormalToken::RecordMap),
"record_map" => Token::Normal(NormalToken::RecordMap),
"seq" => Token::Normal(NormalToken::Seq),
"deepSeq" => Token::Normal(NormalToken::DeepSeq),
"deep_seq" => Token::Normal(NormalToken::DeepSeq),
"head" => Token::Normal(NormalToken::Head),
"tail" => Token::Normal(NormalToken::Tail),
"length" => Token::Normal(NormalToken::Length),
"fieldsOf" => Token::Normal(NormalToken::FieldsOf),
"valuesOf" => Token::Normal(NormalToken::ValuesOf),
"fields" => Token::Normal(NormalToken::FieldsOf),
"values" => Token::Normal(NormalToken::ValuesOf),
"pow" => Token::Normal(NormalToken::Pow),

"hasField" => Token::Normal(NormalToken::HasField),
"has_field" => Token::Normal(NormalToken::HasField),
"map" => Token::Normal(NormalToken::Map),
"generate" => Token::Normal(NormalToken::ListGen),
"elemAt" => Token::Normal(NormalToken::ElemAt),
"elem_at" => Token::Normal(NormalToken::ElemAt),
"merge" => Token::Normal(NormalToken::Merge),
"default" => Token::Normal(NormalToken::Default),
"doc" => Token::Normal(NormalToken::Doc),

"hash" => Token::Normal(NormalToken::OpHash),
"serialize" => Token::Normal(NormalToken::Serialize),
"deserialize" => Token::Normal(NormalToken::Deserialize),
"strSplit" => Token::Normal(NormalToken::StrSplit),
"strTrim" => Token::Normal(NormalToken::StrTrim),
"strChars" => Token::Normal(NormalToken::StrChars),
"charCode" => Token::Normal(NormalToken::CharCode),
"charFromCode" => Token::Normal(NormalToken::CharFromCode),
"strUppercase" => Token::Normal(NormalToken::StrUppercase),
"strLowercase" => Token::Normal(NormalToken::StrLowercase),
"strContains" => Token::Normal(NormalToken::StrContains),
"strReplace" => Token::Normal(NormalToken::StrReplace),
"strReplaceRegex" => Token::Normal(NormalToken::StrReplaceRegex),
"strIsMatch" => Token::Normal(NormalToken::StrIsMatch),
"strMatch" => Token::Normal(NormalToken::StrMatch),
"strLength" => Token::Normal(NormalToken::StrLength),
"strSubstr" => Token::Normal(NormalToken::StrSubstr),
"strFrom" => Token::Normal(NormalToken::ToStr),
"numFrom" => Token::Normal(NormalToken::NumFromStr),
"enumFrom" => Token::Normal(NormalToken::EnumFromStr),
"str_split" => Token::Normal(NormalToken::StrSplit),
"str_trim" => Token::Normal(NormalToken::StrTrim),
"str_chars" => Token::Normal(NormalToken::StrChars),
"char_code" => Token::Normal(NormalToken::CharCode),
"char_from_code" => Token::Normal(NormalToken::CharFromCode),
"str_uppercase" => Token::Normal(NormalToken::StrUppercase),
"str_lowercase" => Token::Normal(NormalToken::StrLowercase),
"str_contains" => Token::Normal(NormalToken::StrContains),
"str_replace" => Token::Normal(NormalToken::StrReplace),
"str_replace_regex" => Token::Normal(NormalToken::StrReplaceRegex),
"str_is_match" => Token::Normal(NormalToken::StrIsMatch),
"str_match" => Token::Normal(NormalToken::StrMatch),
"str_length" => Token::Normal(NormalToken::StrLength),
"str_substr" => Token::Normal(NormalToken::StrSubstr),
"str_from" => Token::Normal(NormalToken::ToStr),
"num_from" => Token::Normal(NormalToken::NumFromStr),
"enum_from" => Token::Normal(NormalToken::EnumFromStr),

"{" => Token::Normal(NormalToken::LBrace),
"}" => Token::Normal(NormalToken::RBrace),
Expand Down
2 changes: 1 addition & 1 deletion src/operation.rs
View file
Open in desktop
Expand Up @@ -473,7 +473,7 @@ fn process_unary_operation(
} else {
Err(EvalError::TypeError(
String::from("Record"),
String::from("fieldsOf"),
String::from("fields"),
arg_pos,
RichTerm { term: t, pos },
))
Expand Down