Get rid of the original encoding of Nix strings

Directly using Nickel's encoding for symbolic strings is as powerful,
and simpler since it means that `nix-s%"blah"%` is a valid Nix string,
while we previously had to explicitly apply the `NixString` contract.

lib/contracts.ncl

@@ -14,16 +14,6 @@ let predicate | doc "Various predicates used to define contracts"
       std.is_record x
       && std.record.has_field type_field x
       && x."%{type_field}" == "nixInput",
-    is_nix_symbolic_string = fun value =>
-      std.is_record value
-      && std.record.has_field "tag" value
-      && value.tag == 'SymbolicString
-      && std.record.has_field "prefix" value
-      && value.prefix == 'nix,
-    is_nix_string = fun value =>
-      std.is_record value
-      && std.record.has_field type_field value
-      && value."%{type_field}" == "nixString",
     is_nickel_derivation = fun x =>
       std.is_record x
       && std.record.has_field type_field x
@@ -39,13 +29,6 @@ let predicate | doc "Various predicates used to define contracts"
   }
   in
 
-let mk_nix_string = fun fs =>
-  {
-    "%{type_field}" = "nixString",
-    fragments = fs,
-  }
-in
-
 {
   # Nix may require name, version, etc. to have a certain format, but we're not sure.
   # TODO: refine those contracts
@@ -154,14 +137,8 @@ from the Nix world) or a derivation defined in Nickel.
       `lib.import_file`), pure Nickel strings, and maybe more in the future.
     "%%
     = fun label value =>
-      # A contract must always be idempotent (be a no-op if applied a second
-      # time), so we accept something that is already a NixString
-      if predicate.is_nix_string value || predicate.is_nix_symbolic_string value then
-        value
-        # We accept a single string fragment (a plain string, a derivation or a
-        # Nix path). We normalize it by wrapping it into symbolic string
-      else if predicate.is_string_fragment value then
-        nix-s%"%{std.contract.apply NixStringFragment label value}"%
+      if predicate.is_string_fragment value then
+        std.contract.apply NixStringFragment label value
       else
         std.contract.apply NixSymbolicString label value,
 

lib/lib.nix

@@ -94,8 +94,6 @@
             value.nix_drv);
           in
             derivation prepared
-          else if organistType == "nixString" || (organistType == "" && value.tag or "" == "SymbolicString" && value.prefix or "" == "nix")
-          then builtins.concatStringsSep "" (builtins.map importFromNickel_ value.fragments)
           else if organistType == "nixPath"
           then baseDir + "/${value.path}"
           else if organistType == "nixInput"
@@ -116,6 +114,8 @@
             lib.getAttrFromPath chosenAttrPath flakeInputs
           else if organistType == "nixPlaceholder"
           then builtins.placeholder value.output
+          else if value.tag or "" == "SymbolicString" && value.prefix or "" == "nix"
+          then builtins.concatStringsSep "" (builtins.map importFromNickel_ value.fragments)
           else builtins.mapAttrs (_: importFromNickel_) value
       )
     else if (type == "list")