1. 04 Oct, 2018 1 commit
  2. 28 Sep, 2018 1 commit
    • Raphael Rieu-Helft's avatar
      Add support for partial functions · 17ed1270
      Raphael Rieu-Helft authored
      Program functions can be declared as partial with "let/val partial".
      Similarly to "diverges", partial code cannot be ghost, however it does not need to be
      explicitly specified as partial.
      
      Fixes #184.
      17ed1270
  3. 21 Jun, 2018 1 commit
  4. 01 Jun, 2018 1 commit
  5. 20 Mar, 2018 2 commits
  6. 11 Jan, 2018 1 commit
  7. 13 Dec, 2017 1 commit
  8. 01 Dec, 2017 1 commit
  9. 28 Nov, 2017 1 commit
    • Andrei Paskevich's avatar
      Ity: "spoil" effect on type variables · 330bd7e5
      Andrei Paskevich authored
      Type variables that appear in the result types of "pure"
      or logical functions are "spoiled" and cannot be instantiated
      with mutable types. Abstract program functions ("val") are assumed
      to not spoil type variables, and no explicit effect annotation is
      provided for this effect. Constructors, projections, and function
      application do not spoil type variables.
      
      This effect prevent unsoundness that results from instantiating
      [constant magic : 'a] with a mutable type in a program. It is,
      however, less precise than tracking of magic values using
      pure type variables. For example, the following program
      does typecheck with pure type variables but not with the
      spoil effects.
      
        use seq.Seq
      
        type ref_hist 'a = {
                mutable contents : 'a;
          ghost mutable history  : Seq.seq {'a}
        }
      
        let (:=) (r : ref_hist 'a) (v : 'a) =
          r.history <- Seq.cons (pure { r.contents }) r.history;
          r.contents <- v
      
        let test (r : ref_hist (ref_hist unit)) =
          r := r.contents
      
      Indeed, (:=) spoils 'a, and precludes it from being instantiated
      with a mutable type in "test".
      330bd7e5
  10. 23 Nov, 2017 1 commit
  11. 20 Nov, 2017 1 commit
  12. 05 Jun, 2017 1 commit
  13. 22 May, 2017 1 commit
  14. 23 Apr, 2017 1 commit
  15. 21 Apr, 2017 1 commit
  16. 12 Apr, 2017 1 commit
  17. 28 Feb, 2017 1 commit
    • Clément Fumex's avatar
      Add the ability to · f0547868
      Clément Fumex authored
      * declare range types and float types,
      * use integer (resp. real) literals for those types through casting,
      * specify how to print them in drivers.
      
      Change in syntax
      * use
      
        type t = < range 1 2 >   (* integers from 1 to 2 *)
        type t' = < float 4 12 > (* float with 4 bits in exponent and 12 in mantissa *)
      
        the two projections :
        t'int
        t''real
      
        and the predicate :
        t''isFinite
      
      * Restrict the use of "'" in whyml:
        Users are not allowed to introduce names where a quote symbol
        is followed by a letter. Thus, the following identifiers are
        valid:
      
        t'
        toto'0''
        toto'_phi
      
        whereas toto'phi is not.
      
      Note: we do not yet support negative numbers in range declaration
      and casting of a literal.
      f0547868
  18. 15 Feb, 2017 1 commit
  19. 20 Jan, 2017 1 commit
  20. 19 Jan, 2017 2 commits
  21. 17 Jan, 2017 1 commit
  22. 01 Jan, 2017 1 commit
  23. 15 Mar, 2016 3 commits
  24. 05 Mar, 2016 1 commit
  25. 25 Feb, 2016 1 commit
  26. 24 Feb, 2016 1 commit
  27. 16 Feb, 2016 1 commit
  28. 24 Jan, 2016 1 commit
  29. 17 Jan, 2016 1 commit
  30. 11 Jan, 2016 1 commit
    • Andrei Paskevich's avatar
      Mlw: non-ghost unit expressions have MaskVisible · e12222bc
      Andrei Paskevich authored
      This makes "let f ... : unit = <effect> ; <ghost effect>" acceptable
      without ghostness annotation in the result.
      
      However, "let f ... : unit = <ghost effect>" is still required to
      be marked ghost (unless f is a local non-recursive function).
      e12222bc
  31. 10 Jan, 2016 1 commit
    • Andrei Paskevich's avatar
      Mlw: allow non-ghost expressions to return (partially) ghost values · 4c79348a
      Andrei Paskevich authored
      this is still work in progress and no testing was done so far.
      
      Highlights of this commit:
      
      - "(ghost 42, 15)" is now a non-ghost expression that can be returned
        from a function and/or matched against a "(ghost x, y)" pattern.
        Only the tuple constructor and direct pattern matching are magical:
        "let z = (ghost 42, 15) in ..." still makes z ghost, and therefore
        "snd (ghost 42, 15)" is ghost, too.
      
      - "if c then e1 else ghost e2" and "let z = e1 in ghost e2" are now
        non-ghost expressions with a ghost result. This means that e1 may
        have visible effects. Of course, if e2 raises exceptions, the whole
        expression is ghostified. Contamination is still done when possible,
        that is, when the contaminated expression has no visible effects.
      
      - "let ghost x = e1 in e2" no longer ghostifies e1.
      
      - "let f (ghost x) = ... in f e1" no longer ghostifies e1.
      
      - new syntax: variables in program patterns may be marked ghost.
        In particular: "let x, ghost y = ...".
      
      - new syntax: the function result type may be written as a partially
        ghost tuple: "val f ... : ghost int" or "any (int, ghost bool)".
        The ghostness annotation is required for top-level and recursive
        functions.
      
      - exceptions can carry partially ghost tuples (API only, WIP)
      4c79348a
  32. 07 Dec, 2015 2 commits
  33. 24 Nov, 2015 1 commit
  34. 15 Nov, 2015 1 commit
    • Andrei Paskevich's avatar
      Mlw: admit fields with mutable types in private records · f522e56e
      Andrei Paskevich authored
      this should not be problematic as long as these fields do not occur
      in the invariants (actual or refined). In other words, a value of
      a private type exists no matter what is stored in the field.
      
      Also, admit non-private mutable types without actual mutable fields.
      It is actually impossible to create a write effect for such types,
      and the only consequence of being mutable is that they are assigned
      a region, and so every value of such type can be tracked individually.
      One use case for this is a non-private record with an invariant,
      which either has fields with mutable types or has type parameters
      that we wish to instantiate with mutable types. If we modify these
      mutable components, this may break the record's invariant. Now, if
      the record itself is immutable (and thus has no associated region),
      then we must reestablish the invariant immediately, otherwise we
      lose track of the value. Even if this extra flexibility does not
      prove useful in the end, it seems to be harmless.
      
      Also, admit type definitions of the form
        type t 'a = (private|abstract)? mutable? {} invariant*
      which define private empty records (even if not declared private).
      
      Also, "type t 'a" is now equivalent to "type t 'a = private {}".
      f522e56e
  35. 13 Nov, 2015 1 commit