In reply to @infinisil:matrix.org
piegames: No concrete proposals yet, and I'm not working on it myself

In reply to @piegames:matrix.org
Are there any specific proposals for how a Nix module builtin might look like?

Playing mindgames:

If types are values. We could extend the language by type-values. e.g.

Primitives:
Number, ...
Composed:
Set, List, ...

{
  /* A type contract, foo must be a number*/
  foo = Number;
} & 
{
  /* foo is '1' */
  foo = 1;
}

{}

In reply to @piegames:matrix.org
Are there any specific proposals for how a Nix module builtin might look like?

Playing mindgames:

If types are values. We could extend the language by type-values. e.g.

Primitives:
Number, ...
Composed:
Set, List, ...

{
  /* A type contract, foo must be a number*/
  foo = Number;
} & 
{
  /* foo is '1' */
  foo = 1;
}

Introducing new keywords for types ^^

Playing mindgames:

If types are values. We could extend the language by type-values. e.g.

Primitives:
Number, ...
Composed:
Set, List, ...

{
  /* A type contract, foo must be a number*/
  foo = Number;
} & 
{
  /* foo is '1' */
  foo = 1;
}

Introducing new keywords for types ^^
and the merge operator &

let 
  partialFoo = {
  nested = {
     foo = Number:
  };
}
in
 partialFoo & {
  nested.foo = 1;
}

You can even use that value as type contract in any other place. e.g. if you want to say that bar is also of type foo.

{
  bar = partialFoo & {
   nested.foo = 2; 
  }
}

I kind of like the simplicity.

let 
  partialFoo = {
    nested = {
      foo = Number:
    };
}
in
  partialFoo & {
    nested.foo = 1;
  }

You can even use that value as type contract in any other place. e.g. if you want to say that bar is also of type foo.

{
  bar = partialFoo & {
   nested.foo = 2; 
  }
}

I kind of like the simplicity.

let 
  partialFoo = {
    nested = {
      foo = Number:
    };
  };
in
  partialFoo & {
    nested.foo = 1;
  }

You can even use that value as type contract in any other place. e.g. if you want to say that bar is also of type foo.

{
  bar = partialFoo & {
   nested.foo = 2; 
  }
}

I kind of like the simplicity.

FWIW, In Nickel, currently you can't merge a contract and a number directlylike Number & 1 (maybe it would make sense to do that, but at least for now, we don't). However, because record contracts are no different from normal records (they are just more likely to have mostly annotations and yet-to-be-defined values), there is in theory two ways to "apply" a record contract. One is by setting the contract using =, as in Johannes Kirschbauer @hsjobeki 's example above:

let Contract = { foo | Number } in
{
  inner = Contract
} & {
  inner.foo = 1
}

Merge will be applied recursively and combine {bar = 1} with {bar | Number} and end up checking that 1 is a Number. However, usually what you want is to use an annotation/metadata (|) instead:

{
  inner | Contract
} & {
  inner.foo = 1
}

The difference is that the second form is more restrictive: it says "attach a contract Contract to inner". Attaching a contract propagates through merging, even if you override. That is, it means inner can never be changed or updated by merging to something that doesn't respect the initial contract. In particular, the contract is closed by default, meaning you can't add new values (for that, you have to add an ..), while solely merging records propagate the subcontracts but you can always merge with new stuff. Attaching a contract is thus more similar to the CUE model, it "refines" a value with a constraint, and merging just refines more and more.

For example:

nickel> { inner = Contract } & { inner.foo = 1} & {inner.bar = "hello"}
{ inner = { bar = "hello", foo | Number = 1, }, }

# turning the `=` into `|` makes it stricter
nickel> { inner | Contract } & { inner.foo = 1} & {inner.bar = "hello"}
error: contract broken by the value of `inner`: extra field `bar`
[...]

# With `=`, we can override the whole contract
nickel> { inner = Contract } & { inner | force = "something totally different"}
{ inner | force = "something totally different", }

# `|` doesn't let you do that
nickel> {inner | Contract} & { inner | force  = "something totally different"}
error: contract broken by the value of `inner`
[...]