Merge pull request #518 from tweag/snake_case

Switch to snake_case by convention for values
tweag · Dec 29, 2021 · 033ed33 · 033ed33
2 parents 27dc663 + c0c2fda
commit 033ed33
Show file tree

Hide file tree

Showing 25 changed files with 283 additions and 282 deletions.
diff --git a/examples/config-gcc/config-gcc.ncl b/examples/config-gcc/config-gcc.ncl
@@ -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
@@ -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."
            | #Path
            | #SharedObjectFile
            | default = "/lib/x86_64-linux-gnu/libc.so",
@@ -63,7 +63,7 @@ let Contract = {
         | List #GccFlag
         | default = [],
 
-  optimizationLevel | doc "
+  optimization_level | doc "
                        Optimization level. Possible values:
 
                         - *0*: unoptimized
@@ -76,5 +76,5 @@ let Contract = {
 
 {
   flags = ["Wextra", {flag = "o", arg = "stuff.o"}],
-  optimizationLevel = 2,
+  optimization_level = 2,
 } | #Contract
diff --git a/examples/lists/lists.ncl b/examples/lists/lists.ncl
@@ -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
@@ -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
diff --git a/examples/merge/security.ncl b/examples/merge/security.ncl
@@ -3,5 +3,5 @@
 
   firewall.enabled | default = true,
   firewall.type = "iptables",
-  firewall.openPorts = [21,80,443],
+  firewall.open_ports = [21, 80, 443],
 }
diff --git a/examples/record-contract/record-contract.ncl b/examples/record-contract/record-contract.ncl
@@ -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

diff --git a/examples/simple-contracts/simple-contract-bool.ncl b/examples/simple-contracts/simple-contract-bool.ncl
@@ -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

diff --git a/examples/simple-contracts/simple-contract-div.ncl b/examples/simple-contracts/simple-contract-div.ncl
@@ -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

diff --git a/src/grammar.lalrpop b/src/grammar.lalrpop
@@ -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 = {
@@ -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),
 }
 
@@ -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),

diff --git a/src/operation.rs b/src/operation.rs
@@ -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 },
                 ))