the case for Namespace Casing

[arcnmx]

So my std wrapper makes a few design decisions in contrast to nix-stdʼs:

1. modules use upper-case for namespace reasons: so std.list becomes std.List
   • because itʼs too easy to (accidentally) shadow the std.xxx modules with local variables and function argument names
   • just look at how imports = { ... } is often used in std for this reason
   • and _optional = std.optional
2. "methods" vs "constructors" and sub-namespaces are similarly distinguished: Set.Optional vs set.optional for example
   • this one seems less important? but I think there may be some value in it
   • list.functor may also benefit from being List.Functor?
3. splits up std.num into std.Int, std.Float and std.Complex
   • the std.num.complex sort of "sub-namespace" convention may or may not be desirable?
4. more succinct names are used for modules and functions:
   • std.function is std.Fn
   • Str rather than string
   • List.One vs list.singleton
5. types are accessable via the associated module:
   • std.Str.Type as an alias for std.Ty.string
   • std.Set.Of as an alias for std.Ty.attrsOf
   • std.Set.check as an alias for std.Ty.attrs.check
     • same goes for show
6. modules themselves are also __functors that perform coercion:
   • std.Str 5 == "5"
   • std.List 5 == std.List [5] == [5]

While Iʼm not necessarily proposing that these changes be adopted, I figure I should at least bring attention to them for reference and discussion, as they were things that generally came to me as improvements or pain points as I started using std more for projects.

[chessai]

need to think about this. it seems like a good idea at first glance.

[chessai]

(0) if everything else is capitalised, i think Std should be too (personal preference)

(1) is currently a big UX problem IMO; +1
(2) agree that it's good, also agree that it is not as important; +0.5
(3) yeah that's probably a good idea. and Std.Num can maybe be common stuff. unsure. +0.5
(4) i agree with Fn vs Function, not sure about Str vs String. it's probably fine as Str. +0.75
(5) i like this change a lot. +1
(6) modules as function objects? i don't like that idea. IMO people should just use functions. in your examples, the first thing is just show, the second is singleton. -1

[chessai]

TLDR i'm in favour of this change. let's do it. minus the modules as function objects.

[arcnmx]

(3) yeah that's probably a good idea. and Std.Num can maybe be common stuff. unsure. +0.5

It just currently seems like a bit of a large and somewhat disorganized module imo, and the addition of .Type encouraged me to reorganize it into something more aligned to the value types the functions operate on, pulling out the integer and floating point specific functions. There is indeed a lot of overlap in the form of operators though, so Num would make sense to remain for that. There probably should be a types.num = types.either types.int types.float anyway!

While num.min, num.max and num.compare are also common, I'd argue that they should be moved out to a Cmp module, since other types like strings can be compared too! I did actually end up wanting such a module for use with tests: cmp.nix.

(6) modules as function objects? i don't like that idea. IMO people should just use functions. in your examples, the first thing is just show, the second is singleton. -1

Fair enough, it's not particularly intuitive or important. There is a sort of consistency to it though:

• Std.Str.__functor = _: builtins.toString
• Std.List.__functor = _: nixpkgs.lib.toList

It's just shorthand for what's often called toX, which is typically a sort of cast operation (casting to string is distinct from string.show), but they also typically have explicit names you can use anyway. I could also see this being a .cast or similar method on the type instead (so like have Ty.list.cast alongside check and show, and maybe even add .of for List.Type.of or something).

[chessai]

okay, you've convinced me on the Num stuff, I'm +1 on that now too.

as for the function object thing, still not sure. but we should just do everything else and see how it feels.