├── .gitignore
├── Cargo.toml
├── LICENSE
├── README.md
├── src
    ├── bin
    │   └── f_ing.rs
    ├── lib.rs
    ├── rrd2014.rs
    └── rrd2014
    │   ├── internal.rs
    │   ├── internal
    │       └── dynamic.rs
    │   └── parser.rs
└── tests
    └── integration.rs


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | **/*.rs.bk
3 | Cargo.lock


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "modules"
 3 | version = "0.1.0"
 4 | authors = ["elpinal"]
 5 | edition = "2018"
 6 | 
 7 | [dependencies]
 8 | colored = "1.7"
 9 | failure = "0.1.3"
10 | structopt = "0.2"
11 | 
12 | [dev-dependencies.cargo-husky]
13 | version = "1"
14 | default-features = false
15 | features = ["precommit-hook", "run-cargo-clippy", "run-cargo-fmt"]
16 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 El Pin Al
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Modules
 2 | 
 3 | This repository contains an interpreter of F-ing modules in Rust.
 4 | 
 5 | ## Install
 6 | 
 7 | Use nightly releases of Rust.
 8 | 
 9 | ```
10 | $ cargo install --git https://github.com/elpinal/modules-rs
11 | ```
12 | 
13 | ## Usage
14 | 
15 | ```
16 | $ f_ing
17 | f-ing 0.1.0
18 | F-ing modules.
19 | 
20 | USAGE:
21 |     f_ing <SUBCOMMAND>
22 | 
23 | FLAGS:
24 |     -h, --help       Prints help information
25 |     -v, --version    Prints version information
26 | 
27 | SUBCOMMANDS:
28 |     exec                  Executes a program.
29 |     help                  Prints this message or the help of the given subcommand(s)
30 |     parse                 Parses a program.
31 |     typecheck             Typechecks a program.
32 |     typecheck-internal    Translates a program into an internal program, and then typechecks it to ensure type
33 |                           soundness.
34 | ```
35 | 
36 | ## See also
37 | 
38 | - [elpinal/modules](https://github.com/elpinal/modules)
39 | contains my previous implementation of F-ing modules in Haskell.
40 | 
41 | ## Reference
42 | 
43 | Andreas Rossberg, Claudio V. Russo and Derek Dreyer.  
44 | F-ing modules.  
45 | Journal of Functional Programming, 24(5), 2014.  
46 | [PDF](https://people.mpi-sws.org/~rossberg/f-ing/f-ing-jfp.pdf).
47 | 


--------------------------------------------------------------------------------
/src/bin/f_ing.rs:
--------------------------------------------------------------------------------
  1 | use structopt::StructOpt;
  2 | 
  3 | use failure::format_err;
  4 | use failure::Error;
  5 | use failure::ResultExt;
  6 | 
  7 | use colored::*;
  8 | 
  9 | use modules::rrd2014;
 10 | use modules::rrd2014::internal;
 11 | use modules::rrd2014::internal::dynamic;
 12 | use modules::rrd2014::parser;
 13 | use modules::rrd2014::Module;
 14 | 
 15 | macro_rules! exitln {
 16 |     ( $code:expr, $($x:expr),* ) => {
 17 |         {
 18 |             eprintln!($($x),*);
 19 |             std::process::exit($code);
 20 |         }
 21 |     }
 22 | }
 23 | 
 24 | #[derive(StructOpt, Debug)]
 25 | #[structopt(name = "f-ing", author = "", version_short = "v")]
 26 | /// F-ing modules.
 27 | enum Opt {
 28 |     #[structopt(name = "parse")]
 29 |     /// Parses a program.
 30 |     Parse {
 31 |         /// Input filename
 32 |         #[structopt(name = "filename")]
 33 |         file: String,
 34 |     },
 35 | 
 36 |     #[structopt(name = "typecheck")]
 37 |     /// Typechecks a program.
 38 |     Typecheck {
 39 |         /// Input filename
 40 |         #[structopt(name = "filename")]
 41 |         file: String,
 42 | 
 43 |         /// Output filename
 44 |         #[structopt(short = "o")]
 45 |         output: Option<String>,
 46 |     },
 47 | 
 48 |     #[structopt(name = "typecheck-internal")]
 49 |     /// Translates a program into an internal program, and then typechecks it to ensure type
 50 |     /// soundness.
 51 |     TypecheckInternal {
 52 |         /// Input filename
 53 |         #[structopt(name = "filename")]
 54 |         file: String,
 55 |     },
 56 | 
 57 |     #[structopt(name = "exec")]
 58 |     /// Executes a program.
 59 |     Exec {
 60 |         /// Input filename
 61 |         #[structopt(name = "filename")]
 62 |         file: String,
 63 |     },
 64 | }
 65 | 
 66 | fn main() {
 67 |     if let Err(e) = run(Opt::from_args()) {
 68 |         exitln!(1, "{}", e);
 69 |     }
 70 | }
 71 | 
 72 | fn run(opt: Opt) -> Result<(), Error> {
 73 |     match opt {
 74 |         Opt::Parse { file } => {
 75 |             println!("{:?}", parse(file)?);
 76 |         }
 77 |         Opt::Typecheck { file, output } => match elaborate(parse(file)?)? {
 78 |             (t, asig, _) => {
 79 |                 println!("{}:", "signature".bright_cyan().bold());
 80 |                 println!("{:?}", asig);
 81 |                 println!();
 82 |                 println!("{}:", "translated F\u{03c9} term".bright_cyan().bold());
 83 |                 println!("{:?}", t);
 84 |                 if let Some(f) = output {
 85 |                     std::fs::write(f, format!("{:#?}", t))?;
 86 |                 }
 87 |             }
 88 |         },
 89 |         Opt::TypecheckInternal { file } => match elaborate(parse(file)?)? {
 90 |             (t, asig, gtenv) => {
 91 |                 let ty = internal::typecheck(&t, gtenv).with_context(|e| {
 92 |                     format!(
 93 |                         "{}:\n{}",
 94 |                         "[bug(unsound)] internal type error".bright_red().bold(),
 95 |                         e
 96 |                     )
 97 |                 })?;
 98 |                 let expect = asig.into();
 99 |                 if ty.equal(&expect) {
100 |                     println!("{}", "The translation is sound.".bright_green().bold());
101 |                     println!("{}", "internal type:".bright_cyan().bold());
102 |                     println!("{:?}", ty);
103 |                 } else {
104 |                     Err(format_err!(
105 |                         "{}:\ntype mismatch:\n{:?}\nand\n{:?}",
106 |                         "[bug] invariant violation".bright_red().bold(),
107 |                         ty,
108 |                         expect
109 |                     ))?;
110 |                 }
111 |             }
112 |         },
113 |         Opt::Exec { file } => match elaborate(parse(file)?)? {
114 |             (t, asig, gtenv) => {
115 |                 let ty = internal::typecheck(&t, gtenv).with_context(|e| {
116 |                     format!(
117 |                         "{}:\n{}",
118 |                         "[bug(unsound)] internal type error".bright_red().bold(),
119 |                         e
120 |                     )
121 |                 })?;
122 |                 let expect = asig.into();
123 |                 if ty.equal(&expect) {
124 |                     let v = dynamic::reduce(t)?;
125 |                     println!("{}:", "result".bright_green().bold());
126 |                     println!("{:?}", v);
127 |                 } else {
128 |                     Err(format_err!(
129 |                         "{}:\ntype mismatch:\n{:?}\nand\n{:?}",
130 |                         "[bug] invariant violation".bright_red().bold(),
131 |                         ty,
132 |                         expect
133 |                     ))?;
134 |                 }
135 |             }
136 |         },
137 |     }
138 |     Ok(())
139 | }
140 | 
141 | fn parse<P>(file: P) -> Result<Module, Error>
142 | where
143 |     P: AsRef<std::path::Path>,
144 | {
145 |     parser::parse_file(&file)
146 | }
147 | 
148 | fn elaborate(
149 |     m: Module,
150 | ) -> Result<(internal::Term, rrd2014::AbstractSig, Vec<internal::Kind>), Error> {
151 |     Ok(rrd2014::elaborate(m)
152 |         .with_context(|e| format!("{}:\n{}", "type error".bright_red().bold(), e))?)
153 | }
154 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | //! Modules
 2 | 
 3 | #![feature(bind_by_move_pattern_guards)]
 4 | #![feature(never_type)]
 5 | #![feature(try_from)]
 6 | 
 7 | pub mod rrd2014;
 8 | 
 9 | use failure::bail;
10 | use failure::Fallible;
11 | 
12 | use rrd2014::internal;
13 | use rrd2014::internal::dynamic;
14 | use rrd2014::parser;
15 | 
16 | pub fn exec<I>(src: I) -> Fallible<()>
17 | where
18 |     I: IntoIterator<Item = char>,
19 | {
20 |     let t = typecheck(src)?;
21 |     let _ = dynamic::reduce(t)?;
22 |     Ok(())
23 | }
24 | 
25 | pub fn typecheck<I>(src: I) -> Fallible<internal::Term>
26 | where
27 |     I: IntoIterator<Item = char>,
28 | {
29 |     let m = parser::parse(src)?;
30 |     let (t, asig, gtenv) = rrd2014::elaborate(m)?;
31 |     let ty = internal::typecheck(&t, gtenv)?;
32 |     let expected = asig.into();
33 |     if !ty.equal(&expected) {
34 |         bail!("invariant violation");
35 |     }
36 |     Ok(t)
37 | }
38 | 


--------------------------------------------------------------------------------
/src/rrd2014/internal.rs:
--------------------------------------------------------------------------------
   1 | //! The internal language.
   2 | 
   3 | use std::borrow::Cow;
   4 | use std::collections::HashMap;
   5 | use std::collections::HashSet;
   6 | use std::convert::TryFrom;
   7 | use std::hash::BuildHasher;
   8 | use std::hash::Hash;
   9 | use std::iter::FromIterator;
  10 | 
  11 | use failure::Fail;
  12 | 
  13 | use super::BinOp;
  14 | use super::Purity;
  15 | 
  16 | pub mod dynamic;
  17 | 
  18 | #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
  19 | pub struct Name(String);
  20 | 
  21 | #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
  22 | pub enum Label {
  23 |     Label(Name),
  24 | }
  25 | 
  26 | #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
  27 | pub enum Variable {
  28 |     Variable(usize),
  29 |     Generated(usize),
  30 | }
  31 | 
  32 | use Variable::Variable as V;
  33 | 
  34 | #[derive(Clone, Debug, PartialEq)]
  35 | pub struct Record<T>(HashMap<Label, T>);
  36 | 
  37 | #[derive(Clone, Debug, PartialEq)]
  38 | pub enum Kind {
  39 |     Mono,
  40 |     Fun(Box<Kind>, Box<Kind>),
  41 | }
  42 | 
  43 | #[derive(Clone, Debug, PartialEq)]
  44 | pub enum Type {
  45 |     Var(Variable),
  46 |     Fun(Box<Type>, Box<Type>),
  47 |     Record(Record<Type>),
  48 | 
  49 |     /// A universal type.
  50 |     Forall(Kind, Box<Type>),
  51 | 
  52 |     /// An existential type.
  53 |     Some(Kind, Box<Type>),
  54 | 
  55 |     Abs(Kind, Box<Type>),
  56 |     App(Box<Type>, Box<Type>),
  57 |     Int,
  58 |     Bool,
  59 | }
  60 | 
  61 | #[derive(Clone, Debug, PartialEq)]
  62 | pub enum Term {
  63 |     Var(Variable),
  64 |     Abs(Type, Box<Term>),
  65 |     App(Box<Term>, Box<Term>),
  66 |     Record(Record<Term>),
  67 | 
  68 |     /// A projection from a record via a label.
  69 |     Proj(Box<Term>, Label),
  70 | 
  71 |     /// A polymorphic function.
  72 |     Poly(Kind, Box<Term>),
  73 | 
  74 |     /// An instantiation.
  75 |     Inst(Box<Term>, Type),
  76 | 
  77 |     /// An existential introduction.
  78 |     /// `Pack(witness, t, ty)` represents *pack [`witness`, `t`] as `ty`*.
  79 |     Pack(Type, Box<Term>, Type),
  80 | 
  81 |     /// An existential elimination.
  82 |     Unpack(Box<Term>, Box<Term>),
  83 | 
  84 |     Int(isize),
  85 |     Bool(bool),
  86 |     If(Box<Term>, Box<Term>, Box<Term>),
  87 |     BinOp(BinOp, Box<Term>, Box<Term>),
  88 | 
  89 |     /// Just a syntax sugar for `App(Abs(ty, t2), t1)`, but convenient for debugging and it reduces
  90 |     /// the size of terms.
  91 |     Let(Box<Term>, Box<Term>),
  92 | }
  93 | 
  94 | #[derive(Debug, PartialEq)]
  95 | pub struct Env<T, S> {
  96 |     /// A type environment.
  97 |     /// Variable 0 denotes the last introduced type variable.
  98 |     tenv: Vec<(Kind, S)>,
  99 | 
 100 |     venv: Vec<Option<T>>,
 101 | 
 102 |     /// A type environment for generated variables.
 103 |     /// Variable 0 denotes the first introduced type variable.
 104 |     gtenv: Vec<Kind>,
 105 | 
 106 |     /// A name-to-index map.
 107 |     nmap: HashMap<Name, usize>,
 108 | 
 109 |     /// A counter to generate fresh type variables for type inference.
 110 |     n: usize,
 111 | }
 112 | 
 113 | pub struct EnvState(HashMap<Name, usize>);
 114 | 
 115 | #[derive(Clone, Debug, PartialEq)]
 116 | pub struct EnvAbs<T, S> {
 117 |     /// A type environment.
 118 |     /// Variable 0 denotes the last introduced type variable.
 119 |     tenv: Vec<(Kind, S)>,
 120 | 
 121 |     venv: Vec<Option<T>>,
 122 | }
 123 | 
 124 | #[derive(Clone, Debug, Default, PartialEq)]
 125 | pub struct Context<'a> {
 126 |     tenv: Vec<Cow<'a, Kind>>,
 127 |     venv: Vec<Cow<'a, Type>>,
 128 |     gtenv: Vec<Kind>,
 129 | }
 130 | 
 131 | #[derive(Debug, Fail, PartialEq)]
 132 | pub enum KindError {
 133 |     #[fail(display = "kind mismatch: {:?} and {:?}", _0, _1)]
 134 |     KindMismatch(Kind, Kind),
 135 | 
 136 |     #[fail(display = "not function kind: {:?}", _0)]
 137 |     NotFunction(Kind),
 138 | 
 139 |     #[fail(display = "type {:?} does not have mono kind: {}", _0, _1)]
 140 |     NotMono(Type, NotMonoError),
 141 | 
 142 |     #[fail(display = "label {:?} in record: {}", _0, _1)]
 143 |     Record(Label, Box<KindError>),
 144 | 
 145 |     #[fail(display = "environment error: {}", _0)]
 146 |     Env(EnvError),
 147 | 
 148 |     #[fail(display = "function's domain type {:?}: {}", _0, _1)]
 149 |     Domain(Type, NotMonoError),
 150 | 
 151 |     #[fail(display = "function's codomain type {:?}: {}", _0, _1)]
 152 |     Codomain(Type, NotMonoError),
 153 | }
 154 | 
 155 | #[derive(Debug, Fail, PartialEq)]
 156 | pub enum TypeError {
 157 |     #[fail(display = "type mismatch: {:?} and {:?}", _0, _1)]
 158 |     TypeMismatch(Type, Type),
 159 | 
 160 |     #[fail(display = "not function type: {:?}", _0)]
 161 |     NotFunction(Type),
 162 | 
 163 |     #[fail(
 164 |         display = "missing label {:?} in {:?}, which is the type of {:?}",
 165 |         _2, _1, _0
 166 |     )]
 167 |     MissingLabel(Term, Record<Type>, Label),
 168 | 
 169 |     #[fail(display = "not record type: {:?}", _0)]
 170 |     NotRecord(Type),
 171 | 
 172 |     #[fail(display = "not universal type: {:?}", _0)]
 173 |     NotForall(Type),
 174 | 
 175 |     #[fail(display = "not existential type: {:?}", _0)]
 176 |     NotSome(Type),
 177 | 
 178 |     #[fail(display = "not boolean type: {:?}", _0)]
 179 |     NotBool(Type),
 180 | 
 181 |     #[fail(display = "environment error: {}", _0)]
 182 |     Env(EnvError),
 183 | 
 184 |     #[fail(display = "kind error: {}", _0)]
 185 |     KindError(KindError),
 186 | 
 187 |     #[fail(display = "in application of {:?} to {:?}: {}", _0, _1, _2)]
 188 |     Application(Box<Term>, Box<Term>, Box<TypeError>),
 189 | 
 190 |     #[fail(display = "in packing [{:?}, {:?}] as {:?}: {}", _0, _1, _2, _3)]
 191 |     Pack(Box<Type>, Box<Term>, Box<Type>, Box<TypeError>),
 192 | 
 193 |     #[fail(display = "instantiation of {:?} with {:?}: {}", _0, _1, _2)]
 194 |     Inst(Box<Term>, Type, KindError),
 195 | }
 196 | 
 197 | #[derive(Clone, Debug, Default, PartialEq)]
 198 | pub struct Subst(HashMap<Variable, Type>);
 199 | 
 200 | pub trait Substitution {
 201 |     fn apply(&mut self, s: &Subst);
 202 | }
 203 | 
 204 | impl<T, S> Default for Env<T, S> {
 205 |     fn default() -> Self {
 206 |         Env {
 207 |             tenv: vec![],
 208 |             venv: vec![],
 209 |             gtenv: vec![],
 210 |             nmap: HashMap::new(),
 211 |             n: 0,
 212 |         }
 213 |     }
 214 | }
 215 | 
 216 | /// Free generated type variables.
 217 | pub trait Fgtv {
 218 |     fn fgtv(&self) -> HashSet<usize>;
 219 | }
 220 | 
 221 | pub trait Shift {
 222 |     fn shift_above(&mut self, c: usize, d: isize);
 223 | 
 224 |     fn shift(&mut self, d: isize) {
 225 |         self.shift_above(0, d)
 226 |     }
 227 | }
 228 | 
 229 | impl Shift for Type {
 230 |     fn shift_above(&mut self, c: usize, d: isize) {
 231 |         let mut f = |c0, v: usize| {
 232 |             if c0 <= v {
 233 |                 Ok(Type::Var(V(v).add(d)))
 234 |             } else {
 235 |                 Ok(Type::Var(V(v)))
 236 |             }
 237 |         };
 238 |         self.map_never_error(&mut f, c);
 239 |     }
 240 | }
 241 | 
 242 | impl Shift for Variable {
 243 |     fn shift_above(&mut self, c: usize, d: isize) {
 244 |         if let V(ref mut n) = *self {
 245 |             if c <= *n {
 246 |                 *n = usize::try_from(isize::try_from(*n).unwrap() + d).unwrap();
 247 |             }
 248 |         }
 249 |     }
 250 | }
 251 | 
 252 | impl Shift for Kind {
 253 |     fn shift_above(&mut self, _: usize, _: isize) {}
 254 | }
 255 | 
 256 | impl<T: Shift> Shift for Record<T> {
 257 |     fn shift_above(&mut self, c: usize, d: isize) {
 258 |         self.0.values_mut().for_each(|x| x.shift_above(c, d))
 259 |     }
 260 | }
 261 | 
 262 | impl Shift for Term {
 263 |     fn shift_above(&mut self, c: usize, d: isize) {
 264 |         use Term::*;
 265 |         match *self {
 266 |             Var(_) | Int(_) | Bool(_) => (),
 267 |             Abs(ref mut ty, ref mut t) => {
 268 |                 ty.shift_above(c, d);
 269 |                 t.shift_above(c, d);
 270 |             }
 271 |             App(ref mut t1, ref mut t2) => {
 272 |                 t1.shift_above(c, d);
 273 |                 t2.shift_above(c, d);
 274 |             }
 275 |             Record(ref mut r) => r.shift_above(c, d),
 276 |             Proj(ref mut t, _) => t.shift_above(c, d),
 277 |             Poly(ref mut k, ref mut t) => {
 278 |                 k.shift_above(c + 1, d);
 279 |                 t.shift_above(c + 1, d);
 280 |             }
 281 |             Inst(ref mut t, ref mut ty) => {
 282 |                 t.shift_above(c, d);
 283 |                 ty.shift_above(c, d);
 284 |             }
 285 |             Pack(ref mut ty1, ref mut t, ref mut ty2) => {
 286 |                 ty1.shift_above(c, d);
 287 |                 t.shift_above(c, d);
 288 |                 ty2.shift_above(c + 1, d);
 289 |             }
 290 |             Unpack(ref mut t1, ref mut t2) => {
 291 |                 t1.shift_above(c, d);
 292 |                 t2.shift_above(c + 1, d);
 293 |             }
 294 |             If(ref mut t1, ref mut t2, ref mut t3) => {
 295 |                 t1.shift_above(c, d);
 296 |                 t2.shift_above(c, d);
 297 |                 t3.shift_above(c, d);
 298 |             }
 299 |             BinOp(_, ref mut t1, ref mut t2) => {
 300 |                 t1.shift_above(c, d);
 301 |                 t2.shift_above(c, d);
 302 |             }
 303 |             Let(ref mut t1, ref mut t2) => {
 304 |                 t1.shift_above(c, d);
 305 |                 t2.shift_above(c, d);
 306 |             }
 307 |         }
 308 |     }
 309 | }
 310 | 
 311 | impl<T: Shift> Shift for Box<T> {
 312 |     fn shift_above(&mut self, c: usize, d: isize) {
 313 |         (**self).shift_above(c, d)
 314 |     }
 315 | }
 316 | 
 317 | impl<T: Shift> Shift for Option<T> {
 318 |     fn shift_above(&mut self, c: usize, d: isize) {
 319 |         if let Some(x) = self.as_mut() {
 320 |             x.shift_above(c, d);
 321 |         }
 322 |     }
 323 | }
 324 | 
 325 | impl<T: Shift> Shift for Vec<T> {
 326 |     fn shift_above(&mut self, c: usize, d: isize) {
 327 |         self.iter_mut().for_each(|x| {
 328 |             x.shift_above(c, d);
 329 |         });
 330 |     }
 331 | }
 332 | 
 333 | impl<K: Eq + Hash, T: Shift, S: BuildHasher> Shift for HashMap<K, T, S> {
 334 |     fn shift_above(&mut self, c: usize, d: isize) {
 335 |         self.values_mut().for_each(|x| {
 336 |             x.shift_above(c, d);
 337 |         });
 338 |     }
 339 | }
 340 | 
 341 | impl<T: Substitution> Substitution for Option<T> {
 342 |     fn apply(&mut self, s: &Subst) {
 343 |         self.iter_mut().for_each(|x| x.apply(s));
 344 |     }
 345 | }
 346 | 
 347 | impl<T: Substitution> Substitution for Vec<T> {
 348 |     fn apply(&mut self, s: &Subst) {
 349 |         self.iter_mut().for_each(|x| x.apply(s));
 350 |     }
 351 | }
 352 | 
 353 | impl<S: Substitution, T: Substitution> Substitution for (S, T) {
 354 |     fn apply(&mut self, s: &Subst) {
 355 |         self.0.apply(s);
 356 |         self.1.apply(s);
 357 |     }
 358 | }
 359 | 
 360 | impl<K: Eq + Hash, T: Substitution, S: BuildHasher> Substitution for HashMap<K, T, S> {
 361 |     fn apply(&mut self, s: &Subst) {
 362 |         self.values_mut().for_each(|x| x.apply(s));
 363 |     }
 364 | }
 365 | 
 366 | impl<T: Substitution> Substitution for Record<T> {
 367 |     fn apply(&mut self, s: &Subst) {
 368 |         self.0.apply(s)
 369 |     }
 370 | }
 371 | 
 372 | impl Substitution for Kind {
 373 |     fn apply(&mut self, _: &Subst) {}
 374 | }
 375 | 
 376 | impl Substitution for Type {
 377 |     fn apply(&mut self, s: &Subst) {
 378 |         use Type::*;
 379 |         match *self {
 380 |             Var(ref mut v) => {
 381 |                 if let Option::Some(ty) = s.0.get(v) {
 382 |                     *self = ty.clone();
 383 |                 }
 384 |             }
 385 |             Fun(ref mut ty1, ref mut ty2) => {
 386 |                 ty1.apply(s);
 387 |                 ty2.apply(s);
 388 |             }
 389 |             Record(ref mut r) => r.apply(s),
 390 |             Forall(ref mut k, ref mut ty) => {
 391 |                 let s = &s.clone().shift(1);
 392 |                 k.apply(s);
 393 |                 ty.apply(s);
 394 |             }
 395 |             Some(ref mut k, ref mut ty) => {
 396 |                 let s = &s.clone().shift(1);
 397 |                 k.apply(s);
 398 |                 ty.apply(s);
 399 |             }
 400 |             Abs(ref mut k, ref mut ty) => {
 401 |                 let s = &s.clone().shift(1);
 402 |                 k.apply(s);
 403 |                 ty.apply(s);
 404 |             }
 405 |             App(ref mut ty1, ref mut ty2) => {
 406 |                 ty1.apply(s);
 407 |                 ty2.apply(s);
 408 |             }
 409 |             Int | Bool => (),
 410 |         }
 411 |     }
 412 | }
 413 | 
 414 | impl Substitution for Term {
 415 |     fn apply(&mut self, s: &Subst) {
 416 |         use Term::*;
 417 |         match *self {
 418 |             Var(_) | Int(_) | Bool(_) => (),
 419 |             Abs(ref mut ty, ref mut t) => {
 420 |                 ty.apply(s);
 421 |                 t.apply(s);
 422 |             }
 423 |             App(ref mut t1, ref mut t2) => {
 424 |                 t1.apply(s);
 425 |                 t2.apply(s);
 426 |             }
 427 |             Record(ref mut r) => r.apply(s),
 428 |             Proj(ref mut t, _) => t.apply(s),
 429 |             Poly(ref mut k, ref mut t) => {
 430 |                 let s = &s.clone().shift(1);
 431 |                 k.apply(s);
 432 |                 t.apply(s);
 433 |             }
 434 |             Inst(ref mut t, ref mut ty) => {
 435 |                 t.apply(s);
 436 |                 ty.apply(s);
 437 |             }
 438 |             Pack(ref mut ty1, ref mut t, ref mut ty2) => {
 439 |                 ty1.apply(s);
 440 |                 t.apply(s);
 441 |                 let s = &s.clone().shift(1);
 442 |                 ty2.apply(s);
 443 |             }
 444 |             Unpack(ref mut t1, ref mut t2) => {
 445 |                 t1.apply(s);
 446 |                 let s = &s.clone().shift(1);
 447 |                 t2.apply(s);
 448 |             }
 449 |             If(ref mut t1, ref mut t2, ref mut t3) => {
 450 |                 t1.apply(s);
 451 |                 t2.apply(s);
 452 |                 t3.apply(s);
 453 |             }
 454 |             BinOp(_, ref mut t1, ref mut t2) => {
 455 |                 t1.apply(s);
 456 |                 t2.apply(s);
 457 |             }
 458 |             Let(ref mut t1, ref mut t2) => {
 459 |                 t1.apply(s);
 460 |                 t2.apply(s);
 461 |             }
 462 |         }
 463 |     }
 464 | }
 465 | 
 466 | impl Substitution for Subst {
 467 |     fn apply(&mut self, s: &Subst) {
 468 |         self.0.values_mut().for_each(|ty| ty.apply(s));
 469 |     }
 470 | }
 471 | 
 472 | impl<T: Substitution, S> Substitution for Env<T, S> {
 473 |     fn apply(&mut self, s: &Subst) {
 474 |         self.tenv.iter_mut().for_each(|p| p.0.apply(s));
 475 |         self.venv.iter_mut().for_each(|x| x.apply(s));
 476 |     }
 477 | }
 478 | 
 479 | impl Fgtv for Kind {
 480 |     fn fgtv(&self) -> HashSet<usize> {
 481 |         HashSet::default()
 482 |     }
 483 | }
 484 | 
 485 | impl Fgtv for Variable {
 486 |     fn fgtv(&self) -> HashSet<usize> {
 487 |         if let Variable::Generated(n) = *self {
 488 |             HashSet::from_iter(Some(n))
 489 |         } else {
 490 |             HashSet::new()
 491 |         }
 492 |     }
 493 | }
 494 | 
 495 | impl Fgtv for Type {
 496 |     fn fgtv(&self) -> HashSet<usize> {
 497 |         use Type::*;
 498 |         match *self {
 499 |             Var(Variable::Generated(n)) => HashSet::from_iter(vec![n]),
 500 |             Var(_) | Int | Bool => HashSet::new(),
 501 |             Fun(ref ty1, ref ty2) => {
 502 |                 let mut s = ty1.fgtv();
 503 |                 s.extend(ty2.fgtv());
 504 |                 s
 505 |             }
 506 |             Record(ref r) => r.0.values().flat_map(|ty| ty.fgtv()).collect(),
 507 |             App(ref ty1, ref ty2) => {
 508 |                 let mut s = ty1.fgtv();
 509 |                 s.extend(ty2.fgtv());
 510 |                 s
 511 |             }
 512 |             Forall(ref k, ref ty) | Some(ref k, ref ty) => {
 513 |                 let mut s = k.fgtv();
 514 |                 s.extend(ty.fgtv());
 515 |                 s
 516 |             }
 517 |             _ => unimplemented!("{:?}", self),
 518 |         }
 519 |     }
 520 | }
 521 | 
 522 | impl<T: Fgtv, S> Fgtv for Env<T, S> {
 523 |     fn fgtv(&self) -> HashSet<usize> {
 524 |         self.venv.iter().flat_map(|x| x.fgtv()).collect()
 525 |     }
 526 | }
 527 | 
 528 | impl<T: Fgtv> Fgtv for Option<T> {
 529 |     fn fgtv(&self) -> HashSet<usize> {
 530 |         match *self {
 531 |             Some(ref x) => x.fgtv(),
 532 |             None => HashSet::new(),
 533 |         }
 534 |     }
 535 | }
 536 | 
 537 | impl From<EnvError> for TypeError {
 538 |     fn from(e: EnvError) -> Self {
 539 |         TypeError::Env(e)
 540 |     }
 541 | }
 542 | 
 543 | impl From<KindError> for TypeError {
 544 |     fn from(e: KindError) -> Self {
 545 |         TypeError::KindError(e)
 546 |     }
 547 | }
 548 | 
 549 | impl From<super::SemanticSig> for Type {
 550 |     fn from(st: super::SemanticSig) -> Self {
 551 |         use super::SemanticSig::*;
 552 |         match st {
 553 |             AtomicTerm(_, ty) => ty,
 554 |             AtomicType(mut ty, k) => {
 555 |                 ty.shift(1);
 556 |                 Type::forall(
 557 |                     vec![Kind::fun(k, Kind::Mono)],
 558 |                     Type::fun(
 559 |                         Type::app(Type::var(0), ty.clone()),
 560 |                         Type::app(Type::var(0), ty),
 561 |                     ),
 562 |                 )
 563 |             }
 564 |             AtomicSig(asig) => {
 565 |                 let ty = Type::from(asig);
 566 |                 Type::fun(ty.clone(), ty)
 567 |             }
 568 |             StructureSig(m) => Type::Record(
 569 |                 m.into_iter()
 570 |                     .map(|(l, ssig)| (l, Type::from(ssig)))
 571 |                     .collect(),
 572 |             ),
 573 |             FunctorSig(u) => u.into(),
 574 |             Applicative(u) => u.into(),
 575 |         }
 576 |     }
 577 | }
 578 | 
 579 | impl<T: Into<Type>> From<super::Existential<T>> for Type {
 580 |     fn from(ex: super::Existential<T>) -> Self {
 581 |         Type::some(
 582 |             ex.0.qs.into_iter().rev().map(|p| p.0).collect::<Vec<_>>(),
 583 |             ex.0.body.into(),
 584 |         )
 585 |     }
 586 | }
 587 | 
 588 | impl<T: Into<Type>> From<super::Universal<T>> for Type {
 589 |     fn from(u: super::Universal<T>) -> Self {
 590 |         Type::forall(
 591 |             u.0.qs.into_iter().rev().map(|p| p.0).collect::<Vec<_>>(),
 592 |             u.0.body.into(),
 593 |         )
 594 |     }
 595 | }
 596 | 
 597 | impl From<super::Fun> for Type {
 598 |     fn from(f: super::Fun) -> Self {
 599 |         Type::fun(f.0.into(), f.1.into())
 600 |     }
 601 | }
 602 | 
 603 | impl From<super::Applicative> for Type {
 604 |     fn from(f: super::Applicative) -> Self {
 605 |         Type::fun(f.0.into(), f.1.into())
 606 |     }
 607 | }
 608 | 
 609 | impl<T: Into<Type>> From<Box<T>> for Type {
 610 |     fn from(x: Box<T>) -> Self {
 611 |         (*x).into()
 612 |     }
 613 | }
 614 | 
 615 | impl From<super::SemanticTerm> for Term {
 616 |     fn from(st: super::SemanticTerm) -> Self {
 617 |         use super::SemanticTerm as ST;
 618 |         match st {
 619 |             ST::Term(t) => t,
 620 |             ST::Type(mut ty, k) => {
 621 |                 ty.shift(1);
 622 |                 Term::poly(
 623 |                     vec![Kind::fun(k, Kind::Mono)],
 624 |                     Term::abs(Type::app(Type::var(0), ty), Term::var(0)),
 625 |                 )
 626 |             }
 627 |             ST::Sig(asig) => Term::abs(Type::from(asig), Term::var(0)),
 628 |         }
 629 |     }
 630 | }
 631 | 
 632 | impl From<super::Ident> for Label {
 633 |     fn from(id: super::Ident) -> Self {
 634 |         Label::Label(Name::from(id))
 635 |     }
 636 | }
 637 | 
 638 | impl<'a> From<&'a super::Ident> for Label {
 639 |     fn from(id: &'a super::Ident) -> Self {
 640 |         Label::Label(Name::from(id.clone()))
 641 |     }
 642 | }
 643 | 
 644 | impl From<Name> for Label {
 645 |     fn from(name: Name) -> Self {
 646 |         Label::Label(name)
 647 |     }
 648 | }
 649 | 
 650 | impl<'a> From<&'a str> for Label {
 651 |     fn from(s: &str) -> Self {
 652 |         Label::Label(Name::from(s))
 653 |     }
 654 | }
 655 | 
 656 | impl<'a> From<&'a str> for Name {
 657 |     fn from(s: &str) -> Self {
 658 |         Name(s.to_string())
 659 |     }
 660 | }
 661 | 
 662 | impl From<String> for Name {
 663 |     fn from(s: String) -> Self {
 664 |         Name(s)
 665 |     }
 666 | }
 667 | 
 668 | impl From<super::Ident> for Name {
 669 |     fn from(id: super::Ident) -> Self {
 670 |         id.0
 671 |     }
 672 | }
 673 | 
 674 | impl<'a> From<&'a super::Ident> for &'a Name {
 675 |     fn from(id: &'a super::Ident) -> Self {
 676 |         &id.0
 677 |     }
 678 | }
 679 | 
 680 | impl TryFrom<Label> for Name {
 681 |     type Error = !;
 682 | 
 683 |     fn try_from(l: Label) -> Result<Self, Self::Error> {
 684 |         match l {
 685 |             Label::Label(name) => Ok(name),
 686 |         }
 687 |     }
 688 | }
 689 | 
 690 | impl Name {
 691 |     pub fn new(s: String) -> Self {
 692 |         Name(s)
 693 |     }
 694 | }
 695 | 
 696 | impl Variable {
 697 |     pub fn new(n: usize) -> Self {
 698 |         V(n)
 699 |     }
 700 | 
 701 |     fn add(self, d: isize) -> Self {
 702 |         match self {
 703 |             Variable::Generated(_) => self,
 704 |             V(n) => V(usize::try_from(isize::try_from(n).unwrap() + d)
 705 |                 .unwrap_or_else(|_| panic!("negative index: {} and {}", n, d))),
 706 |         }
 707 |     }
 708 | 
 709 |     pub fn get_index(self) -> usize {
 710 |         match self {
 711 |             V(n) => n,
 712 |             Variable::Generated(n) => panic!("get_index: unexpected generated variable: {}", n),
 713 |         }
 714 |     }
 715 | 
 716 |     pub fn apply_subst(self, s: &Subst) -> Type {
 717 |         if let Option::Some(ty) = s.0.get(&self) {
 718 |             ty.clone()
 719 |         } else {
 720 |             Type::Var(self)
 721 |         }
 722 |     }
 723 | }
 724 | 
 725 | impl FromIterator<(Variable, Type)> for Subst {
 726 |     fn from_iter<I: IntoIterator<Item = (Variable, Type)>>(iter: I) -> Self {
 727 |         Subst(HashMap::from_iter(iter))
 728 |     }
 729 | }
 730 | 
 731 | impl<T> FromIterator<(Label, T)> for Record<T> {
 732 |     fn from_iter<I: IntoIterator<Item = (Label, T)>>(iter: I) -> Self {
 733 |         Record(HashMap::from_iter(iter))
 734 |     }
 735 | }
 736 | 
 737 | impl Record<Type> {
 738 |     fn map<E, F>(&mut self, f: &mut F, c: usize) -> Result<(), E>
 739 |     where
 740 |         F: FnMut(usize, usize) -> Result<Type, E>,
 741 |     {
 742 |         self.0.values_mut().try_for_each(|ty| ty.map(f, c))
 743 |     }
 744 | }
 745 | 
 746 | impl<T> Record<T> {
 747 |     fn get(&self, l: &Label) -> Option<&T> {
 748 |         self.0.get(l)
 749 |     }
 750 | }
 751 | 
 752 | #[derive(Debug, Fail, PartialEq)]
 753 | #[fail(display = "not mono kind: {:?}", _0)]
 754 | pub struct NotMonoError(Kind);
 755 | 
 756 | impl Kind {
 757 |     pub fn fun(k1: Kind, k2: Kind) -> Self {
 758 |         Kind::Fun(Box::new(k1), Box::new(k2))
 759 |     }
 760 | 
 761 |     fn map<F>(&mut self, _: &F, _: usize) {}
 762 | 
 763 |     pub fn mono(&self) -> Result<(), NotMonoError> {
 764 |         match *self {
 765 |             Kind::Mono => Ok(()),
 766 |             _ => Err(NotMonoError(self.clone())),
 767 |         }
 768 |     }
 769 | 
 770 |     fn eta_reducible(&self, _: usize) -> bool {
 771 |         true
 772 |     }
 773 | 
 774 |     pub fn equal(&self, k: &Kind) -> bool {
 775 |         self == k
 776 |     }
 777 | 
 778 |     pub fn fun_env<T, S>(env: &Env<T, S>, k: Kind) -> Self {
 779 |         env.tenv
 780 |             .iter()
 781 |             .rfold(k, |acc, p| Kind::fun(p.0.clone(), acc))
 782 |     }
 783 | }
 784 | 
 785 | impl Type {
 786 |     pub fn var(n: usize) -> Self {
 787 |         Type::Var(V(n))
 788 |     }
 789 | 
 790 |     pub fn generated_var(n: usize) -> Self {
 791 |         Type::Var(Variable::Generated(n))
 792 |     }
 793 | 
 794 |     pub fn fun(ty1: Type, ty2: Type) -> Self {
 795 |         Type::Fun(Box::new(ty1), Box::new(ty2))
 796 |     }
 797 | 
 798 |     pub fn app(ty1: Type, ty2: Type) -> Self {
 799 |         Type::App(Box::new(ty1), Box::new(ty2))
 800 |     }
 801 | 
 802 |     pub fn record<I: IntoIterator<Item = (Label, Type)>>(iter: I) -> Self {
 803 |         Type::Record(Record::from_iter(iter))
 804 |     }
 805 | 
 806 |     pub fn abs_env<T, S>(env: &Env<T, S>, ty: Type) -> Self {
 807 |         env.tenv
 808 |             .iter()
 809 |             .rfold(ty, |acc, p| Type::abs(Some(p.0.clone()), acc))
 810 |     }
 811 | 
 812 |     pub fn app_env<T, S>(ty: Type, env: &Env<T, S>) -> Self {
 813 |         (0..env.tenv.len()).rfold(ty, |acc, n| Type::app(acc, Type::var(n)))
 814 |     }
 815 | 
 816 |     fn trivial() -> Self {
 817 |         Type::record(None)
 818 |     }
 819 | 
 820 |     pub fn forall_env<T, S>(env: &Env<T, S>, ty: Type) -> Self
 821 |     where
 822 |         T: Clone + Into<Type>,
 823 |     {
 824 |         let ty = env.venv.iter().rfold(ty, |acc, ty| {
 825 |             if let Some(ref ty) = *ty {
 826 |                 Type::fun(ty.clone().into(), acc)
 827 |             } else {
 828 |                 Type::fun(Type::trivial(), acc)
 829 |             }
 830 |         });
 831 |         env.tenv
 832 |             .iter()
 833 |             .rfold(ty, |acc, p| Type::forall(Some(p.0.clone()), acc))
 834 |     }
 835 | 
 836 |     pub fn forall_env_purity<T, S>(env: &Env<T, S>, p: Purity, ty: Type) -> Self
 837 |     where
 838 |         T: Clone + Into<Type>,
 839 |     {
 840 |         if p.is_pure() {
 841 |             Type::forall_env(env, ty)
 842 |         } else {
 843 |             ty
 844 |         }
 845 |     }
 846 | 
 847 |     pub fn forall_env_purity_swap<T, S>(env: &Env<T, S>, p: Purity, n: usize, mut ty: Type) -> Self
 848 |     where
 849 |         T: Clone + Into<Type>,
 850 |     {
 851 |         if p.is_pure() {
 852 |             let s = Subst::from_iter((0..n).map(|i| (V(i), Type::var(i + n + env.tenv_len()))));
 853 |             ty.apply(&s);
 854 |             ty.shift(-isize::try_from(n).unwrap());
 855 |             Type::forall_env(env, ty)
 856 |         } else {
 857 |             ty
 858 |         }
 859 |     }
 860 | 
 861 |     pub fn forall_env_purity_ignore_dummy_values<T, S>(env: &Env<T, S>, p: Purity, ty: Type) -> Self
 862 |     where
 863 |         T: Clone + Into<Type>,
 864 |     {
 865 |         if p.is_impure() {
 866 |             return ty;
 867 |         }
 868 |         let ty = env.venv.iter().rfold(ty, |acc, ty| {
 869 |             if let Some(ref ty) = *ty {
 870 |                 Type::fun(ty.clone().into(), acc)
 871 |             } else {
 872 |                 acc
 873 |             }
 874 |         });
 875 |         env.tenv
 876 |             .iter()
 877 |             .rfold(ty, |acc, p| Type::forall(Some(p.0.clone()), acc))
 878 |     }
 879 | 
 880 |     pub fn must_be_int(&self) -> Result<(), TypeError> {
 881 |         if let Type::Int = *self {
 882 |             Ok(())
 883 |         } else {
 884 |             Err(TypeError::TypeMismatch(self.clone(), Type::Int))
 885 |         }
 886 |     }
 887 | 
 888 |     /// Creates an n-ary existential type.
 889 |     ///
 890 |     /// # Examples
 891 |     ///
 892 |     /// ```
 893 |     /// use modules::rrd2014::internal::*;
 894 |     /// use Type::Int;
 895 |     /// use Kind::*;
 896 |     ///
 897 |     /// assert_eq!(Type::some(None, Int), Int);
 898 |     ///
 899 |     /// assert_eq!(
 900 |     ///     Type::some(vec![Mono], Int),
 901 |     ///     Type::Some(Mono, Box::new(Int))
 902 |     /// );
 903 |     ///
 904 |     /// assert_eq!(
 905 |     ///     Type::some(vec![Mono, Mono], Int),
 906 |     ///     Type::Some(Mono, Box::new(Type::Some(Mono, Box::new(Int))))
 907 |     /// );
 908 |     ///
 909 |     /// assert_eq!(
 910 |     ///     Type::some(vec![Kind::fun(Mono, Mono), Mono], Int),
 911 |     ///     Type::Some(Mono, Box::new(Type::Some(Kind::fun(Mono, Mono), Box::new(Int))))
 912 |     /// );
 913 |     /// ```
 914 |     pub fn some<I>(ks: I, ty: Type) -> Self
 915 |     where
 916 |         I: IntoIterator<Item = Kind>,
 917 |     {
 918 |         ks.into_iter().fold(ty, |ty, k| Type::Some(k, Box::new(ty)))
 919 |     }
 920 | 
 921 |     /// Creates an n-ary universal type.
 922 |     ///
 923 |     /// # Examples
 924 |     ///
 925 |     /// ```
 926 |     /// use modules::rrd2014::internal::*;
 927 |     /// use Type::Int;
 928 |     /// use Kind::*;
 929 |     ///
 930 |     /// assert_eq!(Type::forall(None, Int), Int);
 931 |     ///
 932 |     /// assert_eq!(
 933 |     ///     Type::forall(vec![Mono], Int),
 934 |     ///     Type::Forall(Mono, Box::new(Int))
 935 |     /// );
 936 |     ///
 937 |     /// assert_eq!(
 938 |     ///     Type::forall(vec![Mono, Mono], Int),
 939 |     ///     Type::Forall(Mono, Box::new(Type::Forall(Mono, Box::new(Int))))
 940 |     /// );
 941 |     ///
 942 |     /// assert_eq!(
 943 |     ///     Type::forall(vec![Kind::fun(Mono, Mono), Mono], Int),
 944 |     ///     Type::Forall(Mono, Box::new(Type::Forall(Kind::fun(Mono, Mono), Box::new(Int))))
 945 |     /// );
 946 |     /// ```
 947 |     pub fn forall<I>(ks: I, ty: Type) -> Self
 948 |     where
 949 |         I: IntoIterator<Item = Kind>,
 950 |     {
 951 |         ks.into_iter()
 952 |             .fold(ty, |ty, k| Type::Forall(k, Box::new(ty)))
 953 |     }
 954 | 
 955 |     /// Creates an n-ary type-level lambda abstraction.
 956 |     ///
 957 |     /// # Examples
 958 |     ///
 959 |     /// ```
 960 |     /// use modules::rrd2014::internal::*;
 961 |     /// use Type::Int;
 962 |     /// use Kind::*;
 963 |     ///
 964 |     /// assert_eq!(Type::abs(None, Int), Int);
 965 |     ///
 966 |     /// assert_eq!(
 967 |     ///     Type::abs(vec![Mono], Int),
 968 |     ///     Type::Abs(Mono, Box::new(Int))
 969 |     /// );
 970 |     ///
 971 |     /// assert_eq!(
 972 |     ///     Type::abs(vec![Mono, Mono], Int),
 973 |     ///     Type::Abs(Mono, Box::new(Type::Abs(Mono, Box::new(Int))))
 974 |     /// );
 975 |     ///
 976 |     /// assert_eq!(
 977 |     ///     Type::abs(vec![Kind::fun(Mono, Mono), Mono], Int),
 978 |     ///     Type::Abs(Mono, Box::new(Type::Abs(Kind::fun(Mono, Mono), Box::new(Int))))
 979 |     /// );
 980 |     /// ```
 981 |     pub fn abs<I>(ks: I, ty: Type) -> Self
 982 |     where
 983 |         I: IntoIterator<Item = Kind>,
 984 |     {
 985 |         ks.into_iter().fold(ty, |ty, k| Type::Abs(k, Box::new(ty)))
 986 |     }
 987 | 
 988 |     fn map<E, F>(&mut self, f: &mut F, c: usize) -> Result<(), E>
 989 |     where
 990 |         F: FnMut(usize, usize) -> Result<Type, E>,
 991 |     {
 992 |         use Type::*;
 993 |         match *self {
 994 |             Var(v) => match v {
 995 |                 V(v) => {
 996 |                     let ty = f(c, v)?;
 997 |                     *self = ty;
 998 |                 }
 999 |                 Variable::Generated(_) => (),
1000 |             },
1001 |             Fun(ref mut ty1, ref mut ty2) => {
1002 |                 ty1.map(f, c)?;
1003 |                 ty2.map(f, c)?;
1004 |             }
1005 |             Record(ref mut r) => r.map(f, c)?,
1006 |             Forall(ref mut k, ref mut ty) => {
1007 |                 k.map(f, c); // Currently, kinds do not depend on types, though.
1008 |                 ty.map(f, c + 1)?;
1009 |             }
1010 |             Some(ref mut k, ref mut ty) => {
1011 |                 k.map(f, c); // Currently, kinds do not depend on types, though.
1012 |                 ty.map(f, c + 1)?;
1013 |             }
1014 |             Abs(ref mut k, ref mut ty) => {
1015 |                 k.map(f, c); // Currently, kinds do not depend on types, though.
1016 |                 ty.map(f, c + 1)?;
1017 |             }
1018 |             App(ref mut ty1, ref mut ty2) => {
1019 |                 ty1.map(f, c)?;
1020 |                 ty2.map(f, c)?;
1021 |             }
1022 |             Int | Bool => (),
1023 |         }
1024 |         Ok(())
1025 |     }
1026 | 
1027 |     fn map_never_error<F>(&mut self, f: &mut F, c: usize)
1028 |     where
1029 |         F: FnMut(usize, usize) -> Result<Type, !>,
1030 |     {
1031 |         self.map(f, c).unwrap();
1032 |     }
1033 | 
1034 |     pub(crate) fn shift_neg(&mut self, d: usize) -> Option<usize> {
1035 |         let mut f = |c0: usize, v: usize| {
1036 |             if c0 + d <= v {
1037 |                 Ok(Type::var(v - d))
1038 |             } else if v < c0 {
1039 |                 Ok(Type::var(v))
1040 |             } else {
1041 |                 Err(v)
1042 |             }
1043 |         };
1044 |         if let Err(n) = self.map(&mut f, 0) {
1045 |             Some(n)
1046 |         } else {
1047 |             None
1048 |         }
1049 |     }
1050 | 
1051 |     fn subst(&mut self, j: usize, ty: &Type) {
1052 |         let mut f = |c: usize, v: usize| {
1053 |             if c + j == v {
1054 |                 let mut ty = ty.clone();
1055 |                 ty.shift(isize::try_from(c).unwrap());
1056 |                 Ok(ty)
1057 |             } else {
1058 |                 Ok(Type::Var(V(v)))
1059 |             }
1060 |         };
1061 |         self.map_never_error(&mut f, 0);
1062 |     }
1063 | 
1064 |     fn subst_top(&mut self, ty: &mut Type) {
1065 |         ty.shift(1);
1066 |         self.subst(0, ty);
1067 |         self.shift(-1);
1068 |     }
1069 | 
1070 |     fn subst_shift(&mut self, j: usize, ty: &Type, d: isize) {
1071 |         let mut f = |c: usize, v: usize| {
1072 |             if c + j == v {
1073 |                 let mut ty = ty.clone();
1074 |                 ty.shift(isize::try_from(c).unwrap() + d);
1075 |                 Ok(ty)
1076 |             } else {
1077 |                 Ok(Type::Var(V(v)))
1078 |             }
1079 |         };
1080 |         self.map_never_error(&mut f, 0);
1081 |     }
1082 | 
1083 |     fn ftv(&self) -> HashSet<Variable> {
1084 |         use Type::*;
1085 |         match *self {
1086 |             Var(v) => HashSet::from_iter(vec![v]),
1087 |             Fun(ref ty1, ref ty2) => {
1088 |                 let mut s = ty1.ftv();
1089 |                 s.extend(ty2.ftv());
1090 |                 s
1091 |             }
1092 |             Record(ref r) => r.0.values().flat_map(|ty| ty.ftv()).collect(),
1093 |             App(ref ty1, ref ty2) => {
1094 |                 let mut s = ty1.ftv();
1095 |                 s.extend(ty2.ftv());
1096 |                 s
1097 |             }
1098 |             Int => HashSet::new(),
1099 |             _ => unimplemented!(),
1100 |         }
1101 |     }
1102 | 
1103 |     /// System F type equality.
1104 |     pub fn equal(&self, ty: &Type) -> bool {
1105 |         // TODO: Make it efficient.
1106 |         self.clone().reduce() == ty.clone().reduce()
1107 |     }
1108 | 
1109 |     fn reduce(self) -> Self {
1110 |         use Type::*;
1111 |         match self {
1112 |             Var(_) | Int | Bool => self,
1113 |             Fun(ty1, ty2) => Type::fun(ty1.reduce(), ty2.reduce()),
1114 |             Record(r) => Type::record(r.0.into_iter().map(|(l, ty)| (l, ty.reduce()))),
1115 |             // TODO: Is there any case where kinds depends on types which are sensible about
1116 |             // beta-eta equivalence?
1117 |             Forall(k, ty) => Type::forall(vec![k], ty.reduce()),
1118 |             Some(k, ty) => Type::some(vec![k], ty.reduce()),
1119 |             Abs(k, ty) => match ty.reduce() {
1120 |                 App(mut ty1, ty2) if *ty2 == Type::var(0) && ty1.eta_reducible(0) => {
1121 |                     ty1.shift(-1);
1122 |                     *ty1
1123 |                 }
1124 |                 ty => Type::abs(vec![k], ty),
1125 |             },
1126 |             App(ty1, ty2) => {
1127 |                 let mut ty2 = ty2.reduce();
1128 |                 match ty1.reduce() {
1129 |                     // The kind is ignored.
1130 |                     Abs(_, mut ty1) => {
1131 |                         ty2.shift(1);
1132 |                         ty1.subst(0, &ty2);
1133 |                         ty1.shift(-1);
1134 |                         ty1.reduce() // Well-kinded types may terminate (no proof, though).
1135 |                     }
1136 |                     ty1 => Type::app(ty1, ty2),
1137 |                 }
1138 |             }
1139 |         }
1140 |     }
1141 | 
1142 |     fn eta_reducible(&self, n: usize) -> bool {
1143 |         use Type::*;
1144 |         match *self {
1145 |             Var(V(m)) => m != n,
1146 |             Var(Variable::Generated(_)) => true,
1147 |             Fun(ref ty1, ref ty2) => ty1.eta_reducible(n) && ty2.eta_reducible(n),
1148 |             Record(ref r) => r.0.values().all(|ty| ty.eta_reducible(n)),
1149 |             Forall(ref k, ref ty) => k.eta_reducible(n + 1) && ty.eta_reducible(n + 1),
1150 |             Some(ref k, ref ty) => k.eta_reducible(n + 1) && ty.eta_reducible(n + 1),
1151 |             Abs(ref k, ref ty) => k.eta_reducible(n + 1) && ty.eta_reducible(n + 1),
1152 |             App(ref ty1, ref ty2) => ty1.eta_reducible(n) && ty2.eta_reducible(n),
1153 |             Int | Bool => true,
1154 |         }
1155 |     }
1156 | 
1157 |     pub fn kind_of<T: Shift, S: Clone + Default>(
1158 |         &self,
1159 |         env: &mut Env<T, S>,
1160 |     ) -> Result<Kind, KindError> {
1161 |         use Kind::Mono;
1162 |         use Type::*;
1163 |         match *self {
1164 |             Var(v) => Ok(env.lookup_type(v).map_err(KindError::Env)?.0),
1165 |             Fun(ref ty1, ref ty2) => {
1166 |                 let k1 = ty1.kind_of(env)?;
1167 |                 k1.mono().map_err(|e| KindError::Domain(*ty1.clone(), e))?;
1168 |                 let k2 = ty2.kind_of(env)?;
1169 |                 k2.mono()
1170 |                     .map_err(|e| KindError::Codomain(*ty2.clone(), e))?;
1171 |                 Ok(Mono)
1172 |             }
1173 |             Record(ref r) => {
1174 |                 r.0.iter().try_for_each(|(l, ty)| -> Result<_, KindError> {
1175 |                     ty.kind_of(env)?.mono().map_err(|e| {
1176 |                         KindError::Record(l.clone(), Box::new(KindError::NotMono(ty.clone(), e)))
1177 |                     })?;
1178 |                     Ok(())
1179 |                 })?;
1180 |                 Ok(Mono)
1181 |             }
1182 |             Forall(ref k, ref ty) | Some(ref k, ref ty) => {
1183 |                 env.insert_type(k.clone(), S::default());
1184 |                 ty.kind_of(env)?
1185 |                     .mono()
1186 |                     .map_err(|e| KindError::NotMono(*ty.clone(), e))?;
1187 |                 env.drop_type();
1188 |                 Ok(Mono)
1189 |             }
1190 |             Abs(ref k1, ref ty) => {
1191 |                 env.insert_type(k1.clone(), S::default());
1192 |                 let k2 = ty.kind_of(env)?;
1193 |                 env.drop_type();
1194 |                 Ok(Kind::fun(k1.clone(), k2))
1195 |             }
1196 |             App(ref ty1, ref ty2) => {
1197 |                 let k1 = ty1.kind_of(env)?;
1198 |                 let k2 = ty2.kind_of(env)?;
1199 |                 match k1 {
1200 |                     Kind::Fun(k11, k12) => {
1201 |                         if *k11 == k2 {
1202 |                             Ok(*k12)
1203 |                         } else {
1204 |                             Err(KindError::KindMismatch(*k11, k2))
1205 |                         }
1206 |                     }
1207 |                     _ => Err(KindError::NotFunction(k1)),
1208 |                 }
1209 |             }
1210 |             Int | Bool => Ok(Mono),
1211 |         }
1212 |     }
1213 | 
1214 |     pub fn close<T, S>(mut self, env: &Env<T, S>) -> (Self, Subst, Vec<Kind>)
1215 |     where
1216 |         T: Fgtv,
1217 |         S: Clone + Default,
1218 |     {
1219 |         let tvs = self.fgtv();
1220 |         let env_tvs = env.fgtv();
1221 |         let tvs: Vec<_> = tvs.difference(&env_tvs).collect();
1222 |         let n = tvs.len();
1223 |         self.shift(isize::try_from(n).unwrap());
1224 |         let s = Subst::from_iter(
1225 |             tvs.iter()
1226 |                 .enumerate()
1227 |                 .map(|(i, &&v)| (Variable::Generated(v), Type::var(i))),
1228 |         );
1229 |         self.apply(&s);
1230 |         let ks = tvs
1231 |             .into_iter()
1232 |             .map(|&v| env.lookup_type(Variable::Generated(v)).unwrap().0);
1233 |         (Type::forall(ks.clone(), self), s, ks.collect())
1234 |     }
1235 | 
1236 |     pub fn new_instance<T, S>(self, env: &mut Env<T, S>) -> (Self, Vec<Type>)
1237 |     where
1238 |         T: Shift,
1239 |     {
1240 |         let mut ty0 = self;
1241 |         let mut tys = Vec::new();
1242 |         loop {
1243 |             match ty0 {
1244 |                 Type::Forall(k, ty) => {
1245 |                     let v = env.fresh_type_variable(k);
1246 |                     tys.push(Type::Var(v));
1247 |                     ty0 = *ty;
1248 |                 }
1249 |                 mut ty => {
1250 |                     let s = Subst::from_iter((0..tys.len()).rev().map(V).zip(tys.clone()));
1251 |                     ty.apply(&s);
1252 |                     ty.shift(-isize::try_from(tys.len()).unwrap());
1253 |                     return (ty, tys);
1254 |                 }
1255 |             }
1256 |         }
1257 |     }
1258 | 
1259 |     fn split_universal_quantifiers(&self, v: &mut Vec<Kind>) -> Type {
1260 |         match *self {
1261 |             Type::Forall(ref k, ref ty) => {
1262 |                 v.push(k.clone());
1263 |                 ty.split_universal_quantifiers(v)
1264 |             }
1265 |             _ => self.clone(),
1266 |         }
1267 |     }
1268 | 
1269 |     fn is_general_aux(&self, n: usize, s: &mut Subst, ty: &Type) -> Result<(), ()> {
1270 |         use Type::*;
1271 |         match (self, ty) {
1272 |             (&Int, &Int) => Ok(()),
1273 |             (&Bool, &Bool) => Ok(()),
1274 |             (&Fun(ref ty11, ref ty12), &Fun(ref ty21, ref ty22)) => {
1275 |                 ty11.is_general_aux(n, s, ty21)?;
1276 |                 ty12.is_general_aux(n, s, ty22)?;
1277 |                 Ok(())
1278 |             }
1279 |             (&Int, _) | (&Bool, _) | (&Fun(..), _) => Err(()),
1280 |             (&Var(Variable::Generated(_)), _) => {
1281 |                 unimplemented!();
1282 |             }
1283 |             (&Var(V(i)), _) if i >= n => {
1284 |                 if self == ty {
1285 |                     Ok(())
1286 |                 } else {
1287 |                     Err(())
1288 |                 }
1289 |             }
1290 |             (&Var(v), _) => {
1291 |                 let ty0 = v.apply_subst(s);
1292 |                 if &ty0 == self {
1293 |                     s.0.insert(v, ty.clone());
1294 |                     Ok(())
1295 |                 } else {
1296 |                     ty0.is_general_aux(n, s, ty)
1297 |                 }
1298 |             }
1299 |             _ => unimplemented!(),
1300 |         }
1301 |     }
1302 | 
1303 |     pub fn is_general(&self, ty: &Type) -> Result<(Vec<Type>, Vec<Kind>), ()> {
1304 |         let (mut ty1, m) = {
1305 |             let mut v = Vec::new();
1306 |             let ty1 = self.split_universal_quantifiers(&mut v);
1307 |             (ty1, v.len())
1308 |         };
1309 |         let mut v = Vec::new();
1310 |         let mut ty2 = ty.split_universal_quantifiers(&mut v);
1311 |         let n = v.len();
1312 |         ty2.shift(isize::try_from(m).unwrap());
1313 |         ty1.shift_above(m, isize::try_from(n).unwrap());
1314 |         let mut s = Subst::default();
1315 |         ty1.is_general_aux(m, &mut s, &ty2)?;
1316 |         Ok((
1317 |             (0..m)
1318 |                 .rev()
1319 |                 .map(|i| {
1320 |                     let mut ty = s.0.remove(&V(i)).expect("unexpected error");
1321 |                     ty.shift(-isize::try_from(m).unwrap());
1322 |                     ty
1323 |                 })
1324 |                 .collect(),
1325 |             v,
1326 |         ))
1327 |     }
1328 | }
1329 | 
1330 | impl Term {
1331 |     pub fn var(n: usize) -> Self {
1332 |         Term::Var(V(n))
1333 |     }
1334 | 
1335 |     pub fn abs(ty: Type, t: Term) -> Self {
1336 |         Term::Abs(ty, Box::new(t))
1337 |     }
1338 | 
1339 |     pub fn app(t1: Term, t2: Term) -> Self {
1340 |         Term::App(Box::new(t1), Box::new(t2))
1341 |     }
1342 | 
1343 |     pub fn record<I: IntoIterator<Item = (Label, Term)>>(iter: I) -> Self {
1344 |         Term::Record(Record::from_iter(iter))
1345 |     }
1346 | 
1347 |     pub fn r#if(t1: Term, t2: Term, t3: Term) -> Self {
1348 |         Term::If(Box::new(t1), Box::new(t2), Box::new(t3))
1349 |     }
1350 | 
1351 |     pub fn bin_op(op: BinOp, t1: Term, t2: Term) -> Self {
1352 |         Term::BinOp(op, Box::new(t1), Box::new(t2))
1353 |     }
1354 | 
1355 |     pub fn abs_env<U, T, S>(env: U, t: Term) -> Self
1356 |     where
1357 |         U: Into<EnvAbs<T, S>>,
1358 |         T: Clone + Into<Type>,
1359 |     {
1360 |         let env = env.into();
1361 |         let t = env.venv.iter().rfold(t, |acc, ty| {
1362 |             if let Some(ref ty) = *ty {
1363 |                 Term::abs(ty.clone().into(), acc)
1364 |             } else {
1365 |                 Term::abs(Type::trivial(), acc)
1366 |             }
1367 |         });
1368 |         env.tenv
1369 |             .iter()
1370 |             .rfold(t, |acc, p| Term::poly(Some(p.0.clone()), acc))
1371 |     }
1372 | 
1373 |     pub fn abs_env_purity<U, T, S>(env: U, p: Purity, t: Term) -> Self
1374 |     where
1375 |         U: Into<EnvAbs<T, S>>,
1376 |         T: Clone + Into<Type>,
1377 |     {
1378 |         let env = env.into();
1379 |         if p.is_pure() {
1380 |             Term::abs_env(env, t)
1381 |         } else {
1382 |             t
1383 |         }
1384 |     }
1385 | 
1386 |     pub fn abs_env_purity_ignore_dummy_values<U, T, S>(env: U, p: Purity, t: Term) -> Self
1387 |     where
1388 |         U: Into<EnvAbs<T, S>>,
1389 |         T: Clone + Into<Type>,
1390 |     {
1391 |         if p.is_impure() {
1392 |             return t;
1393 |         }
1394 |         let env = env.into();
1395 |         let t = env.venv.iter().rfold(t, |acc, ty| {
1396 |             if let Some(ref ty) = *ty {
1397 |                 Term::abs(ty.clone().into(), acc)
1398 |             } else {
1399 |                 acc
1400 |             }
1401 |         });
1402 |         env.tenv
1403 |             .iter()
1404 |             .rfold(t, |acc, p| Term::poly(Some(p.0.clone()), acc))
1405 |     }
1406 | 
1407 |     pub fn trivial() -> Self {
1408 |         Term::record(None)
1409 |     }
1410 | 
1411 |     // TODO: parameter `vn` might be unneeded.
1412 |     fn app_env_skip<U, T, S>(t: Term, env: U, tskip: usize, vskip: usize, vn: usize) -> Self
1413 |     where
1414 |         U: Into<EnvAbs<T, S>>,
1415 |     {
1416 |         let env = env.into();
1417 |         let t = (tskip..env.tenv.len()).rfold(t, |acc, i| Term::inst(acc, Some(Type::var(i))));
1418 |         env.venv
1419 |             .iter()
1420 |             .rev()
1421 |             .skip(vskip)
1422 |             .enumerate()
1423 |             .rfold(t, |acc, (i, ty)| {
1424 |                 if ty.is_some() {
1425 |                     Term::app(acc, Term::var(i + vn))
1426 |                 } else {
1427 |                     Term::app(acc, Term::trivial())
1428 |                 }
1429 |             })
1430 |     }
1431 | 
1432 |     pub fn app_env<U, T, S>(t: Term, env: U) -> Self
1433 |     where
1434 |         U: Into<EnvAbs<T, S>>,
1435 |     {
1436 |         Term::app_env_skip(t, env, 0, 0, 0)
1437 |     }
1438 | 
1439 |     pub fn app_env_purity_skip<U, T, S>(
1440 |         t: Term,
1441 |         env: U,
1442 |         p: Purity,
1443 |         tskip: usize,
1444 |         vskip: usize,
1445 |         vn: usize,
1446 |     ) -> Self
1447 |     where
1448 |         U: Into<EnvAbs<T, S>>,
1449 |     {
1450 |         if p.is_pure() {
1451 |             Term::app_env_skip(t, env, tskip, vskip, vn)
1452 |         } else {
1453 |             t
1454 |         }
1455 |     }
1456 | 
1457 |     pub fn app_env_purity<U, T, S>(t: Term, env: U, p: Purity) -> Self
1458 |     where
1459 |         U: Into<EnvAbs<T, S>>,
1460 |     {
1461 |         Term::app_env_purity_skip(t, env, p, 0, 0, 0)
1462 |     }
1463 | 
1464 |     pub fn app_env_seq<U, T, S>(t: Term, env: U, vskip: usize, vn: usize) -> Self
1465 |     where
1466 |         U: Into<EnvAbs<T, S>>,
1467 |     {
1468 |         let env = env.into();
1469 |         env.venv
1470 |             .iter()
1471 |             .rev()
1472 |             .skip(vskip)
1473 |             .enumerate()
1474 |             .rfold(t, |acc, (j, ty)| {
1475 |                 if ty.is_some() {
1476 |                     Term::app(acc, Term::var(j + vn))
1477 |                 } else {
1478 |                     Term::app(acc, Term::trivial())
1479 |                 }
1480 |             })
1481 |     }
1482 | 
1483 |     /// Creates a successive projection.
1484 |     ///
1485 |     /// # Examples
1486 |     ///
1487 |     /// ```
1488 |     /// use modules::rrd2014::internal::*;
1489 |     /// use Term::Int;
1490 |     ///
1491 |     /// assert_eq!(Term::proj(Int(0), None), Int(0));
1492 |     ///
1493 |     /// assert_eq!(
1494 |     ///     Term::proj(Int(1), vec![Label::from("a")]),
1495 |     ///     Term::Proj(Box::new(Int(1)), Label::from("a"))
1496 |     /// );
1497 |     ///
1498 |     /// assert_eq!(
1499 |     ///     Term::proj(Int(1), vec![Label::from("r"), Label::from("u")]),
1500 |     ///     Term::Proj(Box::new(Term::Proj(Box::new(Int(1)), Label::from("r"))), Label::from("u"))
1501 |     /// );
1502 |     ///
1503 |     /// assert_eq!(
1504 |     ///     Term::proj(Term::var(800), vec![Label::from("q"), Label::from("u")]),
1505 |     ///     Term::Proj(Box::new(Term::Proj(Box::new(Term::var(800)), Label::from("q"))), Label::from("u"))
1506 |     /// );
1507 |     /// ```
1508 |     pub fn proj<I>(t: Term, ls: I) -> Self
1509 |     where
1510 |         I: IntoIterator<Item = Label>,
1511 |     {
1512 |         ls.into_iter().fold(t, |t, l| Term::Proj(Box::new(t), l))
1513 |     }
1514 | 
1515 |     /// Creates an n-ary polymorphic function.
1516 |     ///
1517 |     /// # Examples
1518 |     ///
1519 |     /// ```
1520 |     /// use modules::rrd2014::internal::*;
1521 |     /// use Term::Int;
1522 |     /// use Kind::*;
1523 |     ///
1524 |     /// assert_eq!(Term::poly(None, Int(0)), Int(0));
1525 |     ///
1526 |     /// assert_eq!(
1527 |     ///     Term::poly(vec![Mono], Int(1)),
1528 |     ///     Term::Poly(Mono, Box::new(Int(1)))
1529 |     /// );
1530 |     ///
1531 |     /// assert_eq!(
1532 |     ///     Term::poly(vec![Mono, Mono], Int(1)),
1533 |     ///     Term::Poly(Mono, Box::new(Term::Poly(Mono, Box::new(Int(1)))))
1534 |     /// );
1535 |     ///
1536 |     /// assert_eq!(
1537 |     ///     Term::poly(vec![Mono, Kind::fun(Mono, Mono)], Int(8)),
1538 |     ///     Term::Poly(Kind::fun(Mono, Mono), Box::new(Term::Poly(Mono, Box::new(Int(8)))))
1539 |     /// );
1540 |     /// ```
1541 |     pub fn poly<I>(ks: I, t: Term) -> Self
1542 |     where
1543 |         I: IntoIterator<Item = Kind>,
1544 |     {
1545 |         ks.into_iter().fold(t, |t, k| Term::Poly(k, Box::new(t)))
1546 |     }
1547 | 
1548 |     /// Creates an n-ary instantiation.
1549 |     ///
1550 |     /// # Examples
1551 |     ///
1552 |     /// ```
1553 |     /// use modules::rrd2014::internal::*;
1554 |     /// use Term::Int;
1555 |     ///
1556 |     /// assert_eq!(Term::inst(Int(0), None), Int(0));
1557 |     ///
1558 |     /// assert_eq!(
1559 |     ///     Term::inst(Int(1), vec![Type::Int]),
1560 |     ///     Term::Inst(Box::new(Int(1)), Type::Int)
1561 |     /// );
1562 |     ///
1563 |     /// assert_eq!(
1564 |     ///     Term::inst(Int(1), vec![Type::Int, Type::Int]),
1565 |     ///     Term::Inst(Box::new(Term::Inst(Box::new(Int(1)), Type::Int)), Type::Int)
1566 |     /// );
1567 |     ///
1568 |     /// assert_eq!(
1569 |     ///     Term::inst(Int(1), vec![Type::fun(Type::Int, Type::Int), Type::Int]),
1570 |     ///     Term::Inst(
1571 |     ///         Box::new(Term::Inst(Box::new(Int(1)), Type::fun(Type::Int, Type::Int))),
1572 |     ///         Type::Int
1573 |     ///     )
1574 |     /// );
1575 |     /// ```
1576 |     pub fn inst<I>(t: Term, tys: I) -> Self
1577 |     where
1578 |         I: IntoIterator<Item = Type>,
1579 |     {
1580 |         tys.into_iter().fold(t, |t, ty| Term::Inst(Box::new(t), ty))
1581 |     }
1582 | 
1583 |     /// Creates an n-ary let-expression.
1584 |     ///
1585 |     /// # Examples
1586 |     ///
1587 |     /// ```
1588 |     /// use modules::rrd2014::internal::*;
1589 |     /// use Term::Int;
1590 |     ///
1591 |     /// assert_eq!(Term::let_in(None, Int(0)), Int(0));
1592 |     ///
1593 |     /// assert_eq!(
1594 |     ///     Term::let_in(vec![Int(12)], Int(0)),
1595 |     ///     Term::Let(Box::new(Int(12)), Box::new(Int(0)))
1596 |     /// );
1597 |     ///
1598 |     /// assert_eq!(
1599 |     ///     Term::let_in(
1600 |     ///         vec![Int(12), Int(36)],
1601 |     ///         Int(0)
1602 |     ///     ),
1603 |     ///     Term::Let(
1604 |     ///         Box::new(Int(12)),
1605 |     ///         Box::new(
1606 |     ///             Term::Let(
1607 |     ///                 Box::new(Int(36)),
1608 |     ///                 Box::new(Int(0)),
1609 |     ///             )
1610 |     ///         )
1611 |     ///     )
1612 |     /// );
1613 |     /// ```
1614 |     pub fn let_in<I>(bs: I, t: Term) -> Self
1615 |     where
1616 |         I: IntoIterator<Item = Term>,
1617 |         I::IntoIter: DoubleEndedIterator,
1618 |     {
1619 |         bs.into_iter()
1620 |             .rfold(t, |acc, t0| Term::Let(Box::new(t0), Box::new(acc)))
1621 |     }
1622 | 
1623 |     pub fn r#let(t0: Term, t: Term) -> Self {
1624 |         Term::let_in(Some(t0), t)
1625 |     }
1626 |     /// Creates an n-ary pack.
1627 |     ///
1628 |     /// # Examples
1629 |     ///
1630 |     /// ```
1631 |     /// use modules::rrd2014::internal::*;
1632 |     /// use Kind::*;
1633 |     /// use Type::Int;
1634 |     ///
1635 |     /// assert_eq!(
1636 |     ///     Term::pack(Term::Int(3), vec![], None, Int),
1637 |     ///     Term::Int(3)
1638 |     /// );
1639 |     ///
1640 |     /// assert_eq!(
1641 |     ///     Term::pack(Term::Int(3), vec![Int], vec![Mono], Int),
1642 |     ///     Term::Pack(Int, Box::new(Term::Int(3)), Type::some(vec![Mono], Int))
1643 |     /// );
1644 |     ///
1645 |     /// assert_eq!(
1646 |     ///     Term::pack(Term::Int(3), vec![Int, Int], vec![Mono, Mono], Int),
1647 |     ///     Term::Pack(
1648 |     ///         Int,
1649 |     ///         Box::new(Term::Pack(Int, Box::new(Term::Int(3)), Type::some(vec![Mono], Int))),
1650 |     ///         Type::some(vec![Mono, Mono], Int)
1651 |     ///     )
1652 |     /// );
1653 |     ///
1654 |     /// assert_eq!(
1655 |     ///     Term::pack(
1656 |     ///         Term::Int(2),
1657 |     ///         vec![Type::var(576), Type::fun(Int, Int)],
1658 |     ///         vec![Kind::fun(Mono, Mono), Mono],
1659 |     ///         Int
1660 |     ///     ),
1661 |     ///     Term::Pack(
1662 |     ///         Type::fun(Int, Int),
1663 |     ///         Box::new(Term::Pack(
1664 |     ///             Type::var(576),
1665 |     ///             Box::new(Term::Int(2)),
1666 |     ///             Type::some(vec![Kind::fun(Mono, Mono)], Int)
1667 |     ///         )),
1668 |     ///         Type::some(vec![Kind::fun(Mono, Mono), Mono], Int)
1669 |     ///     )
1670 |     /// );
1671 |     ///
1672 |     /// assert_eq!(
1673 |     ///     Term::pack(
1674 |     ///         Term::Int(2),
1675 |     ///         vec![Type::var(576), Type::fun(Int, Int)],
1676 |     ///         vec![Kind::fun(Mono, Mono), Mono],
1677 |     ///         Type::fun(Type::var(0), Type::var(1))
1678 |     ///     ),
1679 |     ///     Term::Pack(
1680 |     ///         Type::fun(Int, Int),
1681 |     ///         Box::new(Term::Pack(
1682 |     ///             Type::var(576),
1683 |     ///             Box::new(Term::Int(2)),
1684 |     ///             Type::some(
1685 |     ///                 vec![Kind::fun(Mono, Mono)],
1686 |     ///                 Type::fun(Type::var(0), Type::fun(Int, Int))
1687 |     ///             )
1688 |     ///         )),
1689 |     ///         Type::some(vec![Kind::fun(Mono, Mono), Mono], Type::fun(Type::var(0), Type::var(1)))
1690 |     ///     )
1691 |     /// );
1692 |     ///
1693 |     /// assert_eq!(
1694 |     ///     Term::pack(
1695 |     ///         Term::Int(2),
1696 |     ///         vec![Type::var(576), Type::var(30)],
1697 |     ///         vec![Kind::fun(Mono, Mono), Mono],
1698 |     ///         Type::fun(Type::var(0), Type::var(1))
1699 |     ///     ),
1700 |     ///     Term::Pack(
1701 |     ///         Type::var(30),
1702 |     ///         Box::new(Term::Pack(
1703 |     ///             Type::var(576),
1704 |     ///             Box::new(Term::Int(2)),
1705 |     ///             Type::some(
1706 |     ///                 vec![Kind::fun(Mono, Mono)],
1707 |     ///                 Type::fun(Type::var(0), Type::var(31))
1708 |     ///             )
1709 |     ///         )),
1710 |     ///         Type::some(vec![Kind::fun(Mono, Mono), Mono], Type::fun(Type::var(0), Type::var(1)))
1711 |     ///     )
1712 |     /// );
1713 |     /// ```
1714 |     pub fn pack<K>(t: Term, tys: Vec<Type>, ks: K, mut body: Type) -> Self
1715 |     where
1716 |         K: IntoIterator<Item = Kind>,
1717 |     {
1718 |         let ks: Vec<Kind> = ks.into_iter().collect();
1719 |         let v: Vec<Type> = tys
1720 |             .iter()
1721 |             .enumerate()
1722 |             .rev()
1723 |             .map(|(i, ty)| {
1724 |                 let ret = body.clone();
1725 |                 body.subst_shift(i, &ty, isize::try_from(i).unwrap() + 1);
1726 |                 body.shift_above(i, -1);
1727 |                 ret
1728 |             })
1729 |             .enumerate()
1730 |             .map(|(i, ty)| Type::some(Vec::from(&ks[..ks.len() - i]), ty))
1731 |             .collect();
1732 |         tys.into_iter()
1733 |             .zip(v.into_iter().rev())
1734 |             .fold(t, |t, (wit, ty)| Term::Pack(wit, Box::new(t), ty))
1735 |     }
1736 | 
1737 |     /// Creates an n-ary unpack.
1738 |     ///
1739 |     /// # Examples
1740 |     ///
1741 |     /// ```
1742 |     /// use modules::rrd2014::internal::*;
1743 |     /// use Kind::*;
1744 |     /// use Term::*;
1745 |     ///
1746 |     /// assert_eq!(
1747 |     ///     Term::unpack(Int(3), 0, Int(5)),
1748 |     ///     Term::r#let(Int(3), Int(5))
1749 |     /// );
1750 |     ///
1751 |     /// assert_eq!(
1752 |     ///     Term::unpack(Int(3), 1, Int(5)),
1753 |     ///     Term::Unpack(
1754 |     ///         Box::new(Int(3)),
1755 |     ///         Box::new(Int(5)),
1756 |     ///     )
1757 |     /// );
1758 |     ///
1759 |     /// assert_eq!(
1760 |     ///     Term::unpack(Int(3), 2, Int(5)),
1761 |     ///     Term::Unpack(
1762 |     ///         Box::new(Int(3)),
1763 |     ///         Box::new(
1764 |     ///             Term::Unpack(
1765 |     ///                 Box::new(Term::var(0)),
1766 |     ///                 Box::new(Int(5)),
1767 |     ///             )
1768 |     ///         )
1769 |     ///     )
1770 |     /// );
1771 |     ///
1772 |     /// assert_eq!(
1773 |     ///     Term::unpack(Int(3), 3, Int(5)),
1774 |     ///     Term::Unpack(
1775 |     ///         Box::new(Int(3)),
1776 |     ///         Box::new(
1777 |     ///             Term::Unpack(
1778 |     ///                 Box::new(Term::var(0)),
1779 |     ///                 Box::new(
1780 |     ///                     Term::Unpack(
1781 |     ///                         Box::new(Term::var(0)),
1782 |     ///                         Box::new(Int(5)),
1783 |     ///                     )
1784 |     ///                 )
1785 |     ///             )
1786 |     ///         )
1787 |     ///     )
1788 |     /// );
1789 |     pub fn unpack(t1: Term, n: usize, t2: Term) -> Self {
1790 |         let mut t = t2;
1791 |         for _ in 1..n {
1792 |             t = Term::Unpack(Box::new(Term::var(0)), Box::new(t));
1793 |         }
1794 |         if 0 < n {
1795 |             Term::Unpack(Box::new(t1), Box::new(t))
1796 |         } else {
1797 |             Term::let_in(Some(t1), t)
1798 |         }
1799 |     }
1800 | 
1801 |     fn type_of<'a>(&'a self, ctx: &mut Context<'a>) -> Result<Type, TypeError> {
1802 |         use Term::*;
1803 |         match *self {
1804 |             Var(v) => Ok(ctx.lookup_value(v)?.into_owned()),
1805 |             Abs(ref ty1, ref t) => {
1806 |                 // FIXME: `ty1` must be well-kinded.
1807 |                 ctx.insert_value(Cow::Borrowed(ty1));
1808 |                 let ty2 = t.type_of(ctx)?;
1809 |                 ctx.drop_value();
1810 |                 Ok(Type::fun(ty1.clone(), ty2))
1811 |             }
1812 |             App(ref t1, ref t2) => {
1813 |                 let ty1 = t1.type_of(ctx)?.reduce();
1814 |                 let ty2 = t2.type_of(ctx)?.reduce();
1815 |                 match ty1 {
1816 |                     Type::Fun(ty11, ty12) if ty11.equal(&ty2) => Ok(*ty12),
1817 |                     Type::Fun(ty11, _) => Err(TypeError::Application(
1818 |                         t1.clone(),
1819 |                         t2.clone(),
1820 |                         Box::new(TypeError::TypeMismatch(*ty11, ty2)),
1821 |                     )),
1822 |                     _ => Err(TypeError::NotFunction(ty1)),
1823 |                 }
1824 |             }
1825 |             Record(ref r) => Ok(Type::Record(self::Record(
1826 |                 r.0.iter()
1827 |                     .map(|(l, t)| Ok((l.clone(), t.type_of(ctx)?)))
1828 |                     .collect::<Result<_, TypeError>>()?,
1829 |             ))),
1830 |             Proj(ref t, ref l) => match t.type_of(ctx)?.reduce() {
1831 |                 Type::Record(mut r) => {
1832 |                     r.0.remove(l)
1833 |                         .ok_or_else(|| TypeError::MissingLabel(*t.clone(), r, l.clone()))
1834 |                 }
1835 |                 ty => Err(TypeError::NotRecord(ty)),
1836 |             },
1837 |             Poly(ref k, ref t) => {
1838 |                 ctx.insert_type(Cow::Borrowed(k));
1839 |                 let ty = t.type_of(ctx)?;
1840 |                 ctx.drop_type();
1841 |                 Ok(Type::forall(Some(k.clone()), ty))
1842 |             }
1843 |             Inst(ref t, ref ty2) => {
1844 |                 let ty1 = t.type_of(ctx)?.reduce();
1845 |                 match ty1 {
1846 |                     Type::Forall(k1, mut ty) => {
1847 |                         let k2 = ty2.kind_of::<_, ()>(&mut Env::from(ctx.clone()))?;
1848 |                         if k1.equal(&k2) {
1849 |                             ty.subst_top(&mut ty2.clone());
1850 |                             Ok(*ty)
1851 |                         } else {
1852 |                             Err(TypeError::Inst(
1853 |                                 t.clone(),
1854 |                                 ty2.clone(),
1855 |                                 KindError::KindMismatch(k1, k2),
1856 |                             ))
1857 |                         }
1858 |                     }
1859 |                     _ => Err(TypeError::NotForall(ty1)),
1860 |                 }
1861 |             }
1862 |             Pack(ref ty1, ref t, ref ty2) => {
1863 |                 ty2.kind_of::<_, ()>(&mut Env::from(ctx.clone()))?
1864 |                     .mono()
1865 |                     .map_err(|e| TypeError::KindError(KindError::NotMono(ty2.clone(), e)))?;
1866 |                 match *ty2 {
1867 |                     Type::Some(ref k1, ref ty) => {
1868 |                         let k2 = ty1.kind_of::<_, ()>(&mut Env::from(ctx.clone()))?;
1869 |                         if k1.equal(&k2) {
1870 |                             let ty0 = t.type_of(ctx)?;
1871 |                             let mut ty = *ty.clone();
1872 |                             ty.subst_top(&mut ty1.clone());
1873 |                             if ty0.equal(&ty) {
1874 |                                 Ok(ty2.clone())
1875 |                             } else {
1876 |                                 Err(TypeError::Pack(
1877 |                                     Box::new(ty1.clone()),
1878 |                                     t.clone(),
1879 |                                     Box::new(ty2.clone()),
1880 |                                     Box::new(TypeError::TypeMismatch(ty0, ty)),
1881 |                                 ))
1882 |                             }
1883 |                         } else {
1884 |                             Err(TypeError::KindError(KindError::KindMismatch(
1885 |                                 k1.clone(),
1886 |                                 k2,
1887 |                             )))
1888 |                         }
1889 |                     }
1890 |                     ref ty2 => Err(TypeError::NotSome(ty2.clone())),
1891 |                 }
1892 |             }
1893 |             Unpack(ref t1, ref t2) => match t1.type_of(ctx)? {
1894 |                 Type::Some(k, ty1) => {
1895 |                     ctx.insert_type(Cow::Owned(k));
1896 |                     ctx.insert_value(Cow::Owned(*ty1));
1897 |                     let ty2 = t2.type_of(ctx)?;
1898 |                     ctx.drop_value();
1899 |                     ctx.drop_type();
1900 |                     ty2.kind_of::<_, ()>(&mut Env::from(ctx.clone()))?
1901 |                         .mono()
1902 |                         .map_err(|e| TypeError::KindError(KindError::NotMono(ty2.clone(), e)))?;
1903 |                     Ok(ty2)
1904 |                 }
1905 |                 ty1 => Err(TypeError::NotSome(ty1)),
1906 |             },
1907 |             Int(_) => Ok(Type::Int),
1908 |             Bool(_) => Ok(Type::Bool),
1909 |             If(ref t1, ref t2, ref t3) => match t1.type_of(ctx)? {
1910 |                 Type::Bool => {
1911 |                     let ty2 = t2.type_of(ctx)?;
1912 |                     let ty3 = t3.type_of(ctx)?;
1913 |                     if !ty2.equal(&ty3) {
1914 |                         return Err(TypeError::TypeMismatch(ty2, ty3));
1915 |                     }
1916 |                     Ok(ty2)
1917 |                 }
1918 |                 ty => Err(TypeError::NotBool(ty)),
1919 |             },
1920 |             BinOp(ref op, ref t1, ref t2) => {
1921 |                 use self::BinOp::*;
1922 |                 let ty1 = t1.type_of(ctx)?.reduce();
1923 |                 let ty2 = t2.type_of(ctx)?.reduce();
1924 |                 match *op {
1925 |                     LessThan | GreaterThan => {
1926 |                         ty1.must_be_int()?;
1927 |                         ty2.must_be_int()?;
1928 |                         Ok(Type::Bool)
1929 |                     }
1930 |                 }
1931 |             }
1932 |             Let(ref t1, ref t2) => {
1933 |                 let ty1 = t1.type_of(ctx)?;
1934 |                 ctx.insert_value(Cow::Owned(ty1));
1935 |                 let ty2 = t2.type_of(ctx)?;
1936 |                 ctx.drop_value();
1937 |                 Ok(ty2)
1938 |             }
1939 |         }
1940 |     }
1941 | }
1942 | 
1943 | pub fn typecheck(t: &Term, gtenv: Vec<Kind>) -> Result<Type, TypeError> {
1944 |     t.type_of(&mut Context {
1945 |         gtenv,
1946 |         ..Default::default()
1947 |     })
1948 | }
1949 | 
1950 | #[derive(Debug, Fail, PartialEq)]
1951 | pub enum EnvError {
1952 |     #[fail(display = "unbound type variable: {:?}", _0)]
1953 |     UnboundTypeVariable(Variable),
1954 | 
1955 |     #[fail(display = "unbound variable: {:?}", _0)]
1956 |     UnboundVariable(Variable),
1957 | 
1958 |     #[fail(display = "unbound name: {:?}", _0)]
1959 |     UnboundName(Name),
1960 | }
1961 | 
1962 | #[derive(Debug, Fail, PartialEq)]
1963 | pub enum UnificationError {
1964 |     #[fail(display = "could not unify: {:?} and {:?}", _0, _1)]
1965 |     NotUnifiable(Type, Type),
1966 | 
1967 |     #[fail(display = "recursive type is not allowed: {:?} and {:?}", _0, _1)]
1968 |     Recursion(Variable, Type),
1969 | }
1970 | 
1971 | impl<T, S> Env<T, S> {
1972 |     pub fn get_generated_type_env(self) -> Vec<Kind> {
1973 |         self.gtenv
1974 |     }
1975 | 
1976 |     pub fn tenv_len(&self) -> usize {
1977 |         self.tenv.len()
1978 |     }
1979 | 
1980 |     pub fn venv_len_purity(&self, p: Purity) -> usize {
1981 |         if p.is_pure() {
1982 |             self.venv.len()
1983 |         } else {
1984 |             0
1985 |         }
1986 |     }
1987 | 
1988 |     pub fn venv_abs_len_purity(&self, p: Purity) -> usize {
1989 |         if p.is_pure() {
1990 |             self.venv.iter().filter(|x| x.is_some()).count()
1991 |         } else {
1992 |             0
1993 |         }
1994 |     }
1995 | 
1996 |     pub fn lookup_type(&self, v: Variable) -> Result<(Kind, S), EnvError>
1997 |     where
1998 |         S: Clone + Default,
1999 |     {
2000 |         match v {
2001 |             V(n) => self
2002 |                 .tenv
2003 |                 .iter()
2004 |                 .rev()
2005 |                 .nth(n)
2006 |                 .cloned()
2007 |                 .ok_or_else(|| EnvError::UnboundTypeVariable(v)),
2008 |             Variable::Generated(n) => self
2009 |                 .gtenv
2010 |                 .get(n)
2011 |                 .cloned()
2012 |                 .map(|k| (k, S::default()))
2013 |                 .ok_or_else(|| EnvError::UnboundTypeVariable(v)),
2014 |         }
2015 |     }
2016 | 
2017 |     pub fn lookup_value(&self, v: Variable) -> Result<T, EnvError>
2018 |     where
2019 |         T: Clone,
2020 |     {
2021 |         let n = v.get_index();
2022 |         self.venv
2023 |             .iter()
2024 |             .rev()
2025 |             .nth(n)
2026 |             .cloned()
2027 |             .ok_or_else(|| EnvError::UnboundVariable(v))?
2028 |             .ok_or_else(|| EnvError::UnboundVariable(v))
2029 |     }
2030 | 
2031 |     pub fn lookup_value_by_name(&self, name: &Name) -> Result<(T, Variable), EnvError>
2032 |     where
2033 |         T: Clone,
2034 |     {
2035 |         let n = *self
2036 |             .nmap
2037 |             .get(&name)
2038 |             .ok_or_else(|| EnvError::UnboundName(name.clone()))?;
2039 |         Ok((
2040 |             self.venv
2041 |                 .get(n)
2042 |                 .expect("lookup_value_by_name: unexpected None")
2043 |                 .clone()
2044 |                 .expect("lookup_value_by_name: unexpected None"),
2045 |             V(self.venv.len() - n - 1),
2046 |         ))
2047 |     }
2048 | 
2049 |     pub fn insert_type(&mut self, k: Kind, x: S)
2050 |     where
2051 |         T: Shift,
2052 |     {
2053 |         self.tenv.push((k, x));
2054 |         self.tenv.iter_mut().for_each(|k| k.0.shift(1));
2055 |         self.venv.iter_mut().for_each(|x| x.shift(1));
2056 |     }
2057 | 
2058 |     pub fn insert_types<I>(&mut self, ks: I)
2059 |     where
2060 |         T: Shift,
2061 |         I: IntoIterator<Item = (Kind, S)>,
2062 |     {
2063 |         ks.into_iter().for_each(|(k, x)| self.insert_type(k, x));
2064 |     }
2065 | 
2066 |     fn drop_type(&mut self)
2067 |     where
2068 |         T: Shift,
2069 |     {
2070 |         self.tenv.pop();
2071 |         self.tenv.iter_mut().for_each(|k| k.0.shift(-1));
2072 |         self.venv.iter_mut().for_each(|x| x.shift(-1));
2073 |     }
2074 | 
2075 |     /// One should probably use `drop_values_state` before `drop_types` and `drop_type` in case
2076 |     /// indices in value environment become negative and then the program panics.
2077 |     pub fn drop_types(&mut self, n: usize)
2078 |     where
2079 |         T: Shift,
2080 |     {
2081 |         self.tenv.truncate(self.tenv.len() - n);
2082 |         let m = isize::try_from(n).unwrap();
2083 |         self.tenv.iter_mut().for_each(|k| k.0.shift(-m));
2084 |         self.venv.iter_mut().for_each(|x| x.shift(-m));
2085 |     }
2086 | 
2087 |     pub fn insert_value(&mut self, name: Name, x: T) {
2088 |         self.nmap.insert(name, self.venv.len());
2089 |         self.venv.push(Some(x));
2090 |     }
2091 | 
2092 |     fn insert_dummy_value(&mut self) {
2093 |         self.venv.push(None);
2094 |     }
2095 | 
2096 |     pub fn insert_dummy_values(&mut self, n: usize) {
2097 |         for _ in 0..n {
2098 |             self.insert_dummy_value();
2099 |         }
2100 |     }
2101 | 
2102 |     fn insert_dummy_value_at(&mut self, v: Variable) {
2103 |         let n = self.venv.len() - v.get_index();
2104 |         self.venv.insert(n, None);
2105 |         self.nmap.values_mut().for_each(|i| {
2106 |             if *i >= n {
2107 |                 *i += 1;
2108 |             }
2109 |         })
2110 |     }
2111 | 
2112 |     pub fn insert_dummy_values_at(&mut self, v: Variable, n: usize) {
2113 |         for _ in 0..n {
2114 |             self.insert_dummy_value_at(v);
2115 |         }
2116 |     }
2117 | 
2118 |     pub fn drop_values_state(&mut self, n: usize, state: EnvState) {
2119 |         self.venv.truncate(self.venv.len() - n);
2120 |         self.nmap = state.0;
2121 |     }
2122 | 
2123 |     pub fn get_state(&self) -> EnvState {
2124 |         EnvState(self.nmap.clone())
2125 |     }
2126 | 
2127 |     pub fn unify<I>(&mut self, iter: I) -> Result<Subst, UnificationError>
2128 |     where
2129 |         I: IntoIterator<Item = (Type, Type)>,
2130 |         T: Substitution,
2131 |     {
2132 |         self.unify_aux(iter, Subst::default())
2133 |     }
2134 | 
2135 |     fn unify_aux<I>(&mut self, iter: I, mut s: Subst) -> Result<Subst, UnificationError>
2136 |     where
2137 |         I: IntoIterator<Item = (Type, Type)>,
2138 |         T: Substitution,
2139 |     {
2140 |         use Type::*;
2141 |         let mut w: Vec<(Type, Type)> = iter.into_iter().collect();
2142 |         loop {
2143 |             if let Option::Some((ty1, ty2)) = w.pop() {
2144 |                 if ty1 == ty2 {
2145 |                     continue;
2146 |                 }
2147 |                 match (ty1, ty2) {
2148 |                     (Var(v), ty) | (ty, Var(v)) => {
2149 |                         let tvs = ty.ftv();
2150 |                         if tvs.contains(&v) {
2151 |                             return Err(UnificationError::Recursion(v, ty));
2152 |                         }
2153 |                         let new_s = Subst::from_iter(vec![(v, ty)]);
2154 |                         self.apply(&new_s);
2155 |                         w.apply(&new_s);
2156 |                         s = s.compose(new_s);
2157 |                     }
2158 |                     (Fun(ty11, ty12), Fun(ty21, ty22)) => {
2159 |                         w.extend(vec![(*ty11, *ty21), (*ty12, *ty22)]);
2160 |                     }
2161 |                     (ty1, ty2) => Err(UnificationError::NotUnifiable(ty1, ty2))?,
2162 |                 }
2163 |             } else {
2164 |                 return Ok(s);
2165 |             }
2166 |         }
2167 |     }
2168 | 
2169 |     pub fn fresh_type_variable(&mut self, k: Kind) -> Variable
2170 |     where
2171 |         T: Shift,
2172 |     {
2173 |         self.gtenv.push(k);
2174 |         let n = self.n;
2175 |         self.n += 1;
2176 |         Variable::Generated(n)
2177 |     }
2178 | }
2179 | 
2180 | impl<T, S> EnvAbs<T, S> {
2181 |     pub fn venv_len_purity(&self, p: Purity) -> usize {
2182 |         if p.is_pure() {
2183 |             self.venv.len()
2184 |         } else {
2185 |             0
2186 |         }
2187 |     }
2188 | 
2189 |     pub fn venv_abs_len_purity(&self, p: Purity) -> usize {
2190 |         if p.is_pure() {
2191 |             self.venv.iter().filter(|x| x.is_some()).count()
2192 |         } else {
2193 |             0
2194 |         }
2195 |     }
2196 | }
2197 | 
2198 | impl<'a, T: Clone, S: Clone> From<&'a Env<T, S>> for EnvAbs<T, S> {
2199 |     fn from(env: &'a Env<T, S>) -> EnvAbs<T, S> {
2200 |         EnvAbs {
2201 |             tenv: env.tenv.clone(),
2202 |             venv: env.venv.clone(),
2203 |         }
2204 |     }
2205 | }
2206 | 
2207 | impl<'a, T: Clone, S: Clone> From<&'a mut Env<T, S>> for EnvAbs<T, S> {
2208 |     fn from(env: &'a mut Env<T, S>) -> EnvAbs<T, S> {
2209 |         EnvAbs {
2210 |             tenv: env.tenv.clone(),
2211 |             venv: env.venv.clone(),
2212 |         }
2213 |     }
2214 | }
2215 | 
2216 | impl Subst {
2217 |     pub fn compose(mut self, s: Subst) -> Self {
2218 |         self.apply(&s);
2219 |         self.0.extend(s.0);
2220 |         self
2221 |     }
2222 | 
2223 |     pub fn shift(self, d: isize) -> Self {
2224 |         let f = |p: (Variable, Type)| {
2225 |             let (v, mut ty) = p;
2226 |             ty.shift(d);
2227 |             (v.add(d), ty)
2228 |         };
2229 |         Subst(self.0.into_iter().map(f).collect())
2230 |     }
2231 | }
2232 | 
2233 | impl<'a> Context<'a> {
2234 |     fn lookup_value(&self, v: Variable) -> Result<Cow<Type>, EnvError> {
2235 |         self.venv
2236 |             .iter()
2237 |             .rev()
2238 |             .nth(v.get_index())
2239 |             .cloned()
2240 |             .ok_or_else(|| EnvError::UnboundVariable(v))
2241 |     }
2242 | 
2243 |     fn insert_type(&mut self, k: Cow<'a, Kind>) {
2244 |         self.tenv.push(k);
2245 |         self.tenv.iter_mut().for_each(|k| k.to_mut().shift(1));
2246 |         self.venv.iter_mut().for_each(|x| x.to_mut().shift(1));
2247 |     }
2248 | 
2249 |     /// One should probably use `drop_value` prior to `drop_type` in case indices in value
2250 |     /// environment become negative and then the program panics.
2251 |     fn drop_type(&mut self) {
2252 |         self.tenv.pop();
2253 |         self.tenv.iter_mut().for_each(|k| k.to_mut().shift(-1));
2254 |         self.venv.iter_mut().for_each(|x| x.to_mut().shift(-1));
2255 |     }
2256 | 
2257 |     fn insert_value(&mut self, ty: Cow<'a, Type>) {
2258 |         self.venv.push(ty);
2259 |     }
2260 | 
2261 |     fn drop_value(&mut self) {
2262 |         self.venv.pop();
2263 |     }
2264 | }
2265 | 
2266 | impl<'a, S: Clone + Default> From<Context<'a>> for Env<Type, S> {
2267 |     fn from(ctx: Context<'a>) -> Self {
2268 |         Env {
2269 |             tenv: ctx
2270 |                 .tenv
2271 |                 .into_iter()
2272 |                 .map(|k| (k.into_owned(), S::default()))
2273 |                 .collect(),
2274 |             venv: ctx
2275 |                 .venv
2276 |                 .into_iter()
2277 |                 .map(|ty| Some(ty.into_owned()))
2278 |                 .collect(),
2279 |             gtenv: ctx.gtenv,
2280 |             nmap: HashMap::new(),
2281 |             n: 0, // TODO: Is this correct?
2282 |         }
2283 |     }
2284 | }
2285 | 
2286 | #[cfg(test)]
2287 | mod tests {
2288 |     #![warn(dead_code)]
2289 |     use super::*;
2290 | 
2291 |     macro_rules! assert_type_shift {
2292 |         ($t:expr, $d:expr, $r:expr) => {{
2293 |             let mut ty = $t;
2294 |             ty.shift($d);
2295 |             assert_eq!(ty, $r);
2296 |         }};
2297 |     }
2298 | 
2299 |     #[test]
2300 |     fn type_shift() {
2301 |         use Kind::Mono;
2302 |         use Type::*;
2303 | 
2304 |         assert_type_shift!(Int, 0, Int);
2305 |         assert_type_shift!(Int, 1, Int);
2306 | 
2307 |         assert_type_shift!(Type::var(0), 0, Type::var(0));
2308 |         assert_type_shift!(Type::var(0), 1, Type::var(1));
2309 |         assert_type_shift!(Type::var(0), 2, Type::var(2));
2310 | 
2311 |         assert_type_shift!(Type::var(1), 2, Type::var(3));
2312 |         assert_type_shift!(Type::var(8), 1, Type::var(9));
2313 | 
2314 |         assert_type_shift!(
2315 |             Type::some(vec![Mono], Type::var(0)),
2316 |             1,
2317 |             Type::some(vec![Mono], Type::var(0))
2318 |         );
2319 | 
2320 |         assert_type_shift!(
2321 |             Type::some(vec![Mono], Type::var(1)),
2322 |             1,
2323 |             Type::some(vec![Mono], Type::var(2))
2324 |         );
2325 | 
2326 |         assert_type_shift!(
2327 |             Type::some(vec![Mono], Type::var(8)),
2328 |             1,
2329 |             Type::some(vec![Mono], Type::var(9))
2330 |         );
2331 | 
2332 |         assert_type_shift!(
2333 |             Type::some(vec![Mono], Type::var(48)),
2334 |             70136,
2335 |             Type::some(vec![Mono], Type::var(70184))
2336 |         );
2337 | 
2338 |         assert_type_shift!(
2339 |             Type::some(vec![Mono], Type::var(48)),
2340 |             -29,
2341 |             Type::some(vec![Mono], Type::var(19))
2342 |         );
2343 | 
2344 |         assert_type_shift!(
2345 |             Type::some(vec![Mono], Type::var(48)),
2346 |             -48,
2347 |             Type::some(vec![Mono], Type::var(0))
2348 |         );
2349 |     }
2350 | 
2351 |     #[test]
2352 |     #[should_panic]
2353 |     fn type_shift_panic() {
2354 |         use Kind::Mono;
2355 | 
2356 |         assert_type_shift!(
2357 |             Type::some(vec![Mono], Type::var(4)),
2358 |             -48,
2359 |             Type::some(vec![Mono], Type::var(0))
2360 |         );
2361 |     }
2362 | 
2363 |     macro_rules! assert_type_subst {
2364 |         ($t:expr, $j:expr, $by:expr, $r:expr) => {{
2365 |             let mut ty = $t;
2366 |             ty.subst($j, &$by);
2367 |             assert_eq!(ty, $r);
2368 |         }};
2369 |     }
2370 | 
2371 |     #[test]
2372 |     fn type_subst() {
2373 |         use Kind::Mono;
2374 |         use Type::*;
2375 | 
2376 |         assert_type_subst!(Int, 0, Int, Int);
2377 |         assert_type_subst!(Int, 1, Int, Int);
2378 | 
2379 |         assert_type_subst!(Type::var(0), 0, Int, Int);
2380 |         assert_type_subst!(Type::var(1), 0, Int, Type::var(1));
2381 |         assert_type_subst!(Type::var(0), 1, Int, Type::var(0));
2382 | 
2383 |         assert_type_subst!(Type::var(0), 0, Type::var(0), Type::var(0));
2384 |         assert_type_subst!(Type::var(1), 0, Type::var(0), Type::var(1));
2385 |         assert_type_subst!(Type::var(0), 1, Type::var(0), Type::var(0));
2386 |         assert_type_subst!(Type::var(0), 0, Type::var(1), Type::var(1));
2387 |         assert_type_subst!(Type::var(1), 1, Type::var(0), Type::var(0));
2388 | 
2389 |         assert_type_subst!(
2390 |             Type::some(vec![Mono], Type::var(0)),
2391 |             0,
2392 |             Type::var(0),
2393 |             Type::some(vec![Mono], Type::var(0))
2394 |         );
2395 | 
2396 |         assert_type_subst!(
2397 |             Type::some(vec![Mono], Type::var(1)),
2398 |             0,
2399 |             Type::var(0),
2400 |             Type::some(vec![Mono], Type::var(1))
2401 |         );
2402 | 
2403 |         assert_type_subst!(
2404 |             Type::some(vec![Mono], Type::var(1)),
2405 |             0,
2406 |             Type::var(106),
2407 |             Type::some(vec![Mono], Type::var(107))
2408 |         );
2409 | 
2410 |         assert_type_subst!(
2411 |             Type::some(vec![Mono], Type::var(0)),
2412 |             0,
2413 |             Type::var(106),
2414 |             Type::some(vec![Mono], Type::var(0))
2415 |         );
2416 | 
2417 |         assert_type_subst!(
2418 |             Type::some(vec![Mono, Mono], Type::var(1)),
2419 |             0,
2420 |             Type::var(106),
2421 |             Type::some(vec![Mono, Mono], Type::var(1))
2422 |         );
2423 | 
2424 |         assert_type_subst!(
2425 |             Type::some(vec![Mono, Mono], Type::var(3)),
2426 |             1,
2427 |             Type::var(16),
2428 |             Type::some(vec![Mono, Mono], Type::var(18))
2429 |         );
2430 |     }
2431 | 
2432 |     #[test]
2433 |     fn pack() {
2434 |         use Kind::*;
2435 | 
2436 |         fn label(x: &str) -> Label {
2437 |             Label::Label(Name(x.to_string()))
2438 |         }
2439 | 
2440 |         assert_eq!(
2441 |             Term::pack(
2442 |                 Term::Int(1),
2443 |                 vec![
2444 |                     Type::var(576),
2445 |                     Type::var(0),
2446 |                     Type::forall(vec![Mono], Type::var(0)),
2447 |                     Type::var(30)
2448 |                 ],
2449 |                 vec![
2450 |                     Kind::fun(Mono, Mono),
2451 |                     Kind::fun(Mono, Kind::fun(Mono, Mono)),
2452 |                     Kind::fun(Kind::fun(Mono, Mono), Mono),
2453 |                     Mono
2454 |                 ],
2455 |                 Type::record(vec![
2456 |                     (label("a"), Type::var(3)),
2457 |                     (label("b"), Type::var(2)),
2458 |                     (label("c"), Type::var(0)),
2459 |                     (label("d"), Type::var(1)),
2460 |                     (label("e"), Type::var(4)),
2461 |                 ])
2462 |             ),
2463 |             Term::Pack(
2464 |                 Type::var(30),
2465 |                 Box::new(Term::Pack(
2466 |                     Type::forall(vec![Mono], Type::var(0)),
2467 |                     Box::new(Term::Pack(
2468 |                         Type::var(0),
2469 |                         Box::new(Term::Pack(
2470 |                             Type::var(576),
2471 |                             Box::new(Term::Int(1)),
2472 |                             Type::some(
2473 |                                 vec![Kind::fun(Mono, Mono)],
2474 |                                 Type::record(vec![
2475 |                                     (label("a"), Type::var(31)),
2476 |                                     (label("b"), Type::forall(vec![Mono], Type::var(0))),
2477 |                                     (label("c"), Type::var(0)),
2478 |                                     (label("d"), Type::var(1)),
2479 |                                     (label("e"), Type::var(1)),
2480 |                                 ])
2481 |                             ),
2482 |                         )),
2483 |                         Type::some(
2484 |                             vec![
2485 |                                 Kind::fun(Mono, Mono),
2486 |                                 Kind::fun(Mono, Kind::fun(Mono, Mono))
2487 |                             ],
2488 |                             Type::record(vec![
2489 |                                 (label("a"), Type::var(32)),
2490 |                                 (label("b"), Type::forall(vec![Mono], Type::var(0))),
2491 |                                 (label("c"), Type::var(0)),
2492 |                                 (label("d"), Type::var(1)),
2493 |                                 (label("e"), Type::var(2)),
2494 |                             ])
2495 |                         ),
2496 |                     )),
2497 |                     Type::some(
2498 |                         vec![
2499 |                             Kind::fun(Mono, Mono),
2500 |                             Kind::fun(Mono, Kind::fun(Mono, Mono)),
2501 |                             Kind::fun(Kind::fun(Mono, Mono), Mono)
2502 |                         ],
2503 |                         Type::record(vec![
2504 |                             (label("a"), Type::var(33)),
2505 |                             (label("b"), Type::var(2)),
2506 |                             (label("c"), Type::var(0)),
2507 |                             (label("d"), Type::var(1)),
2508 |                             (label("e"), Type::var(3)),
2509 |                         ])
2510 |                     ),
2511 |                 )),
2512 |                 Type::some(
2513 |                     vec![
2514 |                         Kind::fun(Mono, Mono),
2515 |                         Kind::fun(Mono, Kind::fun(Mono, Mono)),
2516 |                         Kind::fun(Kind::fun(Mono, Mono), Mono),
2517 |                         Mono
2518 |                     ],
2519 |                     Type::record(vec![
2520 |                         (label("a"), Type::var(3)),
2521 |                         (label("b"), Type::var(2)),
2522 |                         (label("c"), Type::var(0)),
2523 |                         (label("d"), Type::var(1)),
2524 |                         (label("e"), Type::var(4)),
2525 |                     ])
2526 |                 ),
2527 |             )
2528 |         );
2529 | 
2530 |         assert_eq!(
2531 |             Term::pack(
2532 |                 Term::Int(1),
2533 |                 vec![Type::var(0), Type::var(1), Type::var(2)],
2534 |                 vec![Mono, Mono, Mono],
2535 |                 Type::record(vec![
2536 |                     (label("a"), Type::var(2)),
2537 |                     (label("b"), Type::var(1)),
2538 |                     (label("c"), Type::var(0)),
2539 |                 ])
2540 |             ),
2541 |             Term::Pack(
2542 |                 Type::var(2),
2543 |                 Box::new(Term::Pack(
2544 |                     Type::var(1),
2545 |                     Box::new(Term::Pack(
2546 |                         Type::var(0),
2547 |                         Box::new(Term::Int(1)),
2548 |                         Type::some(
2549 |                             vec![Mono],
2550 |                             Type::record(vec![
2551 |                                 (label("a"), Type::var(3)),
2552 |                                 (label("b"), Type::var(2)),
2553 |                                 (label("c"), Type::var(0)),
2554 |                             ])
2555 |                         ),
2556 |                     )),
2557 |                     Type::some(
2558 |                         vec![Mono, Mono],
2559 |                         Type::record(vec![
2560 |                             (label("a"), Type::var(4)),
2561 |                             (label("b"), Type::var(1)),
2562 |                             (label("c"), Type::var(0)),
2563 |                         ])
2564 |                     ),
2565 |                 )),
2566 |                 Type::some(
2567 |                     vec![Mono, Mono, Mono],
2568 |                     Type::record(vec![
2569 |                         (label("a"), Type::var(2)),
2570 |                         (label("b"), Type::var(1)),
2571 |                         (label("c"), Type::var(0)),
2572 |                     ])
2573 |                 ),
2574 |             )
2575 |         );
2576 |     }
2577 | 
2578 |     #[test]
2579 |     fn env_lookup() {
2580 |         use Kind::*;
2581 | 
2582 |         let env = Env {
2583 |             tenv: vec![(Mono, "M.t"), (Kind::fun(Mono, Mono), "M.s")],
2584 |             venv: vec![Type::var(3), Type::var(6)]
2585 |                 .into_iter()
2586 |                 .map(Some)
2587 |                 .collect(),
2588 |             ..Default::default()
2589 |         };
2590 | 
2591 |         assert_eq!(env.lookup_type(V(0)), Ok((Kind::fun(Mono, Mono), "M.s")));
2592 |         assert_eq!(env.lookup_type(V(1)), Ok((Mono, "M.t")));
2593 | 
2594 |         assert_eq!(env.lookup_value(V(0)), Ok(Type::var(6)));
2595 |         assert_eq!(env.lookup_value(V(1)), Ok(Type::var(3)));
2596 | 
2597 |         let mut env = env;
2598 |         env.insert_type(Kind::fun(Mono, Kind::fun(Mono, Mono)), "M.u");
2599 | 
2600 |         assert_eq!(
2601 |             env.lookup_type(V(0)),
2602 |             Ok((Kind::fun(Mono, Kind::fun(Mono, Mono)), "M.u"))
2603 |         );
2604 |         assert_eq!(env.lookup_type(V(1)), Ok((Kind::fun(Mono, Mono), "M.s")));
2605 |         assert_eq!(env.lookup_type(V(2)), Ok((Mono, "M.t")));
2606 | 
2607 |         assert_eq!(
2608 |             env.lookup_type(V(3)),
2609 |             Err(EnvError::UnboundTypeVariable(V(3)))
2610 |         );
2611 | 
2612 |         assert_eq!(env.lookup_value(V(0)), Ok(Type::var(7)));
2613 |         assert_eq!(env.lookup_value(V(1)), Ok(Type::var(4)));
2614 | 
2615 |         assert_eq!(env.lookup_value(V(2)), Err(EnvError::UnboundVariable(V(2))));
2616 |     }
2617 | 
2618 |     #[test]
2619 |     fn env_insert() {
2620 |         use Kind::*;
2621 | 
2622 |         let mut env = Env {
2623 |             tenv: vec![(Mono, "N.t")],
2624 |             venv: vec![Type::var(0)].into_iter().map(Some).collect(),
2625 |             ..Default::default()
2626 |         };
2627 |         env.insert_type(Mono, "P.t");
2628 |         assert_eq!(
2629 |             env,
2630 |             Env {
2631 |                 tenv: vec![(Mono, "N.t"), (Mono, "P.t")],
2632 |                 venv: vec![Type::var(1)].into_iter().map(Some).collect(),
2633 |                 ..Default::default()
2634 |             }
2635 |         );
2636 |     }
2637 | 
2638 |     #[test]
2639 |     fn env_by_name() {
2640 |         use Kind::*;
2641 |         use Type::*;
2642 | 
2643 |         let mut env = Env {
2644 |             tenv: vec![(Mono, "t")],
2645 |             venv: vec![],
2646 |             ..Default::default()
2647 |         };
2648 | 
2649 |         env.insert_value(Name::from("x"), Int);
2650 |         assert_eq!(env.lookup_value_by_name(&Name::from("x")), Ok((Int, V(0))));
2651 | 
2652 |         env.insert_value(Name::from("y"), Type::fun(Int, Int));
2653 |         assert_eq!(env.lookup_value_by_name(&Name::from("x")), Ok((Int, V(1))));
2654 |         assert_eq!(
2655 |             env.lookup_value_by_name(&Name::from("y")),
2656 |             Ok((Type::fun(Int, Int), V(0)))
2657 |         );
2658 | 
2659 |         env.insert_value(Name::from("x"), Type::fun(Int, Type::var(0)));
2660 |         assert_eq!(
2661 |             env.lookup_value_by_name(&Name::from("x")),
2662 |             Ok((Type::fun(Int, Type::var(0)), V(0)))
2663 |         );
2664 |         assert_eq!(
2665 |             env.lookup_value_by_name(&Name::from("y")),
2666 |             Ok((Type::fun(Int, Int), V(1)))
2667 |         );
2668 |     }
2669 | 
2670 |     macro_rules! assert_encoding {
2671 |         ($s:expr, $x:expr) => {{
2672 |             assert_eq!(Type::from($s), $x);
2673 |         }};
2674 |     }
2675 | 
2676 |     #[test]
2677 |     fn encoding() {
2678 |         use crate::rrd2014::SemanticSig;
2679 |         use crate::rrd2014::SemanticSig::*;
2680 |         use Kind::*;
2681 |         use Type::*;
2682 | 
2683 |         assert_encoding!(SemanticSig::default_atomic_term(Int), Int);
2684 |         assert_encoding!(SemanticSig::default_atomic_term(Type::var(0)), Type::var(0));
2685 | 
2686 |         assert_encoding!(
2687 |             AtomicType(Int, Mono),
2688 |             Type::forall(
2689 |                 vec![Kind::fun(Mono, Mono)],
2690 |                 Type::fun(Type::app(Type::var(0), Int), Type::app(Type::var(0), Int))
2691 |             )
2692 |         );
2693 | 
2694 |         assert_encoding!(
2695 |             AtomicType(Type::var(0), Mono),
2696 |             Type::forall(
2697 |                 vec![Kind::fun(Mono, Mono)],
2698 |                 Type::fun(
2699 |                     Type::app(Type::var(0), Type::var(1)),
2700 |                     Type::app(Type::var(0), Type::var(1)),
2701 |                 )
2702 |             )
2703 |         );
2704 |     }
2705 | 
2706 |     impl Shift for () {
2707 |         fn shift_above(&mut self, _: usize, _: isize) {}
2708 |     }
2709 | 
2710 |     macro_rules! assert_kinding_ok {
2711 |         ($ty:expr, $k:expr) => {{
2712 |             use Option::Some as S;
2713 |             assert_eq!($ty.kind_of::<(), ()>(&mut Env::default()).ok(), S($k));
2714 |         }};
2715 |     }
2716 | 
2717 |     macro_rules! assert_kinding_err {
2718 |         ($ty:expr, $e:expr) => {{
2719 |             match $ty.kind_of::<(), ()>(&mut Env::default()) {
2720 |                 Err(e) => assert_eq!(e, $e, "{:?}", e),
2721 |                 Ok(k) => panic!("unexpectedly well-kinded: {:?}", k),
2722 |             }
2723 |         }};
2724 |     }
2725 | 
2726 |     #[test]
2727 |     fn kinding() {
2728 |         use super::Record as R;
2729 |         use Kind::Mono;
2730 |         use Type::*;
2731 | 
2732 |         assert_kinding_ok!(Int, Mono);
2733 |         assert_kinding_ok!(Type::fun(Int, Int), Mono);
2734 |         assert_kinding_ok!(Type::forall(vec![Mono], Int), Mono);
2735 |         assert_kinding_ok!(Type::some(vec![Kind::fun(Mono, Mono)], Int), Mono);
2736 |         assert_kinding_ok!(Type::abs(vec![Mono], Int), Kind::fun(Mono, Mono));
2737 |         assert_kinding_ok!(
2738 |             Type::abs(vec![Kind::fun(Mono, Mono)], Int),
2739 |             Kind::fun(Kind::fun(Mono, Mono), Mono)
2740 |         );
2741 |         assert_kinding_ok!(Type::app(Type::abs(vec![Mono], Int), Int), Mono);
2742 |         assert_kinding_ok!(Type::abs(vec![Mono], Type::var(0)), Kind::fun(Mono, Mono));
2743 |         assert_kinding_ok!(
2744 |             Type::abs(vec![Kind::fun(Mono, Mono)], Type::var(0)),
2745 |             Kind::fun(Kind::fun(Mono, Mono), Kind::fun(Mono, Mono))
2746 |         );
2747 |         assert_kinding_ok!(Record(R::from_iter(None)), Mono);
2748 |         assert_kinding_ok!(Record(R::from_iter(vec![(Label::from("a"), Int)])), Mono);
2749 |         assert_kinding_ok!(
2750 |             Record(R::from_iter(vec![
2751 |                 (Label::from("a"), Int),
2752 |                 (Label::from("b"), Int)
2753 |             ])),
2754 |             Mono
2755 |         );
2756 | 
2757 |         assert_kinding_err!(
2758 |             Type::var(0),
2759 |             KindError::Env(EnvError::UnboundTypeVariable(V(0)))
2760 |         );
2761 |         assert_kinding_err!(
2762 |             Type::fun(Int, Type::abs(vec![Mono], Int)),
2763 |             KindError::Codomain(
2764 |                 Type::abs(vec![Mono], Int),
2765 |                 NotMonoError(Kind::fun(Mono, Mono))
2766 |             )
2767 |         );
2768 |         assert_kinding_err!(
2769 |             Type::some(vec![Mono], Type::abs(vec![Mono], Int)),
2770 |             KindError::NotMono(
2771 |                 Type::abs(vec![Mono], Int),
2772 |                 NotMonoError(Kind::fun(Mono, Mono))
2773 |             )
2774 |         );
2775 |         assert_kinding_err!(
2776 |             Record(R::from_iter(vec![(
2777 |                 Label::from("a"),
2778 |                 Type::abs(vec![Mono], Type::var(0))
2779 |             )])),
2780 |             KindError::Record(
2781 |                 Label::from("a"),
2782 |                 Box::new(KindError::NotMono(
2783 |                     Type::abs(vec![Mono], Type::var(0)),
2784 |                     NotMonoError(Kind::fun(Mono, Mono))
2785 |                 ))
2786 |             )
2787 |         );
2788 |         assert_kinding_err!(
2789 |             Record(R::from_iter(vec![
2790 |                 (Label::from("a"), Int),
2791 |                 (Label::from("b"), Type::abs(vec![Mono], Type::var(0)))
2792 |             ])),
2793 |             KindError::Record(
2794 |                 Label::from("b"),
2795 |                 Box::new(KindError::NotMono(
2796 |                     Type::abs(vec![Mono], Type::var(0)),
2797 |                     NotMonoError(Kind::fun(Mono, Mono))
2798 |                 ))
2799 |             )
2800 |         );
2801 |         assert_kinding_err!(Type::app(Int, Int), KindError::NotFunction(Mono));
2802 |         assert_kinding_err!(
2803 |             Type::app(Type::abs(vec![Kind::fun(Mono, Mono)], Int), Int),
2804 |             KindError::KindMismatch(Kind::fun(Mono, Mono), Mono)
2805 |         );
2806 |     }
2807 | 
2808 |     #[test]
2809 |     fn unification() {
2810 |         let mut env: Env<Type, ()> = Env::default();
2811 |         assert_eq!(
2812 |             env.unify(vec![(
2813 |                 Type::fun(Type::var(0), Type::var(0)),
2814 |                 Type::fun(Type::Int, Type::var(1))
2815 |             )]),
2816 |             Ok(Subst::from_iter(
2817 |                 vec![(V(0), Type::Int), (V(1), Type::Int),]
2818 |             ))
2819 |         );
2820 |     }
2821 | 
2822 |     #[test]
2823 |     fn type_close() {
2824 |         use Kind::*;
2825 |         use Type::*;
2826 | 
2827 |         let mut env = <Env<Type, ()>>::default();
2828 | 
2829 |         macro_rules! close {
2830 |             ($x:expr) => {
2831 |                 $x.close(&env).0
2832 |             };
2833 |         }
2834 | 
2835 |         assert_eq!(close!(Int), Int);
2836 |         assert_eq!(close!(Type::var(0)), Type::var(0));
2837 | 
2838 |         let v = env.fresh_type_variable(Mono);
2839 | 
2840 |         assert_eq!(close!(Var(v)), Type::forall(vec![Mono], Type::var(0)));
2841 |         assert_eq!(close!(Type::var(0)), Type::var(0));
2842 |         assert_eq!(
2843 |             close!(Type::fun(Var(v), Type::var(0))),
2844 |             Type::forall(vec![Mono], Type::fun(Type::var(0), Type::var(1)))
2845 |         );
2846 | 
2847 |         env.insert_value(Name::from("a"), Type::Var(v));
2848 | 
2849 |         assert_eq!(close!(Var(v)), Var(v));
2850 |         assert_eq!(close!(Type::var(0)), Type::var(0));
2851 |         assert_eq!(
2852 |             close!(Type::fun(Var(v), Type::var(0))),
2853 |             Type::fun(Var(v), Type::var(0))
2854 |         );
2855 |     }
2856 | 
2857 |     #[test]
2858 |     fn kind_fun_env() {
2859 |         use Kind::*;
2860 | 
2861 |         let fun = Kind::fun;
2862 | 
2863 |         assert_eq!(Kind::fun_env::<Type, ()>(&Env::default(), Mono), Mono);
2864 | 
2865 |         assert_eq!(
2866 |             Kind::fun_env::<Type, _>(
2867 |                 &Env {
2868 |                     tenv: vec![(Mono, ())],
2869 |                     ..Default::default()
2870 |                 },
2871 |                 Mono
2872 |             ),
2873 |             fun(Mono, Mono)
2874 |         );
2875 | 
2876 |         assert_eq!(
2877 |             Kind::fun_env::<Type, _>(
2878 |                 &Env {
2879 |                     tenv: vec![(fun(Mono, Mono), ()), (Mono, ())],
2880 |                     ..Default::default()
2881 |                 },
2882 |                 Mono
2883 |             ),
2884 |             fun(fun(Mono, Mono), fun(Mono, Mono))
2885 |         );
2886 | 
2887 |         assert_eq!(
2888 |             Kind::fun_env::<Type, _>(
2889 |                 &Env {
2890 |                     tenv: vec![
2891 |                         (fun(Mono, Mono), ()),
2892 |                         (fun(Mono, fun(Mono, Mono)), ()),
2893 |                         (Mono, ())
2894 |                     ],
2895 |                     ..Default::default()
2896 |                 },
2897 |                 fun(Mono, Mono)
2898 |             ),
2899 |             fun(
2900 |                 fun(Mono, Mono),
2901 |                 fun(fun(Mono, fun(Mono, Mono)), fun(Mono, fun(Mono, Mono)))
2902 |             )
2903 |         );
2904 |     }
2905 | 
2906 |     #[test]
2907 |     fn type_abs_app_env() {
2908 |         use Kind::*;
2909 |         use Type::*;
2910 | 
2911 |         let fun = Kind::fun;
2912 |         let abs = Type::abs;
2913 |         let app = Type::app;
2914 |         let var = Type::var;
2915 | 
2916 |         assert_eq!(Type::abs_env::<Type, ()>(&Env::default(), Int), Int);
2917 | 
2918 |         assert_eq!(
2919 |             Type::abs_env::<Type, _>(
2920 |                 &Env {
2921 |                     tenv: vec![(Mono, ())],
2922 |                     ..Default::default()
2923 |                 },
2924 |                 Int
2925 |             ),
2926 |             abs(vec![Mono], Int)
2927 |         );
2928 | 
2929 |         // Capture can occur.
2930 |         assert_eq!(
2931 |             Type::abs_env::<Type, _>(
2932 |                 &Env {
2933 |                     tenv: vec![(fun(Mono, Mono), ()), (Mono, ())],
2934 |                     ..Default::default()
2935 |                 },
2936 |                 var(0)
2937 |             ),
2938 |             abs(vec![Mono, fun(Mono, Mono)], var(0))
2939 |         );
2940 | 
2941 |         assert_eq!(
2942 |             Type::abs_env::<Type, _>(
2943 |                 &Env {
2944 |                     tenv: vec![
2945 |                         (fun(Mono, Mono), ()),
2946 |                         (fun(Mono, fun(Mono, Mono)), ()),
2947 |                         (Mono, ())
2948 |                     ],
2949 |                     ..Default::default()
2950 |                 },
2951 |                 var(0)
2952 |             ),
2953 |             abs(
2954 |                 vec![Mono, fun(Mono, fun(Mono, Mono)), fun(Mono, Mono)],
2955 |                 var(0)
2956 |             )
2957 |         );
2958 | 
2959 |         assert_eq!(Type::app_env::<Type, ()>(Int, &Env::default()), Int);
2960 | 
2961 |         assert_eq!(
2962 |             Type::app_env::<Type, ()>(
2963 |                 Int,
2964 |                 &Env {
2965 |                     tenv: vec![(Mono, ())],
2966 |                     ..Default::default()
2967 |                 },
2968 |             ),
2969 |             app(Int, var(0))
2970 |         );
2971 | 
2972 |         assert_eq!(
2973 |             Type::app_env::<Type, ()>(
2974 |                 Int,
2975 |                 &Env {
2976 |                     tenv: vec![(Mono, ()), (Mono, ())],
2977 |                     ..Default::default()
2978 |                 },
2979 |             ),
2980 |             app(app(Int, var(1)), var(0))
2981 |         );
2982 |     }
2983 | }
2984 | 


--------------------------------------------------------------------------------
/src/rrd2014/internal/dynamic.rs:
--------------------------------------------------------------------------------
  1 | use failure::*;
  2 | 
  3 | use super::*;
  4 | 
  5 | /// `body` is the body of the function of a closure.
  6 | /// Variables indexed by 0 is an argument to the closure.
  7 | /// The other variables are captured by `env`.
  8 | #[derive(Clone, Debug, PartialEq)]
  9 | pub struct Closure {
 10 |     body: Term,
 11 |     env: DynEnv,
 12 | }
 13 | 
 14 | /// This sort of a closure represents a polymorphic function.
 15 | /// `body` is the body of the function of a closure.
 16 | /// All variables are captured by `env`.
 17 | #[derive(Clone, Debug, PartialEq)]
 18 | pub struct TypeClosure {
 19 |     body: Term,
 20 |     env: DynEnv,
 21 | }
 22 | 
 23 | #[derive(Clone, Debug, PartialEq)]
 24 | pub enum Value {
 25 |     Int(isize),
 26 |     Bool(bool),
 27 |     Closure(Closure),
 28 |     TypeClosure(TypeClosure),
 29 |     Record(Record<Value>),
 30 |     Pack(Box<Value>),
 31 | }
 32 | 
 33 | /// A dynamic environment.
 34 | #[derive(Clone, Debug, Default, PartialEq)]
 35 | struct DynEnv {
 36 |     vs: Vec<Value>,
 37 | }
 38 | 
 39 | pub fn reduce(t: Term) -> Fallible<Value> {
 40 |     let mut env = DynEnv::default();
 41 |     env.reduce(t)
 42 | }
 43 | 
 44 | impl Value {
 45 |     fn pack(v: Value) -> Self {
 46 |         Value::Pack(Box::new(v))
 47 |     }
 48 | 
 49 |     fn get_int(self) -> Fallible<isize> {
 50 |         if let Value::Int(n) = self {
 51 |             Ok(n)
 52 |         } else {
 53 |             bail!("not integer: {:?}", self)
 54 |         }
 55 |     }
 56 | }
 57 | 
 58 | impl DynEnv {
 59 |     fn insert(&mut self, v: Value) {
 60 |         self.vs.push(v);
 61 |     }
 62 | 
 63 |     fn get(&self, v: Variable) -> Option<&Value> {
 64 |         self.vs.iter().rev().nth(v.get_index())
 65 |     }
 66 | 
 67 |     fn drop(&mut self) {
 68 |         self.vs.pop();
 69 |     }
 70 | 
 71 |     fn reduce(&mut self, t: Term) -> Fallible<Value> {
 72 |         use Term::*;
 73 |         match t {
 74 |             Var(v) => self
 75 |                 .get(v)
 76 |                 .cloned()
 77 |                 .ok_or_else(|| format_err!("unbound variable: {:?}", v)),
 78 |             Abs(_, t) => Ok(Value::Closure(Closure {
 79 |                 body: *t,
 80 |                 env: self.clone(),
 81 |             })),
 82 |             App(t1, t2) => {
 83 |                 let v1 = self.reduce(*t1)?;
 84 |                 let v2 = self.reduce(*t2)?;
 85 |                 match v1 {
 86 |                     Value::Closure(cls) => {
 87 |                         let mut env = cls.env;
 88 |                         env.insert(v2);
 89 |                         env.reduce(cls.body)
 90 |                     }
 91 |                     _ => bail!("not closure: {:?}", v1),
 92 |                 }
 93 |             }
 94 |             Record(r) => Ok(Value::Record(
 95 |                 r.0.into_iter()
 96 |                     .map(|(l, t)| Ok((l, self.reduce(t)?)))
 97 |                     .collect::<Fallible<_>>()?,
 98 |             )),
 99 |             Proj(t, l) => match self.reduce(*t)? {
100 |                 Value::Record(r) => r
101 |                     .get(&l)
102 |                     .cloned()
103 |                     .ok_or_else(|| format_err!("unknown label: {:?}", l)),
104 |                 v => bail!("not record: {:?}", v),
105 |             },
106 |             Poly(_, t) => Ok(Value::TypeClosure(TypeClosure {
107 |                 body: *t,
108 |                 env: self.clone(),
109 |             })),
110 |             Inst(t, _) => match self.reduce(*t)? {
111 |                 Value::TypeClosure(cls) => {
112 |                     let mut env = cls.env;
113 |                     env.reduce(cls.body)
114 |                 }
115 |                 v => bail!("not type closure: {:?}", v),
116 |             },
117 |             Pack(_, t, _) => Ok(Value::pack(self.reduce(*t)?)),
118 |             Unpack(t1, t2) => match self.reduce(*t1)? {
119 |                 Value::Pack(v) => {
120 |                     self.insert(*v);
121 |                     let v = self.reduce(*t2)?;
122 |                     self.drop();
123 |                     Ok(v)
124 |                 }
125 |                 v => bail!("not package: {:?}", v),
126 |             },
127 |             Int(n) => Ok(Value::Int(n)),
128 |             Bool(b) => Ok(Value::Bool(b)),
129 |             If(t1, t2, t3) => match self.reduce(*t1)? {
130 |                 Value::Bool(true) => self.reduce(*t2),
131 |                 Value::Bool(false) => self.reduce(*t3),
132 |                 v => bail!("not boolean: {:?}", v),
133 |             },
134 |             BinOp(op, t1, t2) => {
135 |                 use super::BinOp::*;
136 |                 let n1 = self.reduce(*t1)?.get_int()?;
137 |                 let n2 = self.reduce(*t2)?.get_int()?;
138 |                 let b = match op {
139 |                     LessThan => n1 < n2,
140 |                     GreaterThan => n1 > n2,
141 |                 };
142 |                 Ok(Value::Bool(b))
143 |             }
144 |             Let(t1, t2) => {
145 |                 let v = self.reduce(*t1)?;
146 |                 self.insert(v);
147 |                 let v = self.reduce(*t2)?;
148 |                 self.drop();
149 |                 Ok(v)
150 |             }
151 |         }
152 |     }
153 | }
154 | 


--------------------------------------------------------------------------------
/src/rrd2014/parser.rs:
--------------------------------------------------------------------------------
   1 | use std::io::Read;
   2 | use std::iter::FromIterator;
   3 | use std::iter::Peekable;
   4 | use std::vec::IntoIter;
   5 | 
   6 | use failure::Fail;
   7 | use failure::Fallible;
   8 | 
   9 | use super::*;
  10 | 
  11 | mod position {
  12 |     use std::fmt;
  13 | 
  14 |     #[derive(Clone, Debug, PartialEq)]
  15 |     pub struct Position {
  16 |         line: usize,
  17 |         column: usize,
  18 |     }
  19 | 
  20 |     impl Default for Position {
  21 |         fn default() -> Self {
  22 |             Position { line: 1, column: 1 }
  23 |         }
  24 |     }
  25 | 
  26 |     impl fmt::Display for Position {
  27 |         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  28 |             write!(f, "{}:{}", self.line, self.column)
  29 |         }
  30 |     }
  31 | 
  32 |     impl Position {
  33 |         pub fn new(line: usize, column: usize) -> Self {
  34 |             Position { line, column }
  35 |         }
  36 | 
  37 |         pub fn new_line(&mut self) {
  38 |             self.line += 1;
  39 |             self.column = 1;
  40 |         }
  41 | 
  42 |         pub fn inc_column(&mut self) {
  43 |             self.column += 1;
  44 |         }
  45 |     }
  46 | }
  47 | 
  48 | use position::Position;
  49 | 
  50 | #[derive(Clone, Debug, PartialEq)]
  51 | enum TokenKind {
  52 |     Mono,
  53 |     Int,
  54 |     Bool,
  55 |     Arrow,
  56 |     Lambda,
  57 |     Dot,
  58 |     Fun,
  59 |     Colon,
  60 |     Equal,
  61 |     DoubleArrow,
  62 |     OpaqueSealing,
  63 | 
  64 |     Val,
  65 |     Type,
  66 |     Module,
  67 |     Signature,
  68 |     Include,
  69 | 
  70 |     Where,
  71 | 
  72 |     LParen,
  73 |     RParen,
  74 | 
  75 |     Struct,
  76 |     Sig,
  77 |     End,
  78 | 
  79 |     Pack,
  80 |     Unpack,
  81 | 
  82 |     Ident(String),
  83 |     IntLit(isize),
  84 |     True,
  85 |     False,
  86 |     If,
  87 |     Then,
  88 |     Else,
  89 |     LessThan,
  90 |     GreaterThan,
  91 | }
  92 | 
  93 | #[derive(Clone, Debug, PartialEq)]
  94 | struct Token {
  95 |     kind: TokenKind,
  96 |     pos: Position,
  97 | }
  98 | 
  99 | struct Lexer {
 100 |     pos: Position,
 101 |     src: Peekable<IntoIter<char>>,
 102 |     filename: Option<String>,
 103 | }
 104 | 
 105 | struct Parser {
 106 |     src: Peekable<IntoIter<Token>>,
 107 |     filename: Option<String>,
 108 | }
 109 | 
 110 | struct State(Peekable<IntoIter<Token>>);
 111 | 
 112 | #[derive(Debug, Fail, PartialEq)]
 113 | enum LexError {
 114 |     #[fail(display = "no token")]
 115 |     NoToken,
 116 | 
 117 |     #[fail(display = "{}: unexpected end of file", _0)]
 118 |     UnexpectedEOF(Position),
 119 | 
 120 |     #[fail(display = "{}: illegal character: {:?}", _0, _1)]
 121 |     IllegalCharacter(Position, char),
 122 | 
 123 |     #[fail(display = "{}: expected {}, but found {:?}", _0, _1, _2)]
 124 |     Expected(Position, String, char),
 125 | }
 126 | 
 127 | #[derive(Debug, Fail, PartialEq)]
 128 | enum ParseError {
 129 |     #[fail(display = "unexpected end of file")]
 130 |     UnexpectedEOF,
 131 | 
 132 |     #[fail(display = "{}: expected {}, but found {:?}", _0, _1, _2)]
 133 |     Expected(Position, String, TokenKind),
 134 | 
 135 |     #[fail(display = "{}: expected {:?}, but found {:?}", _0, _1, _2)]
 136 |     ExpectedToken(Position, TokenKind, TokenKind),
 137 | }
 138 | 
 139 | type Res<T> = Result<T, LexError>;
 140 | 
 141 | type ParseRes<T> = Result<T, ParseError>;
 142 | 
 143 | impl TokenKind {
 144 |     fn ident(s: &str) -> Self {
 145 |         TokenKind::Ident(s.to_string())
 146 |     }
 147 | }
 148 | 
 149 | impl Lexer {
 150 |     fn new(src: Vec<char>) -> Self {
 151 |         Lexer {
 152 |             pos: Position::default(),
 153 |             src: src.into_iter().peekable(),
 154 |             filename: None,
 155 |         }
 156 |     }
 157 | 
 158 |     fn with_filename(src: Vec<char>, filename: String) -> Self {
 159 |         Lexer {
 160 |             pos: Position::default(),
 161 |             src: src.into_iter().peekable(),
 162 |             filename: Some(filename),
 163 |         }
 164 |     }
 165 | 
 166 |     fn proceed(&mut self) {
 167 |         if let Some(ch) = self.src.next() {
 168 |             if ch == '\n' {
 169 |                 self.pos.new_line();
 170 |             } else {
 171 |                 self.pos.inc_column();
 172 |             }
 173 |         }
 174 |     }
 175 | 
 176 |     fn next(&mut self) -> Res<char> {
 177 |         self.next_opt()
 178 |             .ok_or_else(|| LexError::UnexpectedEOF(self.pos.clone()))
 179 |     }
 180 | 
 181 |     fn next_opt(&mut self) -> Option<char> {
 182 |         if let Some(ch) = self.src.next() {
 183 |             if ch == '\n' {
 184 |                 self.pos.new_line();
 185 |             } else {
 186 |                 self.pos.inc_column();
 187 |             }
 188 |             Some(ch)
 189 |         } else {
 190 |             None
 191 |         }
 192 |     }
 193 | 
 194 |     fn peek(&mut self) -> Res<char> {
 195 |         self.src.peek().cloned().ok_or(LexError::NoToken)
 196 |     }
 197 | 
 198 |     fn pos(&self) -> Position {
 199 |         self.pos.clone()
 200 |     }
 201 | 
 202 |     fn token(&self, kind: TokenKind) -> Token {
 203 |         Token {
 204 |             kind,
 205 |             pos: self.pos(),
 206 |         }
 207 |     }
 208 | 
 209 |     fn lex(&mut self) -> Res<Token> {
 210 |         macro_rules! proceeding {
 211 |             ($token:expr) => {{
 212 |                 let token = $token;
 213 |                 self.proceed();
 214 |                 Ok(token)
 215 |             }};
 216 |         };
 217 | 
 218 |         let pos = self.pos();
 219 |         match self.peek()? {
 220 |             ' ' | '\n' | '\t' => {
 221 |                 self.proceed();
 222 |                 self.lex()
 223 |             }
 224 |             '*' => proceeding!(self.token(TokenKind::Mono)),
 225 |             '.' => proceeding!(self.token(TokenKind::Dot)),
 226 |             '(' => proceeding!(self.token(TokenKind::LParen)),
 227 |             ')' => proceeding!(self.token(TokenKind::RParen)),
 228 |             '<' => proceeding!(self.token(TokenKind::LessThan)),
 229 |             '>' => proceeding!(self.token(TokenKind::GreaterThan)),
 230 |             ':' => {
 231 |                 self.proceed();
 232 |                 self.colon(pos)
 233 |             }
 234 |             '=' => {
 235 |                 self.proceed();
 236 |                 self.double_arrow(pos)
 237 |             }
 238 |             '-' => {
 239 |                 self.proceed();
 240 |                 self.arrow(pos)
 241 |             }
 242 |             '\u{03bb}' => proceeding!(self.token(TokenKind::Lambda)),
 243 |             ch if ch.is_ascii_digit() => self.int(),
 244 |             ch if ch.is_ascii_alphabetic() => self.ident(),
 245 |             ch => Err(LexError::IllegalCharacter(self.pos.clone(), ch)),
 246 |         }
 247 |     }
 248 | 
 249 |     fn arrow(&mut self, pos: Position) -> Res<Token> {
 250 |         match self.next_opt() {
 251 |             Some('>') => Ok(Token {
 252 |                 kind: TokenKind::Arrow,
 253 |                 pos,
 254 |             }),
 255 |             Some(ch) => Err(LexError::Expected(self.pos.clone(), '>'.to_string(), ch)),
 256 |             None => Err(LexError::UnexpectedEOF(self.pos.clone())),
 257 |         }
 258 |     }
 259 | 
 260 |     fn double_arrow(&mut self, pos: Position) -> Res<Token> {
 261 |         macro_rules! proceeding {
 262 |             ($token:expr) => {{
 263 |                 let token = $token;
 264 |                 self.proceed();
 265 |                 Ok(token)
 266 |             }};
 267 |         };
 268 | 
 269 |         match self.peek() {
 270 |             Ok('>') => proceeding!(Token {
 271 |                 kind: TokenKind::DoubleArrow,
 272 |                 pos,
 273 |             }),
 274 |             _ => Ok(Token {
 275 |                 kind: TokenKind::Equal,
 276 |                 pos,
 277 |             }),
 278 |         }
 279 |     }
 280 | 
 281 |     fn colon(&mut self, pos: Position) -> Res<Token> {
 282 |         macro_rules! proceeding {
 283 |             ($token:expr) => {{
 284 |                 let token = $token;
 285 |                 self.proceed();
 286 |                 Ok(token)
 287 |             }};
 288 |         };
 289 | 
 290 |         match self.peek() {
 291 |             Ok('>') => proceeding!(Token {
 292 |                 kind: TokenKind::OpaqueSealing,
 293 |                 pos,
 294 |             }),
 295 |             _ => Ok(Token {
 296 |                 kind: TokenKind::Colon,
 297 |                 pos,
 298 |             }),
 299 |         }
 300 |     }
 301 | 
 302 |     fn ident(&mut self) -> Res<Token> {
 303 |         let pos = self.pos();
 304 |         let mut v = Vec::new();
 305 |         while let Ok(ch) = self.peek() {
 306 |             if ch.is_ascii_alphanumeric() || ch == '_' {
 307 |                 v.push(ch);
 308 |                 self.proceed();
 309 |             } else {
 310 |                 break;
 311 |             }
 312 |         }
 313 |         let kind = keyword_or_ident(String::from_iter(v));
 314 |         Ok(Token { kind, pos })
 315 |     }
 316 | 
 317 |     fn int(&mut self) -> Res<Token> {
 318 |         let pos = self.pos();
 319 |         let mut n = 0;
 320 |         while let Ok(ch) = self.peek() {
 321 |             if ch.is_ascii_digit() {
 322 |                 n = n * 10 + ch.to_digit(10).unwrap() as isize;
 323 |             } else if ch != '_' {
 324 |                 break;
 325 |             }
 326 |             self.proceed();
 327 |         }
 328 |         Ok(Token {
 329 |             kind: TokenKind::IntLit(n),
 330 |             pos,
 331 |         })
 332 |     }
 333 | 
 334 |     fn lex_all(&mut self) -> Res<Vec<Token>> {
 335 |         let mut v = Vec::new();
 336 |         loop {
 337 |             match self.lex() {
 338 |                 Ok(token) => v.push(token),
 339 |                 Err(LexError::NoToken) => return Ok(v),
 340 |                 Err(e) => return Err(e),
 341 |             }
 342 |         }
 343 |     }
 344 | }
 345 | 
 346 | fn keyword_or_ident(s: String) -> TokenKind {
 347 |     match s.as_str() {
 348 |         "int" => TokenKind::Int,
 349 |         "bool" => TokenKind::Bool,
 350 |         "true" => TokenKind::True,
 351 |         "false" => TokenKind::False,
 352 |         "if" => TokenKind::If,
 353 |         "then" => TokenKind::Then,
 354 |         "else" => TokenKind::Else,
 355 |         "fun" => TokenKind::Fun,
 356 |         "val" => TokenKind::Val,
 357 |         "type" => TokenKind::Type,
 358 |         "module" => TokenKind::Module,
 359 |         "signature" => TokenKind::Signature,
 360 |         "include" => TokenKind::Include,
 361 |         "where" => TokenKind::Where,
 362 |         "struct" => TokenKind::Struct,
 363 |         "sig" => TokenKind::Sig,
 364 |         "end" => TokenKind::End,
 365 |         "pack" => TokenKind::Pack,
 366 |         "unpack" => TokenKind::Unpack,
 367 |         _ => TokenKind::Ident(s),
 368 |     }
 369 | }
 370 | 
 371 | impl ParseError {
 372 |     fn expected(s: &str, token: Token) -> Self {
 373 |         ParseError::Expected(token.pos, s.to_string(), token.kind)
 374 |     }
 375 | 
 376 |     fn expected_token(kind: TokenKind, token: Token) -> Self {
 377 |         ParseError::ExpectedToken(token.pos, kind, token.kind)
 378 |     }
 379 | }
 380 | 
 381 | impl Parser {
 382 |     fn new(src: Vec<Token>) -> Self {
 383 |         Parser {
 384 |             src: src.into_iter().peekable(),
 385 |             filename: None,
 386 |         }
 387 |     }
 388 | 
 389 |     fn with_filename(src: Vec<Token>, filename: String) -> Self {
 390 |         Parser {
 391 |             src: src.into_iter().peekable(),
 392 |             filename: Some(filename),
 393 |         }
 394 |     }
 395 | 
 396 |     fn save(&self) -> State {
 397 |         State(self.src.clone())
 398 |     }
 399 | 
 400 |     fn restore(&mut self, s: State) {
 401 |         self.src = s.0
 402 |     }
 403 | 
 404 |     fn next(&mut self) -> ParseRes<Token> {
 405 |         self.next_opt().ok_or(ParseError::UnexpectedEOF)
 406 |     }
 407 | 
 408 |     fn next_opt(&mut self) -> Option<Token> {
 409 |         self.src.next()
 410 |     }
 411 | 
 412 |     fn proceed(&mut self) {
 413 |         self.src.next();
 414 |     }
 415 | 
 416 |     fn peek(&mut self) -> ParseRes<Token> {
 417 |         self.src.peek().cloned().ok_or(ParseError::UnexpectedEOF)
 418 |     }
 419 | 
 420 |     fn expect_eof(&mut self) -> ParseRes<()> {
 421 |         if let Some(token) = self.src.peek() {
 422 |             Err(ParseError::expected("eof", token.clone()))?;
 423 |         }
 424 |         Ok(())
 425 |     }
 426 | 
 427 |     fn kind(&mut self) -> ParseRes<Kind> {
 428 |         let token = self.next()?;
 429 |         match token.kind {
 430 |             TokenKind::Mono => Ok(Kind::Mono),
 431 |             _ => Err(ParseError::expected("kind", token)),
 432 |         }
 433 |     }
 434 | 
 435 |     fn type_atom(&mut self) -> ParseRes<Type> {
 436 |         let token = self.peek()?;
 437 |         match token.kind {
 438 |             TokenKind::Int => {
 439 |                 self.proceed();
 440 |                 Ok(Type::Int)
 441 |             }
 442 |             TokenKind::Bool => {
 443 |                 self.proceed();
 444 |                 Ok(Type::Bool)
 445 |             }
 446 |             TokenKind::Ident(_) => {
 447 |                 let m = self.module()?;
 448 |                 Ok(Type::path(m))
 449 |             }
 450 |             TokenKind::LParen => {
 451 |                 let state = self.save();
 452 |                 if let Ok(m) = self.module() {
 453 |                     return Ok(Type::path(m));
 454 |                 } else {
 455 |                     self.restore(state);
 456 |                 }
 457 |                 self.proceed();
 458 |                 let ty = self.r#type()?;
 459 |                 self.expect(TokenKind::RParen)?;
 460 |                 Ok(ty)
 461 |             }
 462 |             TokenKind::Pack => {
 463 |                 self.proceed();
 464 |                 let sig = self.signature_atom()?;
 465 |                 Ok(Type::pack(sig))
 466 |             }
 467 |             _ => Err(ParseError::expected("type", token)),
 468 |         }
 469 |     }
 470 | 
 471 |     fn r#type(&mut self) -> ParseRes<Type> {
 472 |         let ty = self.type_atom()?;
 473 |         match self.peek().map(|t| t.kind) {
 474 |             Ok(TokenKind::Arrow) => {
 475 |                 self.proceed();
 476 |                 Ok(Type::fun(ty, self.r#type()?))
 477 |             }
 478 |             _ => Ok(ty),
 479 |         }
 480 |     }
 481 | 
 482 |     fn expr_atom(&mut self) -> ParseRes<Expr> {
 483 |         let token = self.peek()?;
 484 |         match token.kind {
 485 |             TokenKind::IntLit(n) => {
 486 |                 self.proceed();
 487 |                 Ok(Expr::Int(n))
 488 |             }
 489 |             TokenKind::False => {
 490 |                 self.proceed();
 491 |                 Ok(Expr::Bool(false))
 492 |             }
 493 |             TokenKind::True => {
 494 |                 self.proceed();
 495 |                 Ok(Expr::Bool(true))
 496 |             }
 497 |             TokenKind::Ident(s) => {
 498 |                 self.proceed();
 499 |                 let mut m0 = Module::Ident(Ident::from(s));
 500 |                 while self.peek_expect(TokenKind::Dot) {
 501 |                     self.proceed();
 502 |                     let id = self.ident()?;
 503 |                     m0 = Module::proj(m0, id);
 504 |                 }
 505 |                 Ok(Expr::path(m0))
 506 |             }
 507 |             TokenKind::LParen => {
 508 |                 let state = self.save();
 509 |                 if let Ok(e) = self.expr_atom_aux() {
 510 |                     return Ok(e);
 511 |                 } else {
 512 |                     self.restore(state);
 513 |                 }
 514 |                 Ok(Expr::path(self.module()?))
 515 |             }
 516 |             _ => Err(ParseError::expected("expression", token)),
 517 |         }
 518 |     }
 519 | 
 520 |     fn expr_atom_aux(&mut self) -> ParseRes<Expr> {
 521 |         self.proceed();
 522 |         let e = self.expr()?;
 523 |         self.expect(TokenKind::RParen)?;
 524 |         Ok(e)
 525 |     }
 526 | 
 527 |     fn expect(&mut self, kind: TokenKind) -> ParseRes<Token> {
 528 |         match self.next()? {
 529 |             token if token.kind == kind => Ok(token),
 530 |             token => Err(ParseError::expected_token(kind, token)),
 531 |         }
 532 |     }
 533 | 
 534 |     fn peek_expect(&mut self, kind: TokenKind) -> bool {
 535 |         if let Ok(token) = self.peek() {
 536 |             token.kind == kind
 537 |         } else {
 538 |             false
 539 |         }
 540 |     }
 541 | 
 542 |     fn abs(&mut self) -> ParseRes<Expr> {
 543 |         let token = self.next()?;
 544 |         match token.kind {
 545 |             TokenKind::Ident(s) => {
 546 |                 let id = Ident::from(s);
 547 |                 self.expect(TokenKind::Dot)?;
 548 |                 let e = self.expr()?;
 549 |                 Ok(Expr::abs(id, e))
 550 |             }
 551 |             _ => Err(ParseError::expected("identifier", token)),
 552 |         }
 553 |     }
 554 | 
 555 |     fn expr_term(&mut self) -> ParseRes<Expr> {
 556 |         let mut e0 = self.expr_atom()?;
 557 |         let mut state = self.save();
 558 |         while let Ok(e) = self.expr_atom() {
 559 |             e0 = Expr::app(e0, e);
 560 |             state = self.save();
 561 |         }
 562 |         self.restore(state);
 563 |         Ok(e0)
 564 |     }
 565 | 
 566 |     fn peek_operator(&mut self) -> ParseRes<BinOp> {
 567 |         use super::BinOp::*;
 568 |         let token = self.peek()?;
 569 |         match token.kind {
 570 |             TokenKind::LessThan => Ok(LessThan),
 571 |             TokenKind::GreaterThan => Ok(GreaterThan),
 572 |             _ => Err(ParseError::expected("binary operator", token)),
 573 |         }
 574 |     }
 575 | 
 576 |     fn expr(&mut self) -> ParseRes<Expr> {
 577 |         match self.peek()?.kind {
 578 |             TokenKind::Lambda => {
 579 |                 self.proceed();
 580 |                 self.abs()
 581 |             }
 582 |             TokenKind::Pack => {
 583 |                 self.proceed();
 584 |                 let m = self.module()?;
 585 |                 self.expect(TokenKind::Colon)?;
 586 |                 let sig = self.signature()?;
 587 |                 Ok(Expr::pack(m, sig))
 588 |             }
 589 |             TokenKind::If => {
 590 |                 self.proceed();
 591 |                 let e1 = self.expr()?;
 592 |                 self.expect(TokenKind::Then)?;
 593 |                 let e2 = self.expr()?;
 594 |                 self.expect(TokenKind::Else)?;
 595 |                 let e3 = self.expr()?;
 596 |                 Ok(Expr::r#if(e1, e2, e3))
 597 |             }
 598 |             _ => {
 599 |                 let mut e0 = self.expr_term()?;
 600 |                 while let Ok(op) = self.peek_operator() {
 601 |                     self.proceed();
 602 |                     let e = self.expr_atom()?;
 603 |                     e0 = Expr::bin_op(op, e0, e); // Assumes left-associativity.
 604 |                 }
 605 |                 Ok(e0)
 606 |             }
 607 |         }
 608 |     }
 609 | 
 610 |     fn decl(&mut self) -> ParseRes<Decl> {
 611 |         let token = self.peek()?;
 612 |         match token.kind {
 613 |             TokenKind::Val => {
 614 |                 self.proceed();
 615 |                 self.val_decl()
 616 |             }
 617 |             TokenKind::Type => {
 618 |                 self.proceed();
 619 |                 self.type_decl()
 620 |             }
 621 |             TokenKind::Module => {
 622 |                 self.proceed();
 623 |                 self.module_decl()
 624 |             }
 625 |             TokenKind::Signature => {
 626 |                 self.proceed();
 627 |                 self.signature_decl()
 628 |             }
 629 |             TokenKind::Include => {
 630 |                 self.proceed();
 631 |                 self.include_decl()
 632 |             }
 633 |             _ => Err(ParseError::expected("declaration", token)),
 634 |         }
 635 |     }
 636 | 
 637 |     fn ident(&mut self) -> ParseRes<Ident> {
 638 |         let token = self.next()?;
 639 |         match token.kind {
 640 |             TokenKind::Ident(s) => Ok(Ident::from(s)),
 641 |             _ => Err(ParseError::expected("identifier", token)),
 642 |         }
 643 |     }
 644 | 
 645 |     fn peek_ident(&mut self) -> ParseRes<Ident> {
 646 |         let token = self.peek()?;
 647 |         match token.kind {
 648 |             TokenKind::Ident(s) => Ok(Ident::from(s)),
 649 |             _ => Err(ParseError::expected("identifier", token)),
 650 |         }
 651 |     }
 652 | 
 653 |     fn val_decl(&mut self) -> ParseRes<Decl> {
 654 |         let id = self.ident()?;
 655 |         self.expect(TokenKind::Colon)?;
 656 |         let ty = self.r#type()?;
 657 |         Ok(Decl::Val(id, ty))
 658 |     }
 659 | 
 660 |     fn type_decl(&mut self) -> ParseRes<Decl> {
 661 |         let id = self.ident()?;
 662 |         let token = self.next()?;
 663 |         match token.kind {
 664 |             TokenKind::Colon => {
 665 |                 let k = self.kind()?;
 666 |                 Ok(Decl::AbsType(id, k))
 667 |             }
 668 |             TokenKind::Equal => {
 669 |                 let ty = self.r#type()?;
 670 |                 Ok(Decl::ManType(id, ty))
 671 |             }
 672 |             _ => Err(ParseError::expected("':' or '='", token)),
 673 |         }
 674 |     }
 675 | 
 676 |     fn module_decl(&mut self) -> ParseRes<Decl> {
 677 |         let id = self.ident()?;
 678 |         self.expect(TokenKind::Colon)?;
 679 |         let sig = self.signature()?;
 680 |         Ok(Decl::Module(id, sig))
 681 |     }
 682 | 
 683 |     fn signature_decl(&mut self) -> ParseRes<Decl> {
 684 |         let id = self.ident()?;
 685 |         self.expect(TokenKind::Equal)?;
 686 |         let sig = self.signature()?;
 687 |         Ok(Decl::Signature(id, sig))
 688 |     }
 689 | 
 690 |     fn include_decl(&mut self) -> ParseRes<Decl> {
 691 |         let sig = self.signature()?;
 692 |         Ok(Decl::Include(sig))
 693 |     }
 694 | 
 695 |     fn signature_atom(&mut self) -> ParseRes<Sig> {
 696 |         let token = self.peek()?;
 697 |         match token.kind {
 698 |             TokenKind::Sig => {
 699 |                 self.proceed();
 700 |                 let mut v = Vec::new();
 701 |                 let mut state = self.save();
 702 |                 loop {
 703 |                     match self.decl() {
 704 |                         Ok(decl) => {
 705 |                             v.push(decl);
 706 |                             state = self.save();
 707 |                         }
 708 |                         Err(e) => {
 709 |                             self.restore(state);
 710 |                             self.expect(TokenKind::End).map_err(|_| e)?;
 711 |                             break;
 712 |                         }
 713 |                     }
 714 |                 }
 715 |                 Ok(Sig::Seq(v))
 716 |             }
 717 |             TokenKind::Ident(_) => {
 718 |                 let m = self.module()?;
 719 |                 Ok(Sig::path(m))
 720 |             }
 721 |             TokenKind::LParen => {
 722 |                 let state = self.save();
 723 |                 if let Ok(m) = self.module() {
 724 |                     return Ok(Sig::path(m));
 725 |                 } else {
 726 |                     self.restore(state);
 727 |                 }
 728 |                 self.proceed();
 729 |                 let id = self.ident()?;
 730 |                 self.expect(TokenKind::Colon)?;
 731 |                 let sig1 = self.signature()?;
 732 |                 self.expect(TokenKind::RParen)?;
 733 |                 self.expect(TokenKind::Arrow)?;
 734 |                 let sig2 = self.signature()?;
 735 |                 Ok(Sig::generative(id, sig1, sig2))
 736 |             }
 737 |             _ => Err(ParseError::expected(
 738 |                 "signature ('sig', identifier, etc.)",
 739 |                 token,
 740 |             )),
 741 |         }
 742 |     }
 743 | 
 744 |     fn signature(&mut self) -> ParseRes<Sig> {
 745 |         let sig = self.signature_atom()?;
 746 |         if self.peek_expect(TokenKind::Where) {
 747 |             self.proceed();
 748 |             self.expect(TokenKind::Type)?;
 749 |             let root = self.ident()?;
 750 |             let mut v = Vec::new();
 751 |             while self.peek_expect(TokenKind::Dot) {
 752 |                 self.proceed();
 753 |                 v.push(self.ident()?);
 754 |             }
 755 |             self.expect(TokenKind::Equal)?;
 756 |             let ty = self.r#type()?;
 757 |             Ok(Sig::r#where(sig, Proj(root, v), ty))
 758 |         } else {
 759 |             Ok(sig)
 760 |         }
 761 |     }
 762 | 
 763 |     fn binding(&mut self) -> ParseRes<Binding> {
 764 |         let token = self.peek()?;
 765 |         match token.kind {
 766 |             TokenKind::Val => {
 767 |                 self.proceed();
 768 |                 self.val_binding()
 769 |             }
 770 |             TokenKind::Type => {
 771 |                 self.proceed();
 772 |                 self.type_binding()
 773 |             }
 774 |             TokenKind::Module => {
 775 |                 self.proceed();
 776 |                 self.module_binding()
 777 |             }
 778 |             TokenKind::Signature => {
 779 |                 self.proceed();
 780 |                 self.signature_binding()
 781 |             }
 782 |             TokenKind::Include => {
 783 |                 self.proceed();
 784 |                 self.include_binding()
 785 |             }
 786 |             _ => Err(ParseError::expected("binding", token)),
 787 |         }
 788 |     }
 789 | 
 790 |     fn val_binding(&mut self) -> ParseRes<Binding> {
 791 |         let id = self.ident()?;
 792 |         self.expect(TokenKind::Equal)?;
 793 |         let e = self.expr()?;
 794 |         Ok(Binding::Val(id, e))
 795 |     }
 796 | 
 797 |     fn type_binding(&mut self) -> ParseRes<Binding> {
 798 |         let id = self.ident()?;
 799 |         self.expect(TokenKind::Equal)?;
 800 |         let ty = self.r#type()?;
 801 |         Ok(Binding::Type(id, ty))
 802 |     }
 803 | 
 804 |     fn module_binding(&mut self) -> ParseRes<Binding> {
 805 |         let id = self.ident()?;
 806 |         self.expect(TokenKind::Equal)?;
 807 |         let m = self.module()?;
 808 |         Ok(Binding::Module(id, m))
 809 |     }
 810 | 
 811 |     fn signature_binding(&mut self) -> ParseRes<Binding> {
 812 |         let id = self.ident()?;
 813 |         self.expect(TokenKind::Equal)?;
 814 |         let sig = self.signature()?;
 815 |         Ok(Binding::Signature(id, sig))
 816 |     }
 817 | 
 818 |     fn include_binding(&mut self) -> ParseRes<Binding> {
 819 |         let m = self.module()?;
 820 |         Ok(Binding::Include(m))
 821 |     }
 822 | 
 823 |     fn module_ident(&mut self, id: Ident) -> ParseRes<Module> {
 824 |         match self.peek().map(|t| t.kind) {
 825 |             Ok(TokenKind::OpaqueSealing) => {
 826 |                 self.proceed();
 827 |                 let sig = self.signature()?;
 828 |                 Ok(Module::Seal(id, sig))
 829 |             }
 830 |             Ok(TokenKind::Ident(s)) => {
 831 |                 self.proceed();
 832 |                 Ok(Module::App(id, Ident::from(s)))
 833 |             }
 834 |             _ => Ok(Module::Ident(id)),
 835 |         }
 836 |     }
 837 | 
 838 |     fn module_atom(&mut self) -> ParseRes<Module> {
 839 |         let token = self.peek()?;
 840 |         match token.kind {
 841 |             TokenKind::Ident(s) => {
 842 |                 self.proceed();
 843 |                 self.module_ident(Ident::from(s))
 844 |             }
 845 |             TokenKind::LParen => {
 846 |                 self.proceed();
 847 |                 let m = self.module()?;
 848 |                 self.expect(TokenKind::RParen)?;
 849 |                 Ok(m)
 850 |             }
 851 |             _ => Err(ParseError::expected("module", token)),
 852 |         }
 853 |     }
 854 | 
 855 |     fn module(&mut self) -> ParseRes<Module> {
 856 |         match self.peek()?.kind {
 857 |             TokenKind::Struct => {
 858 |                 self.proceed();
 859 |                 let mut v = Vec::new();
 860 |                 let mut state = self.save();
 861 |                 loop {
 862 |                     match self.binding() {
 863 |                         Ok(binding) => {
 864 |                             v.push(binding);
 865 |                             state = self.save();
 866 |                         }
 867 |                         Err(e) => {
 868 |                             self.restore(state);
 869 |                             self.expect(TokenKind::End).map_err(|_| e)?;
 870 |                             break;
 871 |                         }
 872 |                     }
 873 |                 }
 874 |                 Ok(Module::Seq(v))
 875 |             }
 876 |             TokenKind::Fun => {
 877 |                 self.proceed();
 878 |                 let id = self.ident()?;
 879 |                 self.expect(TokenKind::Colon)?;
 880 |                 let sig = self.signature()?;
 881 |                 self.expect(TokenKind::DoubleArrow)?;
 882 |                 let m = self.module()?;
 883 |                 Ok(Module::fun(id, sig, m))
 884 |             }
 885 |             TokenKind::Unpack => {
 886 |                 self.proceed();
 887 |                 let e = self.expr()?;
 888 |                 self.expect(TokenKind::Colon)?;
 889 |                 let sig = self.signature()?;
 890 |                 Ok(Module::unpack(e, sig))
 891 |             }
 892 |             _ => {
 893 |                 let mut m0 = self.module_atom()?;
 894 |                 while self.peek_expect(TokenKind::Dot) {
 895 |                     self.proceed();
 896 |                     let id = self.ident()?;
 897 |                     m0 = Module::proj(m0, id);
 898 |                 }
 899 |                 Ok(m0)
 900 |             }
 901 |         }
 902 |     }
 903 | }
 904 | 
 905 | pub fn parse<I>(src: I) -> Fallible<Module>
 906 | where
 907 |     I: IntoIterator<Item = char>,
 908 | {
 909 |     let mut l = Lexer::new(src.into_iter().collect());
 910 |     let tokens = l.lex_all()?;
 911 |     let mut p = Parser::new(tokens);
 912 |     let m = p.module()?;
 913 |     p.expect_eof()?;
 914 |     Ok(m)
 915 | }
 916 | 
 917 | pub fn parse_file<P>(filename: P) -> Fallible<Module>
 918 | where
 919 |     P: AsRef<std::path::Path>,
 920 | {
 921 |     use std::fs::File;
 922 |     let mut s = String::new();
 923 |     let mut f = File::open(filename)?;
 924 |     f.read_to_string(&mut s)?;
 925 |     parse(s.chars())
 926 | }
 927 | 
 928 | #[cfg(test)]
 929 | mod tests {
 930 |     #![warn(dead_code)]
 931 | 
 932 |     use super::*;
 933 | 
 934 |     #[test]
 935 |     fn lambda() {
 936 |         let mut l = Lexer::new(vec!['λ']);
 937 |         assert_eq!(
 938 |             l.lex(),
 939 |             Ok(Token {
 940 |                 kind: TokenKind::Lambda,
 941 |                 pos: Default::default(),
 942 |             })
 943 |         );
 944 |     }
 945 | 
 946 |     #[test]
 947 |     fn int_literal() {
 948 |         let mut l = Lexer::new(vec!['0', '1', '_', '9']);
 949 |         assert_eq!(
 950 |             l.lex(),
 951 |             Ok(Token {
 952 |                 kind: TokenKind::IntLit(19),
 953 |                 pos: Default::default(),
 954 |             })
 955 |         );
 956 |     }
 957 | 
 958 |     #[test]
 959 |     fn lexer() {
 960 |         let mut l = Lexer::new(vec!['s', 't', 'r', 'u', 'c', 't', ' ', 'e', 'n', 'd']);
 961 | 
 962 |         assert_eq!(
 963 |             l.lex(),
 964 |             Ok(Token {
 965 |                 kind: TokenKind::Struct,
 966 |                 pos: Default::default(),
 967 |             })
 968 |         );
 969 | 
 970 |         assert_eq!(
 971 |             l.lex(),
 972 |             Ok(Token {
 973 |                 kind: TokenKind::End,
 974 |                 pos: Position::new(1, 8)
 975 |             })
 976 |         );
 977 |     }
 978 | 
 979 |     #[test]
 980 |     fn parse_expr() {
 981 |         let mut p = Parser::new(vec![Token {
 982 |             kind: TokenKind::IntLit(33),
 983 |             pos: Default::default(),
 984 |         }]);
 985 |         assert_eq!(p.expr_atom(), Ok(Expr::Int(33)));
 986 | 
 987 |         let mut p = Parser::new(vec![Token {
 988 |             kind: TokenKind::IntLit(33),
 989 |             pos: Default::default(),
 990 |         }]);
 991 |         assert_eq!(p.expr(), Ok(Expr::Int(33)));
 992 | 
 993 |         let mut p = Parser::new(vec![Token {
 994 |             kind: TokenKind::ident("a"),
 995 |             pos: Default::default(),
 996 |         }]);
 997 |         assert_eq!(p.expr(), Ok(Expr::path(Module::Ident(Ident::from("a")))));
 998 | 
 999 |         let mut p = Parser::new(vec![
1000 |             Token {
1001 |                 kind: TokenKind::ident("a"),
1002 |                 pos: Default::default(),
1003 |             },
1004 |             Token {
1005 |                 kind: TokenKind::ident("a"),
1006 |                 pos: Default::default(),
1007 |             },
1008 |         ]);
1009 |         assert_eq!(
1010 |             p.expr(),
1011 |             Ok(Expr::app(
1012 |                 Expr::path(Module::Ident(Ident::from("a"))),
1013 |                 Expr::path(Module::Ident(Ident::from("a")))
1014 |             ))
1015 |         );
1016 |     }
1017 | 
1018 |     #[test]
1019 |     fn parse_type() {
1020 |         let mut p = Parser::new(vec![Token {
1021 |             kind: TokenKind::Int,
1022 |             pos: Default::default(),
1023 |         }]);
1024 |         assert_eq!(p.type_atom(), Ok(Type::Int));
1025 | 
1026 |         let mut p = Parser::new(vec![Token {
1027 |             kind: TokenKind::Int,
1028 |             pos: Default::default(),
1029 |         }]);
1030 |         assert_eq!(p.r#type(), Ok(Type::Int));
1031 | 
1032 |         let mut p = Parser::new(vec![Token {
1033 |             kind: TokenKind::Ident("t".to_string()),
1034 |             pos: Default::default(),
1035 |         }]);
1036 |         assert_eq!(p.r#type(), Ok(Type::path(Module::Ident(Ident::from("t")))));
1037 |     }
1038 | 
1039 |     #[test]
1040 |     fn parse_signature() {
1041 |         let mut p = Parser::new(vec![
1042 |             Token {
1043 |                 kind: TokenKind::Sig,
1044 |                 pos: Default::default(),
1045 |             },
1046 |             Token {
1047 |                 kind: TokenKind::Type,
1048 |                 pos: Default::default(),
1049 |             },
1050 |             Token {
1051 |                 kind: TokenKind::Ident("x".to_string()),
1052 |                 pos: Default::default(),
1053 |             },
1054 |             Token {
1055 |                 kind: TokenKind::Equal,
1056 |                 pos: Default::default(),
1057 |             },
1058 |             Token {
1059 |                 kind: TokenKind::Ident("t".to_string()),
1060 |                 pos: Default::default(),
1061 |             },
1062 |             Token {
1063 |                 kind: TokenKind::End,
1064 |                 pos: Default::default(),
1065 |             },
1066 |         ]);
1067 |         assert_eq!(
1068 |             p.signature(),
1069 |             Ok(Sig::Seq(vec![Decl::ManType(
1070 |                 Ident::from("x"),
1071 |                 Type::path(Module::Ident(Ident::from("t")))
1072 |             )]))
1073 |         );
1074 |     }
1075 | 
1076 |     #[test]
1077 |     fn parse_decl() {
1078 |         let mut p = Parser::new(vec![
1079 |             Token {
1080 |                 kind: TokenKind::Type,
1081 |                 pos: Default::default(),
1082 |             },
1083 |             Token {
1084 |                 kind: TokenKind::Ident("x".to_string()),
1085 |                 pos: Default::default(),
1086 |             },
1087 |             Token {
1088 |                 kind: TokenKind::Equal,
1089 |                 pos: Default::default(),
1090 |             },
1091 |             Token {
1092 |                 kind: TokenKind::Ident("t".to_string()),
1093 |                 pos: Default::default(),
1094 |             },
1095 |         ]);
1096 |         assert_eq!(
1097 |             p.decl(),
1098 |             Ok(Decl::ManType(
1099 |                 Ident::from("x"),
1100 |                 Type::path(Module::Ident(Ident::from("t")))
1101 |             ))
1102 |         );
1103 |     }
1104 | 
1105 |     #[test]
1106 |     fn parse_binding() {
1107 |         let mut p = Parser::new(vec![
1108 |             Token {
1109 |                 kind: TokenKind::Type,
1110 |                 pos: Default::default(),
1111 |             },
1112 |             Token {
1113 |                 kind: TokenKind::Ident("t".to_string()),
1114 |                 pos: Default::default(),
1115 |             },
1116 |             Token {
1117 |                 kind: TokenKind::Equal,
1118 |                 pos: Default::default(),
1119 |             },
1120 |             Token {
1121 |                 kind: TokenKind::Int,
1122 |                 pos: Default::default(),
1123 |             },
1124 |         ]);
1125 |         assert_eq!(p.binding(), Ok(Binding::Type(Ident::from("t"), Type::Int)));
1126 | 
1127 |         let mut p = Parser::new(vec![
1128 |             Token {
1129 |                 kind: TokenKind::Val,
1130 |                 pos: Default::default(),
1131 |             },
1132 |             Token {
1133 |                 kind: TokenKind::Ident("x".to_string()),
1134 |                 pos: Default::default(),
1135 |             },
1136 |             Token {
1137 |                 kind: TokenKind::Equal,
1138 |                 pos: Default::default(),
1139 |             },
1140 |             Token {
1141 |                 kind: TokenKind::IntLit(3),
1142 |                 pos: Default::default(),
1143 |             },
1144 |         ]);
1145 |         assert_eq!(
1146 |             p.binding(),
1147 |             Ok(Binding::Val(Ident::from("x"), Expr::Int(3)))
1148 |         );
1149 | 
1150 |         let mut p = Parser::new(vec![
1151 |             Token {
1152 |                 kind: TokenKind::Type,
1153 |                 pos: Default::default(),
1154 |             },
1155 |             Token {
1156 |                 kind: TokenKind::Ident("x".to_string()),
1157 |                 pos: Default::default(),
1158 |             },
1159 |             Token {
1160 |                 kind: TokenKind::Equal,
1161 |                 pos: Default::default(),
1162 |             },
1163 |             Token {
1164 |                 kind: TokenKind::Ident("t".to_string()),
1165 |                 pos: Default::default(),
1166 |             },
1167 |         ]);
1168 |         assert_eq!(
1169 |             p.binding(),
1170 |             Ok(Binding::Type(
1171 |                 Ident::from("x"),
1172 |                 Type::path(Module::Ident(Ident::from("t")))
1173 |             ))
1174 |         );
1175 |     }
1176 | 
1177 |     #[test]
1178 |     fn parse_module() {
1179 |         let mut p = Parser::new(vec![]);
1180 |         assert_eq!(p.module(), Err(ParseError::UnexpectedEOF));
1181 | 
1182 |         let mut p = Parser::new(vec![
1183 |             Token {
1184 |                 kind: TokenKind::Struct,
1185 |                 pos: Default::default(),
1186 |             },
1187 |             Token {
1188 |                 kind: TokenKind::End,
1189 |                 pos: Default::default(),
1190 |             },
1191 |         ]);
1192 |         assert_eq!(p.module(), Ok(Module::Seq(vec![])));
1193 | 
1194 |         let mut p = Parser::new(vec![
1195 |             Token {
1196 |                 kind: TokenKind::Struct,
1197 |                 pos: Default::default(),
1198 |             },
1199 |             Token {
1200 |                 kind: TokenKind::Type,
1201 |                 pos: Default::default(),
1202 |             },
1203 |             Token {
1204 |                 kind: TokenKind::Ident("t".to_string()),
1205 |                 pos: Default::default(),
1206 |             },
1207 |             Token {
1208 |                 kind: TokenKind::Equal,
1209 |                 pos: Default::default(),
1210 |             },
1211 |             Token {
1212 |                 kind: TokenKind::Int,
1213 |                 pos: Default::default(),
1214 |             },
1215 |             Token {
1216 |                 kind: TokenKind::End,
1217 |                 pos: Default::default(),
1218 |             },
1219 |         ]);
1220 |         assert_eq!(
1221 |             p.module(),
1222 |             Ok(Module::Seq(vec![Binding::Type(
1223 |                 Ident::from("t"),
1224 |                 Type::Int
1225 |             )]))
1226 |         );
1227 |     }
1228 | }
1229 | 


--------------------------------------------------------------------------------
/tests/integration.rs:
--------------------------------------------------------------------------------
  1 | use modules::exec;
  2 | use modules::typecheck;
  3 | 
  4 | macro_rules! assert_exec {
  5 |     ($s:expr) => {{
  6 |         let r = exec($s.chars());
  7 |         assert!(r.is_ok(), "{:?}", r.unwrap_err());
  8 |     }};
  9 | }
 10 | 
 11 | macro_rules! assert_typecheck {
 12 |     ($s:expr) => {{
 13 |         let r = typecheck($s.chars());
 14 |         assert!(r.is_ok(), "{:?}", r.unwrap_err());
 15 |     }};
 16 | }
 17 | 
 18 | #[test]
 19 | fn test_execution() {
 20 |     assert_exec!("struct end");
 21 |     assert_exec!("struct val x = 1 end");
 22 | 
 23 |     assert_exec!(
 24 |         "struct
 25 |            val x = 1
 26 |            val y = 1
 27 |          end"
 28 |     );
 29 | 
 30 |     assert_exec!(
 31 |         "struct
 32 |            module M = struct end
 33 | 
 34 |            module W = struct
 35 |              val x = 1
 36 |            end
 37 |          end"
 38 |     );
 39 | 
 40 |     assert_exec!(
 41 |         "struct
 42 |            val a = 1
 43 |            val b = 1
 44 |            val c = 1
 45 |          end"
 46 |     );
 47 | 
 48 |     assert_exec!(
 49 |         "struct
 50 |            val x = 20
 51 | 
 52 |            module W = struct
 53 |              val y = 40
 54 |              val f = λa.a
 55 |            end
 56 |          end"
 57 |     );
 58 | 
 59 |     assert_exec!(
 60 |         "struct
 61 |            module M = fun X : sig end =>
 62 |              ( struct
 63 |                module M = struct type t = int end
 64 |              end
 65 |              ).M
 66 | 
 67 |            module E = struct end
 68 | 
 69 |            type t = (M E).t
 70 |            type s = (M E).t
 71 | 
 72 |            module W = struct
 73 |              val x = λa.a
 74 |              val f = λa.a
 75 |            end
 76 |          end"
 77 |     );
 78 | }
 79 | 
 80 | #[test]
 81 | fn test_typecheck() {
 82 |     assert_typecheck!("struct end");
 83 |     assert_typecheck!("struct val x = 1 end");
 84 | 
 85 |     assert_typecheck!(
 86 |         "struct
 87 |            val x = 1
 88 |            val y = 1
 89 |          end"
 90 |     );
 91 | 
 92 |     assert_typecheck!(
 93 |         "struct
 94 |            module M = fun X : sig end =>
 95 |              ( struct
 96 |                  module M = struct type t = int end
 97 |                end
 98 |              ).M
 99 | 
100 |            module E = struct end
101 | 
102 |            type t = (M E).t
103 |            type s = (M E).t
104 | 
105 |            module W = struct
106 |              val x = λa.a
107 |              val f = λa.a
108 |            end
109 | 
110 |            module Y = W :> sig
111 |              val x : t -> s
112 |              val f : s -> t
113 |            end
114 |          end"
115 |     );
116 | }
117 | 


--------------------------------------------------------------------------------