juvix/tests/positive/Records2.juvix

module Records2;

import Stdlib.Data.Nat open;

type Pair (A B : Type) :=
  mkPair {
    pfst : A;
    psnd : B
  };

main : Pair Nat Nat :=
  let
    p : Pair Nat Nat := mkPair 2 2;
  in p@Pair{pfst := Pair.pfst p + Pair.psnd p};
Record updates (#2263) - Closes #1642. This pr introduces syntax for convenient record updates. Example: ``` type Triple (A B C : Type) := \| mkTriple { fst : A; snd : B; thd : C; }; main : Triple Nat Nat Nat; main := let p : Triple Nat Nat Nat := mkTriple 2 2 2; p' : Triple Nat Nat Nat := p @Triple{ fst := fst + 1; snd := snd * 3 }; f : Triple Nat Nat Nat -> Triple Nat Nat Nat := (@Triple{fst := fst * 10}); in f p'; ``` We write `@InductiveType{..}` to update the contents of a record. The `@` is used for parsing. The `InductiveType` symbol indicates the type of the record update. Inside the braces we have a list of `fieldName := newValue` items separated by semicolon. The `fieldName` is bound in `newValue` with the old value of the field. Thus, we can write something like `p @Triple{fst := fst + 1;}`. Record updates `X@{..}` are parsed as postfix operators with higher priority than application, so `f x y @X{q := 1}` is equivalent to `f x (y @X{q := 1})`. It is possible the use a record update with no argument by wrapping the update in parentheses. See `f` in the above example. 2023-08-07 13:35:36 +03:00			`module Records2;`

Literal casting (#2457) * Closes #2453 * Closes #2432 * Any nonnegative literal `n` is replaced with `fromNat {_} {{_}} n` where `fromNat` is the builtin conversion function defined in the `Natural` trait in `Stdlib.Trait.Natural`. * Any negative literal `-n` is replaced with `fromInt {_} {{_}} -n` where `fromInt` is the builtin conversion function defined in the `Integral` trait in `Stdlib.Trait.Integral`. * Before resolving instance holes, it is checked whether the type holes introduced for `fromNat` and `fromInt` have been inferred. If not, an attempt is made to unify them with `Nat` or `Int`. This allows to type-check e.g. `1 == 1` (there is no hint in the context as to what the type of `1` should be, so it is decided to be `Nat` after inferring the hole fails). 2023-11-03 12:01:03 +03:00			`import Stdlib.Data.Nat open;`
Record updates (#2263) - Closes #1642. This pr introduces syntax for convenient record updates. Example: ``` type Triple (A B C : Type) := \| mkTriple { fst : A; snd : B; thd : C; }; main : Triple Nat Nat Nat; main := let p : Triple Nat Nat Nat := mkTriple 2 2 2; p' : Triple Nat Nat Nat := p @Triple{ fst := fst + 1; snd := snd * 3 }; f : Triple Nat Nat Nat -> Triple Nat Nat Nat := (@Triple{fst := fst * 10}); in f p'; ``` We write `@InductiveType{..}` to update the contents of a record. The `@` is used for parsing. The `InductiveType` symbol indicates the type of the record update. Inside the braces we have a list of `fieldName := newValue` items separated by semicolon. The `fieldName` is bound in `newValue` with the old value of the field. Thus, we can write something like `p @Triple{fst := fst + 1;}`. Record updates `X@{..}` are parsed as postfix operators with higher priority than application, so `f x y @X{q := 1}` is equivalent to `f x (y @X{q := 1})`. It is possible the use a record update with no argument by wrapping the update in parentheses. See `f` in the above example. 2023-08-07 13:35:36 +03:00
			`type Pair (A B : Type) :=`
Fix formatting for all Juvix files in tests folder (#2404) In this PR, we ran the Juvix formatter so that we can now freely run `make format`, `make check`, or `make pre-commit` without any unexpected file changes. This goes after: - https://github.com/anoma/juvix/pull/2486 2023-10-31 20:36:34 +03:00			`mkPair {`
			`pfst : A;`
			`psnd : B`
			`};`
Record updates (#2263) - Closes #1642. This pr introduces syntax for convenient record updates. Example: ``` type Triple (A B C : Type) := \| mkTriple { fst : A; snd : B; thd : C; }; main : Triple Nat Nat Nat; main := let p : Triple Nat Nat Nat := mkTriple 2 2 2; p' : Triple Nat Nat Nat := p @Triple{ fst := fst + 1; snd := snd * 3 }; f : Triple Nat Nat Nat -> Triple Nat Nat Nat := (@Triple{fst := fst * 10}); in f p'; ``` We write `@InductiveType{..}` to update the contents of a record. The `@` is used for parsing. The `InductiveType` symbol indicates the type of the record update. Inside the braces we have a list of `fieldName := newValue` items separated by semicolon. The `fieldName` is bound in `newValue` with the old value of the field. Thus, we can write something like `p @Triple{fst := fst + 1;}`. Record updates `X@{..}` are parsed as postfix operators with higher priority than application, so `f x y @X{q := 1}` is equivalent to `f x (y @X{q := 1})`. It is possible the use a record update with no argument by wrapping the update in parentheses. See `f` in the above example. 2023-08-07 13:35:36 +03:00
Remove old function syntax (#2305) * Enables new function syntax in local let-declarations * Closes #2251 2023-08-24 12:20:09 +03:00			`main : Pair Nat Nat :=`
Record updates (#2263) - Closes #1642. This pr introduces syntax for convenient record updates. Example: ``` type Triple (A B C : Type) := \| mkTriple { fst : A; snd : B; thd : C; }; main : Triple Nat Nat Nat; main := let p : Triple Nat Nat Nat := mkTriple 2 2 2; p' : Triple Nat Nat Nat := p @Triple{ fst := fst + 1; snd := snd * 3 }; f : Triple Nat Nat Nat -> Triple Nat Nat Nat := (@Triple{fst := fst * 10}); in f p'; ``` We write `@InductiveType{..}` to update the contents of a record. The `@` is used for parsing. The `InductiveType` symbol indicates the type of the record update. Inside the braces we have a list of `fieldName := newValue` items separated by semicolon. The `fieldName` is bound in `newValue` with the old value of the field. Thus, we can write something like `p @Triple{fst := fst + 1;}`. Record updates `X@{..}` are parsed as postfix operators with higher priority than application, so `f x y @X{q := 1}` is equivalent to `f x (y @X{q := 1})`. It is possible the use a record update with no argument by wrapping the update in parentheses. See `f` in the above example. 2023-08-07 13:35:36 +03:00			`let`
			`p : Pair Nat Nat := mkPair 2 2;`
Non-recursive definitions (#3138) * Closes #2968 * Implements detection of function-like definitions, which either: - have some arguments on the left of `:`, or - have at least one clause. * Only function-like definitions are recursive. * Non-recursive definitions are not mutually recursive either, and can be used only after their definition. This necessitates rearranging some definitions in existing Juvix code. * Changes the scoping of identifiers in record updates. Now field names on the right side don't refer to the old values of the record fields but to identifiers in scope defined outside the record update. To refer to old values, one needs to explicitly use record projections, e.g. ``` r@Rec{x := Rec.x r} ``` 2024-11-04 18:31:30 +03:00			`in p@Pair{pfst := Pair.pfst p + Pair.psnd p};`