Is there a language with constrainable types?

Is there a typed programming language where I can constrain types like the following two examples?

type Probability subtype of float
where
    max_value = 0.0
    min_value = 1.0

type DPD<K> subtype of map<K, Probability>
where
    sum(values) = 1.0

As far as I understand, this is not possible with Haskell or Agda.

What you want is called refinement types.

It's possible to define Probability in Agda: Prob.agda

The probability mass function type, with sum condition is defined at line 264.

There are languages with more direct refinement types than in Agda, for example ATS

You can do this in Haskell with Liquid Haskell which extends Haskell with refinement types. The predicates are managed by an SMT solver at compile time which means that the proofs are fully automatic but the logic you can use is limited by what the SMT solver handles. (Happily, modern SMT solvers are reasonably versatile!)

One problem is that I don't think Liquid Haskell currently supports floats. If it doesn't though, it should be possible to rectify because there are theories of floating point numbers for SMT solvers. You could also pretend floating point numbers were actually rational (or even use Rational in Haskell!). With this in mind, your first type could look like this:

{p : Float | p >= 0 && p <= 1}

Your second type would be a bit harder to encode, especially because maps are an abstract type that's hard to reason about. If you used a list of pairs instead of a map, you could write a "measure" like this:

measure total :: [(a, Float)] -> Float
total []          = 0 
total ((_, p):ps) = p + probDist ps

(You might want to wrap [] in a newtype too.)

Now you can use total in a refinement to constrain a list:

{dist: [(a, Float)] | total dist == 1}

The neat trick with Liquid Haskell is that all the reasoning is automated for you at compile time, in return for using a somewhat constrained logic. (Measures like total are also very constrained in how they can be written—it's a small subset of Haskell with rules like "exactly one case per constructor".) This means that refinement types in this style are less powerful but much easier to use than full-on dependent types, making them more practical.

Perl6 has a notion of "type subsets" which can add arbitrary conditions to create a "sub type."

For your question specifically:

subset Probability of Real where 0 .. 1;

and

role DPD[::T] {
  has Map[T, Probability] $.map
    where [+](.values) == 1; # calls `.values` on Map
}

(note: in current implementations, the "where" part is checked at run-time, but since "real types" are checked at compile-time (that includes your classes), and since there are pure annotations ( is pure ) inside the std (which is mostly perl6) (those are also on operators like * , etc), it's only a matter of effort put into it (and it shouldn't be much more).

More generally:

# (%% is the "divisible by", which we can negate, becoming "!%%")
subset Even of Int where * %% 2; # * creates a closure around its expression
subset Odd of Int where -> $n { $n !%% 2 } # using a real "closure" ("pointy block")

Then you can check if a number matches with the Smart Matching operator ~~ :

say 4 ~~ Even; # True
say 4 ~~ Odd; # False
say 5 ~~ Odd; # True

And, thanks to multi sub s (or multi whatever, really – multi methods or others), we can dispatch based on that:

multi say-parity(Odd $n) { say "Number $n is odd" }
multi say-parity(Even) { say "This number is even" } # we don't name the argument, we just put its type
#Also, the last semicolon in a block is optional

上一篇: 在Agda停止问题？

下一篇: 有限制类型的语言吗？