make trapdoor purely safe

nt/primitives/bootstrap/trapdoor.nix

@@ -1,8 +1,7 @@
 {this, ...}: let
   inherit
     (builtins)
-    attrNames
+    isAttrs
-    elem
     isFunction
     ;
 
@@ -10,7 +9,12 @@
     (this.std)
     enfHasAttr
     enfHasAttrUnsafe
-    enfIsAttrs
+    ;
+
+  inherit
+    (this.types)
+    Some
+    None
     ;
 in rec {
   masterkey = "_''traps''_";
@@ -21,38 +25,61 @@ in rec {
     assert enfHasAttr "default" decl "mkTrapdoorFn";
     assert enfHasAttrUnsafe "unlock" decl "mkTrapdoorFn";
     # return trapdoor function
-      (x: let
+      (x:
-        keys = attrNames decl.unlock;
+        if key == masterkey
-      in
+        then decl.unlock
-        if elem key keys
+        else decl.default x);
-        then decl.unlock.${key}
-        else if key == masterkey
-        then keys
-        else decl.default);
 
   mkTrapdoorSet = key: decl:
     assert enfHasAttr "default" decl "mkTrapdoorSet";
     assert enfHasAttrUnsafe "unlock" decl "mkTrapdoorSet";
     # return trapdoor set
-      let
+      decl.default
-        keys = attrNames decl.unlock;
+      // {
-      in
+        ${masterkey} = decl.unlock;
-        decl.default
+      };
-        // {
-          ${key} = decl.unlock.${key};
-          ${masterkey} = keys;
-        };
-  revealTrapdoors = openTrapdoor masterkey;
 
-  openTrapdoorFn = key: f: f key;
+  # XXX: TODO: should we just remove all unsafe functions here?
+  # revealTrapdoorsUnsafe = openTrapdoorUnsafe masterkey;
+  #
+  # openTrapdoorFnUnsafe = key: T: (T masterkey).${key};
+  # openTrapdoorSetUnsafe = key: T: T.${masterkey}.${key};
+  #
+  # openTrapdoorUnsafe = key: T:
+  #   if isFunction T
+  #   then openTrapdoorFnUnsafe key T
+  #   else openTrapdoorSetUnsafe key T;
 
-  openTrapdoorSet = key: xs: xs.${key};
+  isTrapdoorFnKey = key: T: isFunction T && (T masterkey) ? ${key};
+
+  isTrapdoorSetKey = key: T:
+    if T ? ${masterkey}
+    then T.${masterkey} ? ${key}
+    else false;
+
+  isTrapdoorKey = key: T:
+    if isAttrs T
+    then isTrapdoorSetKey key T
+    else isTrapdoorFnKey key T;
+
+  openTrapdoorFn = key: T: let
+    unlock = T masterkey;
+  in
+    if isFunction T && unlock ? ${key}
+    then Some unlock.${key}
+    else None;
+
+  openTrapdoorSet = key: T: let
+    unlock = T.${masterkey};
+  in
+    if T ? ${masterkey} && unlock ? ${key}
+    then Some unlock.${key}
+    else None;
 
-  # TODO: implement a function called enfIsTypeAny (for cases like this where it might be function or set)
   openTrapdoor = key: T:
     if isFunction T
     then openTrapdoorFn key T
-    else
+    else if isAttrs T
-      assert enfIsAttrs T "openTrapdoor";
+    then openTrapdoorSet key T
-        openTrapdoorSet key T;
+    else None;
 }