From 25d752dc4bca3b2a303365e65ff96a6c7c72bc7b Mon Sep 17 00:00:00 2001 From: Ishan Bhanuka Date: Mon, 11 Sep 2023 15:53:15 +0800 Subject: [PATCH] Specially type lists for better error messages --- shared/src/main/scala/hmloc/Typer.scala | 19 + shared/src/test/diff/ocaml/Jonathan.mls | 105 +- .../src/test/diff/ocaml/OcamlComparison.mls | 262 +- shared/src/test/diff/ocaml/OcamlDataset.mls | 1510 ++-- .../src/test/diff/ocaml/OcamlExprChecker.mls | 82 +- .../src/test/diff/ocaml/OcamlPresentation.mls | 153 +- shared/src/test/diff/ocaml/Regression.mls | 7503 ++++++++++++----- shared/src/test/diff/ocaml/SurveyHard2.mls | 2 +- shared/src/test/diff/ocaml/SurveyHard3.mls | 6 +- shared/src/test/diff/ocaml/SurveyMed1.mls | 1150 ++- shared/src/test/diff/ocaml/SurveyMed2.mls | 12 +- shared/src/test/diff/ocaml/SurveyMed3.mls | 10 +- shared/src/test/diff/ocaml/TupleLists.mls | 34 +- 13 files changed, 6974 insertions(+), 3874 deletions(-) diff --git a/shared/src/main/scala/hmloc/Typer.scala b/shared/src/main/scala/hmloc/Typer.scala index 014a720..fb66d70 100644 --- a/shared/src/main/scala/hmloc/Typer.scala +++ b/shared/src/main/scala/hmloc/Typer.scala @@ -372,6 +372,25 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool) val param_ty = typePattern(pat)(newCtx, raise, vars) val body_ty = typeTerm(body)(newCtx, raise, vars) FunctionType(param_ty, body_ty)(tp(term.toLoc, "function")) + // specialize Cons Nil application for better error messages + case cons@App(Var("Cons"), Tup(v :: Var("Nil") :: Nil)) => + // version 2 inline Nil +// val arg_var = freshVar(tp(v.toCoveringLoc, "cons arg")) +// val v_ty = typeTerm(v) +// con(v_ty, arg_var, arg_var) +// TypeRef(TypeName("list"), arg_var :: Nil)(tp(cons.toLoc, "cons")) + // version 2 remove Nil completely + val v_ty = typeTerm(v) + TypeRef(TypeName("list"), v_ty :: Nil)(tp(cons.toLoc, "cons")) + // specialize Cons application for better error messages + case cons@App(Var("Cons"), Tup(v :: vs :: Nil)) => + // version 2 simplified style + val arg_var = freshVar(tp(v.toCoveringLoc, "cons arg")) + val v_ty = typeTerm(v) + con(v_ty, arg_var, arg_var) + val vs_ty = typeTerm(vs) + val res_ty = TypeRef(TypeName("list"), v_ty :: Nil)(tp(cons.toLoc, "cons")) + con(vs_ty, res_ty, res_ty) case App(f, a) => // version 2 simplified style val fun_ty = typeTerm(f) diff --git a/shared/src/test/diff/ocaml/Jonathan.mls b/shared/src/test/diff/ocaml/Jonathan.mls index 398af13..ac94873 100644 --- a/shared/src/test/diff/ocaml/Jonathan.mls +++ b/shared/src/test/diff/ocaml/Jonathan.mls @@ -221,9 +221,9 @@ let rec additivePersistence n = //│ additivePersistence: 'a -> 'b //│ where //│ 'b = bool, int -//│ U max: 6, total: 56 +//│ U max: 4, total: 50 //│ UERR 1 errors -//│ L: 0 [bool ~ int, bool <: α121', α121' <: α111', α111' :> int] +//│ L: 0 [bool ~ int, bool <: α115', α115' <: α105', α105' :> int] // The unification chain terminates at a higher level // because int is a direct parameter of the list @@ -233,52 +233,7 @@ let y x = [x] let k a = if a then [2] else y true //│ [ERROR] Type `bool` does not match `int` //│ -//│ (bool) ---> (?c) ~~~~ (?a0) ~~~~ (?a) ~~~~ (int) -//│ -//│ ◉ (bool) comes from -//│ │ - l.2 let k a = if a then [2] else y true -//│ │ ^^^^ -//│ ▼ -//│ ◉ (?c) is assumed for -//│ - l.1 let y x = [x] -//│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.1 let y x = [x] -//│ │ ^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.1 let y x = [x] -//│ ^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.1 let y x = [x] -//│ │ ^^^ -//│ │ - l.2 let k a = if a then [2] else y true -//│ │ ^^^^^^ -//│ │ - l.2 let k a = if a then [2] else y true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for -//│ ▲ - l.2 let k a = if a then [2] else y true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (?a list) comes from -//│ - l.2 let k a = if a then [2] else y true -//│ ^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.2 let k a = if a then [2] else y true -//│ │ ^ -//│ │ -//│ ◉ (int * _ list) comes from -//│ - l.2 let k a = if a then [2] else y true -//│ ^ -//│ ◉ (int) comes from -//│ - l.2 let k a = if a then [2] else y true -//│ ^ -//│ [ERROR] Type `bool` does not match `int` -//│ -//│ (bool) ---> (?b) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (int) +//│ (bool) ---> (?b) ~~~~ (int) //│ //│ ◉ (bool) comes from //│ │ - l.2 let k a = if a then [2] else y true @@ -287,35 +242,7 @@ let k a = if a then [2] else y true //│ ◉ (?b) is assumed for //│ - l.1 let y x = [x] //│ ^ -//│ ◉ (?b * ?a list) comes from -//│ │ - l.1 let y x = [x] -//│ │ ^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.1 let y x = [x] -//│ ^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.1 let y x = [x] -//│ │ ^ -//│ │ -//│ ◉ (?b * ?a list) comes from -//│ - l.1 let y x = [x] -//│ ^ -//│ ◉ (?a list) comes from -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ ◉ (?b * ?a list) comes from -//│ │ - l.1 let y x = [x] -//│ │ ^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.1 let y x = [x] -//│ ^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from +//│ ◉ (?b list) comes from //│ │ - l.1 let y x = [x] //│ │ ^^^ //│ │ - l.2 let k a = if a then [2] else y true @@ -323,27 +250,21 @@ let k a = if a then [2] else y true //│ │ - l.2 let k a = if a then [2] else y true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.2 let k a = if a then [2] else y true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from +//│ ◉ (int list) comes from //│ - l.2 let k a = if a then [2] else y true //│ ^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.2 let k a = if a then [2] else y true -//│ │ ^ -//│ │ -//│ ◉ (int * _ list) comes from -//│ - l.2 let k a = if a then [2] else y true -//│ ^ //│ ◉ (int) comes from //│ - l.2 let k a = if a then [2] else y true //│ ^ //│ y: 'a -> list['a] -//│ k: bool -> list[bool] -//│ U max: 5, total: 31 -//│ UERR 2 errors -//│ L: 1 [bool ~ int, bool <: α132', [α132' - ([[α132']], [[list['a134']]],) ~ ('a133', list['a133'],) - 'a133', L: 0 [([[α132']], [[list['a134']]],) ~ ('a133', list['a133'],), ([[α132']], [[list['a134']]],) <: ('a133', list['a133'],)]], ['a133' - list['a133'] ~ list['a130'] - 'a130', L: 0 [list['a133'] ~ list['a130'], list['a133'] <: α129', α129' :> list['a130']]], ['a130' - ('a130', list['a130'],) ~ ([[int]], [[list['a131']]],) - int, L: 0 [('a130', list['a130'],) ~ ([[int]], [[list['a131']]],), ('a130', list['a130'],) :> ([[int]], [[list['a131']]],)]]] -//│ L: 2 [bool ~ int, bool <: α132', [α132' - ([[α132']], [[list['a134']]],) ~ ('a133', list['a133'],) - 'a133', L: 0 [([[α132']], [[list['a134']]],) ~ ('a133', list['a133'],), ([[α132']], [[list['a134']]],) <: ('a133', list['a133'],)]], ['a133' - list['a133'] ~ list['a134'] - 'a134', L: 1 [list['a133'] ~ list['a134'], [list['a133'] - ('a133', list['a133'],) ~ ([[α132']], [[list['a134']]],) - list['a134'], L: 0 [('a133', list['a133'],) ~ ([[α132']], [[list['a134']]],), ('a133', list['a133'],) :> ([[α132']], [[list['a134']]],)]]]], ['a134' - list['a134'] ~ list['a133'] - 'a133', L: 1 [list['a134'] ~ list['a133'], [list['a134'] - ([[α132']], [[list['a134']]],) ~ ('a133', list['a133'],) - list['a133'], L: 0 [([[α132']], [[list['a134']]],) ~ ('a133', list['a133'],), ([[α132']], [[list['a134']]],) <: ('a133', list['a133'],)]]]], ['a133' - list['a133'] ~ list['a130'] - 'a130', L: 0 [list['a133'] ~ list['a130'], list['a133'] <: α129', α129' :> list['a130']]], ['a130' - ('a130', list['a130'],) ~ ([[int]], [[list['a131']]],) - int, L: 0 [('a130', list['a130'],) ~ ([[int]], [[list['a131']]],), ('a130', list['a130'],) :> ([[int]], [[list['a131']]],)]]] +//│ k: bool -> 'a +//│ where +//│ 'a = list['b], list[int] +//│ 'b = int, bool +//│ U max: 1, total: 7 +//│ UERR 1 errors +//│ L: 1 [bool ~ int, bool <: α121', [α121' - list[[α121']] ~ list[[int]] - int, L: 0 [list[[α121']] ~ list[[int]], list[[α121']] <: α120', α120' :> list[[int]]]]] diff --git a/shared/src/test/diff/ocaml/OcamlComparison.mls b/shared/src/test/diff/ocaml/OcamlComparison.mls index 90b5e84..ac02635 100644 --- a/shared/src/test/diff/ocaml/OcamlComparison.mls +++ b/shared/src/test/diff/ocaml/OcamlComparison.mls @@ -110,7 +110,7 @@ let bigAdd l1 l2 = //│ - l.6 let (_,res) = List.fold_left f base args in res in //│ ^^^^^^^ //│ bigAdd: list[int] -> list[int] -> list[int] -//│ U max: 63, total: 255 +//│ U max: 63, total: 253 //│ UERR 3 errors //│ L: 2 [int ~ ([α127''], [α128''],), [int - (α123'' -> [int]) ~ (α121'' -> α120'') - α120'', L: 1 [(α123'' -> [int]) ~ (α121'' -> α120''), [(α123'' -> [int]) - (α122'' -> (α123'' -> [int])) ~ (α120'' -> (α121'' -> α120'')) - (α121'' -> α120''), L: 0 [(α122'' -> (α123'' -> [int])) ~ (α120'' -> (α121'' -> α120'')), (α122'' -> (α123'' -> [int])) <: (α120'' -> (α121'' -> α120''))]]]], α120'' <: ([α127''], [α128''],)] //│ L: 1 [int ~ ([α127''], [α128''],), int :> α122'', [α122'' - (α122'' -> (α123'' -> [int])) ~ (α120'' -> (α121'' -> α120'')) - α120'', L: 0 [(α122'' -> (α123'' -> [int])) ~ (α120'' -> (α121'' -> α120'')), (α122'' -> (α123'' -> [int])) <: (α120'' -> (α121'' -> α120''))]], α120'' <: ([α127''], [α128''],)] @@ -306,11 +306,11 @@ let bigAdd l1 l2 = //│ - l.8 (let (toSum1,toSum2) = x in //│ ^^^^^^^^^^^^^^^ //│ bigAdd: list[int] -> list[int] -> list[int] -//│ U max: 35, total: 378 +//│ U max: 33, total: 360 //│ UERR 3 errors +//│ L: 2 [([α276''], [α277''],) ~ list['a290''], [([α276''], [α277''],) - list[([α276''], [α277''],)] ~ list[α293''] - α293'', L: 0 [list[([α276''], [α277''],)] ~ list[α293''], list[([α276''], [α277''],)] <: list[α293'']]], [α293'' - list[α293''] ~ list[α279''] - α279'', L: 0 [list[α293''] ~ list[α279''], list[α293''] <: list[α279'']]], [α279'' - (α279'' -> α278'') ~ (α287'' -> α284'') - α287'', L: 1 [(α279'' -> α278'') ~ (α287'' -> α284''), [(α279'' -> α278'') - (α278'' -> (α279'' -> α278'')) ~ (α280'' -> (α287'' -> α284'')) - (α287'' -> α284''), L: 0 [(α278'' -> (α279'' -> α278'')) ~ (α280'' -> (α287'' -> α284'')), (α278'' -> (α279'' -> α278'')) :> (α280'' -> (α287'' -> α284''))]]]], α287'' <: α291'', α291'' :> list['a290'']] //│ L: 0 [list['a267'''] ~ ([α271'''], [α272'''],), list['a267'''] <: α266''', α266''' :> α262''', α262''' <: ([α271'''], [α272'''],)] -//│ L: 2 [list['a288''] ~ ([α286''], [α287''],), list['a288''] <: α289'', α289'' :> α285'', [α285'' - (α285'' -> α290'') ~ (α279'' -> α278'') - α279'', L: 1 [(α285'' -> α290'') ~ (α279'' -> α278''), [(α285'' -> α290'') - (α280'' -> (α285'' -> α290'')) ~ (α278'' -> (α279'' -> α278'')) - (α279'' -> α278''), L: 0 [(α280'' -> (α285'' -> α290'')) ~ (α278'' -> (α279'' -> α278'')), (α280'' -> (α285'' -> α290'')) <: (α278'' -> (α279'' -> α278''))]]]], [α279'' - (α279'' -> α278'') ~ (α285'' -> α290'') - α285'', L: 1 [(α279'' -> α278'') ~ (α285'' -> α290''), [(α279'' -> α278'') - (α278'' -> (α279'' -> α278'')) ~ (α280'' -> (α285'' -> α290'')) - (α285'' -> α290''), L: 0 [(α278'' -> (α279'' -> α278'')) ~ (α280'' -> (α285'' -> α290'')), (α278'' -> (α279'' -> α278'')) :> (α280'' -> (α285'' -> α290''))]]]], α285'' <: ([α286''], [α287''],)] -//│ L: 2 [([α276''], [α277''],) ~ list['a288''], [([α276''], [α277''],) - list[([α276''], [α277''],)] ~ list[α294''] - α294'', L: 0 [list[([α276''], [α277''],)] ~ list[α294''], list[([α276''], [α277''],)] <: list[α294'']]], [α294'' - list[α294''] ~ list[α279''] - α279'', L: 0 [list[α294''] ~ list[α279''], list[α294''] <: list[α279'']]], [α279'' - (α279'' -> α278'') ~ (α285'' -> α290'') - α285'', L: 1 [(α279'' -> α278'') ~ (α285'' -> α290''), [(α279'' -> α278'') - (α278'' -> (α279'' -> α278'')) ~ (α280'' -> (α285'' -> α290'')) - (α285'' -> α290''), L: 0 [(α278'' -> (α279'' -> α278'')) ~ (α280'' -> (α285'' -> α290'')), (α278'' -> (α279'' -> α278'')) :> (α280'' -> (α285'' -> α290''))]]]], α285'' <: α289'', α289'' :> list['a288'']] +//│ L: 2 [list['a290''] ~ ([α288''], [α289''],), list['a290''] <: α291'', α291'' :> α287'', [α287'' - (α287'' -> α284'') ~ (α279'' -> α278'') - α279'', L: 1 [(α287'' -> α284'') ~ (α279'' -> α278''), [(α287'' -> α284'') - (α280'' -> (α287'' -> α284'')) ~ (α278'' -> (α279'' -> α278'')) - (α279'' -> α278''), L: 0 [(α280'' -> (α287'' -> α284'')) ~ (α278'' -> (α279'' -> α278'')), (α280'' -> (α287'' -> α284'')) <: (α278'' -> (α279'' -> α278''))]]]], [α279'' - (α279'' -> α278'') ~ (α287'' -> α284'') - α287'', L: 1 [(α279'' -> α278'') ~ (α287'' -> α284''), [(α279'' -> α278'') - (α278'' -> (α279'' -> α278'')) ~ (α280'' -> (α287'' -> α284'')) - (α287'' -> α284''), L: 0 [(α278'' -> (α279'' -> α278'')) ~ (α280'' -> (α287'' -> α284'')), (α278'' -> (α279'' -> α278'')) :> (α280'' -> (α287'' -> α284''))]]]], α287'' <: ([α288''], [α289''],)] ////////// file 1948 @@ -528,7 +528,7 @@ let bigMul l1 l2 = //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?c) ---> (?a) ~~~~ (?e) ---> (_ list) +//│ (_ * _) ---> (?e) ---> (?a) ~~~~ (?c) ---> (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -536,7 +536,7 @@ let bigMul l1 l2 = //│ │ - l.-26let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ │ - l.-26let bigAdd l1 l2 = //│ │ ^^ //│ │ - l.-17 removeZero (add (padZero l1 l2));; @@ -571,10 +571,10 @@ let bigMul l1 l2 = //│ │ - l.-17 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e * _) comes from +//│ ◉ (?c * _) comes from //│ - l.-25 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?e) is assumed for +//│ ◉ (?c) is assumed for //│ │ - l.-25 let add (l1,l2) = //│ │ ^^ //│ │ - l.-19 let args = List.rev (List.combine l1 l2) in @@ -585,7 +585,7 @@ let bigMul l1 l2 = //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?c) ---> (?a) ~~~~ (?e) ~~~~ (_ list) +//│ (_ * _) ---> (?e) ---> (?a) ~~~~ (?c) ~~~~ (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -593,7 +593,7 @@ let bigMul l1 l2 = //│ │ - l.-26let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ │ - l.-26let bigAdd l1 l2 = //│ │ ^^ //│ │ - l.-17 removeZero (add (padZero l1 l2));; @@ -628,13 +628,13 @@ let bigMul l1 l2 = //│ │ - l.-17 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e * _) comes from +//│ ◉ (?c * _) comes from //│ - l.-25 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?e) is assumed for +//│ ◉ (?c) is assumed for //│ - l.-25 let add (l1,l2) = //│ ^^ -//│ ◉ (?e * _) comes from +//│ ◉ (?c * _) comes from //│ ▲ - l.-25 let add (l1,l2) = //│ │ ^^^^^^^ //│ │ - l.-17 removeZero (add (padZero l1 l2));; @@ -670,7 +670,7 @@ let bigMul l1 l2 = //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?c) ---> (?a) ~~~~ (?e) ~~~~ (?a) ---> (_ list) +//│ (_ * _) ---> (?e) ---> (?a) ~~~~ (?c) ~~~~ (?a) ---> (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -678,7 +678,7 @@ let bigMul l1 l2 = //│ │ - l.-26let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ │ - l.-26let bigAdd l1 l2 = //│ │ ^^ //│ │ - l.-17 removeZero (add (padZero l1 l2));; @@ -713,13 +713,13 @@ let bigMul l1 l2 = //│ │ - l.-17 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e * _) comes from +//│ ◉ (?c * _) comes from //│ - l.-25 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?e) is assumed for +//│ ◉ (?c) is assumed for //│ - l.-25 let add (l1,l2) = //│ ^^ -//│ ◉ (?e * _) comes from +//│ ◉ (?c * _) comes from //│ ▲ - l.-25 let add (l1,l2) = //│ │ ^^^^^^^ //│ │ - l.-17 removeZero (add (padZero l1 l2));; @@ -759,7 +759,7 @@ let bigMul l1 l2 = //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?c) ---> (?a) ~~~~ (?e) ~~~~ (?a) ---> (_ list) +//│ (_ * _) ---> (?e) ---> (?a) ~~~~ (?c) ~~~~ (?a) ---> (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -767,7 +767,7 @@ let bigMul l1 l2 = //│ │ - l.-26let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ │ - l.-26let bigAdd l1 l2 = //│ │ ^^ //│ │ - l.-17 removeZero (add (padZero l1 l2));; @@ -802,13 +802,13 @@ let bigMul l1 l2 = //│ │ - l.-17 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e * _) comes from +//│ ◉ (?c * _) comes from //│ - l.-25 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?e) is assumed for +//│ ◉ (?c) is assumed for //│ - l.-25 let add (l1,l2) = //│ ^^ -//│ ◉ (?e * _) comes from +//│ ◉ (?c * _) comes from //│ ▲ - l.-25 let add (l1,l2) = //│ │ ^^^^^^^ //│ │ - l.-17 removeZero (add (padZero l1 l2));; @@ -848,7 +848,7 @@ let bigMul l1 l2 = //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?c) ---> (?a) ~~~~ (?e) ~~~~ (?a) ---> (_ list) +//│ (_ * _) ---> (?e) ---> (?a) ~~~~ (?c) ~~~~ (?a) ---> (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -856,7 +856,7 @@ let bigMul l1 l2 = //│ │ - l.-26let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ │ - l.-26let bigAdd l1 l2 = //│ │ ^^ //│ │ - l.-17 removeZero (add (padZero l1 l2));; @@ -891,13 +891,13 @@ let bigMul l1 l2 = //│ │ - l.-17 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e * _) comes from +//│ ◉ (?c * _) comes from //│ - l.-25 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?e) is assumed for +//│ ◉ (?c) is assumed for //│ - l.-25 let add (l1,l2) = //│ ^^ -//│ ◉ (?e * _) comes from +//│ ◉ (?c * _) comes from //│ ▲ - l.-25 let add (l1,l2) = //│ │ ^^^^^^^ //│ │ - l.-17 removeZero (add (padZero l1 l2));; @@ -937,7 +937,7 @@ let bigMul l1 l2 = //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?c) ---> (?a) ~~~~ (?e) ~~~~ (?a) ---> (_ list) +//│ (_ * _) ---> (?e) ---> (?a) ~~~~ (?c) ~~~~ (?a) ---> (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -945,7 +945,7 @@ let bigMul l1 l2 = //│ │ - l.-26let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ │ - l.-26let bigAdd l1 l2 = //│ │ ^^ //│ │ - l.-17 removeZero (add (padZero l1 l2));; @@ -980,13 +980,13 @@ let bigMul l1 l2 = //│ │ - l.-17 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e * _) comes from +//│ ◉ (?c * _) comes from //│ - l.-25 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?e) is assumed for +//│ ◉ (?c) is assumed for //│ - l.-25 let add (l1,l2) = //│ ^^ -//│ ◉ (?e * _) comes from +//│ ◉ (?c * _) comes from //│ ▲ - l.-25 let add (l1,l2) = //│ │ ^^^^^^^ //│ │ - l.-17 removeZero (add (padZero l1 l2));; @@ -1026,35 +1026,35 @@ let bigMul l1 l2 = //│ ^^^^^^^ //│ [ERROR] Type `int * _ list` does not match `_ -> _` //│ -//│ (int * _ list) ---> (?a) ~~~~ (?b) <--- (?d) <--- (?c) <--- (_ -> _) +//│ (int * _ list) ---> (?d) ~~~~ (?a) <--- (?c) <--- (?b) <--- (_ -> _) //│ //│ ◉ (int * _ list) comes from //│ │ - l.6 let base = (0, []) in //│ │ ^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for +//│ ◉ (?d) is assumed for //│ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ ^^^^ -//│ ◉ (_ -> ?a) comes from +//│ ◉ (_ -> ?d) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?a -> _ -> ?a) comes from +//│ ◉ (?d -> _ -> ?d) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ //│ │ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ │ -//│ ◉ (_ -> _ -> ?b) comes from +//│ ◉ (_ -> _ -> ?a) comes from //│ - l.2 let f a x = //│ ^^^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?b) comes from +//│ ◉ (_ -> ?a) comes from //│ - l.2 let f a x = //│ ^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.3 let (x1,x2) = x in //│ │ ^^^^^^^^^^^^^^^^^^ //│ │ let (carry,res) = a in ... @@ -1064,7 +1064,7 @@ let bigMul l1 l2 = //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.4 let (carry,res) = a in //│ │ ^^^^^^^^^^^^^^^^^^^^^^ //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -1072,7 +1072,7 @@ let bigMul l1 l2 = //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?c) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -1085,35 +1085,35 @@ let bigMul l1 l2 = //│ ^^^^^^^^^^^^^^^^^^^^^ //│ [ERROR] Type `int * _ list` does not match `_ list` //│ -//│ (int * _ list) ---> (?a) ~~~~ (?b) <--- (?d) <--- (?c) <--- (_ list) +//│ (int * _ list) ---> (?d) ~~~~ (?a) <--- (?c) <--- (?b) <--- (_ list) //│ //│ ◉ (int * _ list) comes from //│ │ - l.6 let base = (0, []) in //│ │ ^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for +//│ ◉ (?d) is assumed for //│ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ ^^^^ -//│ ◉ (_ -> ?a) comes from +//│ ◉ (_ -> ?d) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?a -> _ -> ?a) comes from +//│ ◉ (?d -> _ -> ?d) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ //│ │ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ │ -//│ ◉ (_ -> _ -> ?b) comes from +//│ ◉ (_ -> _ -> ?a) comes from //│ - l.2 let f a x = //│ ^^^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?b) comes from +//│ ◉ (_ -> ?a) comes from //│ - l.2 let f a x = //│ ^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.3 let (x1,x2) = x in //│ │ ^^^^^^^^^^^^^^^^^^ //│ │ let (carry,res) = a in ... @@ -1123,7 +1123,7 @@ let bigMul l1 l2 = //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.4 let (carry,res) = a in //│ │ ^^^^^^^^^^^^^^^^^^^^^^ //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -1131,7 +1131,7 @@ let bigMul l1 l2 = //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?c) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ @@ -1140,7 +1140,7 @@ let bigMul l1 l2 = //│ ^^ //│ [ERROR] Type `_ -> _` does not match `_ * _` //│ -//│ (_ -> _) ---> (?c) ---> (?d) ---> (?b) ~~~~ (?a) ---> (_ * _) +//│ (_ -> _) ---> (?b) ---> (?c) ---> (?a) ~~~~ (?d) ---> (_ * _) //│ //│ ◉ (_ -> _) comes from //│ │ - l.-26let bigAdd l1 l2 = @@ -1152,7 +1152,7 @@ let bigMul l1 l2 = //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.4 let (carry,res) = a in @@ -1160,23 +1160,23 @@ let bigMul l1 l2 = //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ │ - l.4 let (carry,res) = a in //│ │ ^^^^^^^^^^^^^^^^^^^^^^ //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ - l.3 let (x1,x2) = x in //│ ^^^^^^^^^^^^^^^^^^ //│ let (carry,res) = a in ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?b) comes from +//│ ◉ (_ -> ?a) comes from //│ - l.2 let f a x = //│ ^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> _ -> ?b) comes from +//│ ◉ (_ -> _ -> ?a) comes from //│ │ - l.2 let f a x = //│ │ ^^^^^ //│ │ let (x1,x2) = x in ... @@ -1184,13 +1184,13 @@ let bigMul l1 l2 = //│ │ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ ▼ -//│ ◉ (?a -> _ -> ?a) comes from +//│ ◉ (?d -> _ -> ?d) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?a) comes from +//│ ◉ (_ -> ?d) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?a) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ @@ -1199,7 +1199,7 @@ let bigMul l1 l2 = //│ ^^^^^^^^^^^ //│ [ERROR] Type `_ list` does not match `_ * _` //│ -//│ (_ list) ---> (?c) ---> (?d) ---> (?b) ~~~~ (?a) ---> (_ * _) +//│ (_ list) ---> (?b) ---> (?c) ---> (?a) ~~~~ (?d) ---> (_ * _) //│ //│ ◉ (_ list) comes from //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -1207,7 +1207,7 @@ let bigMul l1 l2 = //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.4 let (carry,res) = a in @@ -1215,23 +1215,23 @@ let bigMul l1 l2 = //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ │ - l.4 let (carry,res) = a in //│ │ ^^^^^^^^^^^^^^^^^^^^^^ //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ - l.3 let (x1,x2) = x in //│ ^^^^^^^^^^^^^^^^^^ //│ let (carry,res) = a in ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?b) comes from +//│ ◉ (_ -> ?a) comes from //│ - l.2 let f a x = //│ ^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> _ -> ?b) comes from +//│ ◉ (_ -> _ -> ?a) comes from //│ │ - l.2 let f a x = //│ │ ^^^^^ //│ │ let (x1,x2) = x in ... @@ -1239,13 +1239,13 @@ let bigMul l1 l2 = //│ │ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ ▼ -//│ ◉ (?a -> _ -> ?a) comes from +//│ ◉ (?d -> _ -> ?d) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?a) comes from +//│ ◉ (_ -> ?d) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?a) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ @@ -1301,7 +1301,7 @@ let bigMul l1 l2 = //│ ^^ //│ [ERROR] Type `_ -> _` does not match `_ * _` //│ -//│ (_ -> _) ---> (?b) ---> (?d) ---> (?e) ~~~~ (?a) ~~~~ (?c) ---> (_ * _) +//│ (_ -> _) ---> (?a) ---> (?c) ---> (?e) ~~~~ (?d) ~~~~ (?b) ---> (_ * _) //│ //│ ◉ (_ -> _) comes from //│ │ - l.-26let bigAdd l1 l2 = @@ -1313,7 +1313,7 @@ let bigMul l1 l2 = //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.4 let (carry,res) = a in @@ -1321,7 +1321,7 @@ let bigMul l1 l2 = //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ │ - l.4 let (carry,res) = a in //│ │ ^^^^^^^^^^^^^^^^^^^^^^ //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -1337,7 +1337,7 @@ let bigMul l1 l2 = //│ ^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?c -> _ -> ?e) comes from +//│ ◉ (?b -> _ -> ?e) comes from //│ │ - l.2 let f a x = //│ │ ^^^^^ //│ │ let (x1,x2) = x in ... @@ -1345,25 +1345,25 @@ let bigMul l1 l2 = //│ │ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ ▼ -//│ ◉ (?a -> _ -> ?a) comes from +//│ ◉ (?d -> _ -> ?d) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?a) comes from +//│ ◉ (_ -> ?d) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a -> _ -> ?a) comes from +//│ ◉ (?d) is assumed for +//│ ◉ (?d -> _ -> ?d) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ //│ │ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ │ -//│ ◉ (?c -> _ -> ?e) comes from +//│ ◉ (?b -> _ -> ?e) comes from //│ - l.2 let f a x = //│ ^^^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?c) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.2 let f a x = //│ │ ^ //│ │ - l.4 let (carry,res) = a in @@ -1374,7 +1374,7 @@ let bigMul l1 l2 = //│ ^^^^^^^^^^^ //│ [ERROR] Type `_ list` does not match `_ * _` //│ -//│ (_ list) ---> (?b) ---> (?d) ---> (?e) ~~~~ (?a) ~~~~ (?c) ---> (_ * _) +//│ (_ list) ---> (?a) ---> (?c) ---> (?e) ~~~~ (?d) ~~~~ (?b) ---> (_ * _) //│ //│ ◉ (_ list) comes from //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -1382,7 +1382,7 @@ let bigMul l1 l2 = //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.4 let (carry,res) = a in @@ -1390,7 +1390,7 @@ let bigMul l1 l2 = //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ │ - l.4 let (carry,res) = a in //│ │ ^^^^^^^^^^^^^^^^^^^^^^ //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -1406,7 +1406,7 @@ let bigMul l1 l2 = //│ ^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?c -> _ -> ?e) comes from +//│ ◉ (?b -> _ -> ?e) comes from //│ │ - l.2 let f a x = //│ │ ^^^^^ //│ │ let (x1,x2) = x in ... @@ -1414,25 +1414,25 @@ let bigMul l1 l2 = //│ │ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ ▼ -//│ ◉ (?a -> _ -> ?a) comes from +//│ ◉ (?d -> _ -> ?d) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?a) comes from +//│ ◉ (_ -> ?d) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a -> _ -> ?a) comes from +//│ ◉ (?d) is assumed for +//│ ◉ (?d -> _ -> ?d) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ //│ │ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ │ -//│ ◉ (?c -> _ -> ?e) comes from +//│ ◉ (?b -> _ -> ?e) comes from //│ - l.2 let f a x = //│ ^^^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?c) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.2 let f a x = //│ │ ^ //│ │ - l.4 let (carry,res) = a in @@ -1443,7 +1443,7 @@ let bigMul l1 l2 = //│ ^^^^^^^^^^^ //│ [ERROR] Type `_ list` does not match `_ -> _` //│ -//│ (_ list) ---> (?c) ---> (?d) ---> (?b) ~~~~ (?a) ~~~~ (?b) <--- (?d) <--- (?c) <--- (_ -> _) +//│ (_ list) ---> (?b) ---> (?c) ---> (?a) ~~~~ (?d) ~~~~ (?a) <--- (?c) <--- (?b) <--- (_ -> _) //│ //│ ◉ (_ list) comes from //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -1451,7 +1451,7 @@ let bigMul l1 l2 = //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.4 let (carry,res) = a in @@ -1459,23 +1459,23 @@ let bigMul l1 l2 = //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ │ - l.4 let (carry,res) = a in //│ │ ^^^^^^^^^^^^^^^^^^^^^^ //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ - l.3 let (x1,x2) = x in //│ ^^^^^^^^^^^^^^^^^^ //│ let (carry,res) = a in ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?b) comes from +//│ ◉ (_ -> ?a) comes from //│ - l.2 let f a x = //│ ^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> _ -> ?b) comes from +//│ ◉ (_ -> _ -> ?a) comes from //│ │ - l.2 let f a x = //│ │ ^^^^^ //│ │ let (x1,x2) = x in ... @@ -1483,33 +1483,33 @@ let bigMul l1 l2 = //│ │ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ ▼ -//│ ◉ (?a -> _ -> ?a) comes from +//│ ◉ (?d -> _ -> ?d) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?a) comes from +//│ ◉ (_ -> ?d) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (_ -> ?a) comes from +//│ ◉ (?d) is assumed for +//│ ◉ (_ -> ?d) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?a -> _ -> ?a) comes from +//│ ◉ (?d -> _ -> ?d) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ //│ │ - l.8 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ │ -//│ ◉ (_ -> _ -> ?b) comes from +//│ ◉ (_ -> _ -> ?a) comes from //│ - l.2 let f a x = //│ ^^^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?b) comes from +//│ ◉ (_ -> ?a) comes from //│ - l.2 let f a x = //│ ^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.3 let (x1,x2) = x in //│ │ ^^^^^^^^^^^^^^^^^^ //│ │ let (carry,res) = a in ... @@ -1519,7 +1519,7 @@ let bigMul l1 l2 = //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.4 let (carry,res) = a in //│ │ ^^^^^^^^^^^^^^^^^^^^^^ //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -1527,7 +1527,7 @@ let bigMul l1 l2 = //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?c) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.5 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -1541,28 +1541,28 @@ let bigMul l1 l2 = //│ bigMul: 'a -> list[int] -> list[int] //│ where //│ 'a = list[int] -> list[('b, list[int],)], list['c] -//│ U max: 17, total: 275 +//│ U max: 13, total: 241 //│ UERR 20 errors -//│ L: 2 [(α751' -> α809') ~ ([α824'], [α825'],), (α751' -> α809') <: α748', α748' <: α749', α749' <: α747', [α747' - (α744' -> α747') ~ (α740' -> α739') - α739', L: 1 [(α744' -> α747') ~ (α740' -> α739'), [(α744' -> α747') - (α741' -> (α744' -> α747')) ~ (α739' -> (α740' -> α739')) - (α740' -> α739'), L: 0 [(α741' -> (α744' -> α747')) ~ (α739' -> (α740' -> α739')), (α741' -> (α744' -> α747')) <: (α739' -> (α740' -> α739'))]]]], α739' <: ([α824'], [α825'],)] -//│ L: 1 [([α717'], [[[α615'']]],) ~ list[α620''], ([α717'], [[[α615'']]],) <: α619'', α619'' <: α634'', [α634'' - ([[α634'']], [[α636'']],) ~ ([α635''], [α651''],) - α635'', L: 0 [([[α634'']], [[α636'']],) ~ ([α635''], [α651''],), ([[α634'']], [[α636'']],) <: α652'', α652'' <: α653'', α653'' <: ([α635''], [α651''],)]], [α635'' - ([α635''], [α651''],) ~ ([[α634'']], [[α636'']],) - α634'', L: 0 [([α635''], [α651''],) ~ ([[α634'']], [[α636'']],), ([α635''], [α651''],) :> α653'', α653'' :> α652'', α652'' :> ([[α634'']], [[α636'']],)]], α634'' <: list[α620'']] -//│ L: 0 [([α717'], [[[α615'']]],) ~ list[α620''], ([α717'], [[[α615'']]],) <: α619'', α619'' <: α634'', α634'' <: list[α620'']] -//│ L: 2 [([[int]], [[list['a822']]],) ~ (α751' -> α809'), ([[int]], [[list['a822']]],) <: α739', [α739' - (α740' -> α739') ~ (α744' -> α747') - α747', L: 1 [(α740' -> α739') ~ (α744' -> α747'), [(α740' -> α739') - (α739' -> (α740' -> α739')) ~ (α741' -> (α744' -> α747')) - (α744' -> α747'), L: 0 [(α739' -> (α740' -> α739')) ~ (α741' -> (α744' -> α747')), (α739' -> (α740' -> α739')) :> (α741' -> (α744' -> α747'))]]]], α747' :> α749', α749' :> α748', α748' :> (α751' -> α809')] -//│ L: 0 [([α717'], [[[α615'']]],) ~ list[α687''], ([α717'], [[[α615'']]],) <: α619'', α619'' <: α634'', α634'' <: list[α687'']] -//│ L: 0 [([α717'], [[[α615'']]],) ~ list[α621''], ([α717'], [[[α615'']]],) <: α619'', α619'' <: α634'', α634'' <: list[α621'']] -//│ L: 1 [([α717'], [[[α615'']]],) ~ list[α633''], ([α717'], [[[α615'']]],) <: α619'', α619'' <: α634'', [α634'' - ([[α634'']], [[α636'']],) ~ ([α635''], [α651''],) - α635'', L: 0 [([[α634'']], [[α636'']],) ~ ([α635''], [α651''],), ([[α634'']], [[α636'']],) <: α652'', α652'' <: α653'', α653'' <: ([α635''], [α651''],)]], [α635'' - ([α635''], [α651''],) ~ ([[α634'']], [[α636'']],) - α634'', L: 0 [([α635''], [α651''],) ~ ([[α634'']], [[α636'']],), ([α635''], [α651''],) :> α653'', α653'' :> α652'', α652'' :> ([[α634'']], [[α636'']],)]], α634'' <: list[α633'']] -//│ L: 2 [list['a750'] ~ (α751' -> α809'), list['a750'] <: α748', α748' <: α749', α749' <: α747', [α747' - (α744' -> α747') ~ (α740' -> α739') - α739', L: 1 [(α744' -> α747') ~ (α740' -> α739'), [(α744' -> α747') - (α741' -> (α744' -> α747')) ~ (α739' -> (α740' -> α739')) - (α740' -> α739'), L: 0 [(α741' -> (α744' -> α747')) ~ (α739' -> (α740' -> α739')), (α741' -> (α744' -> α747')) <: (α739' -> (α740' -> α739'))]]]], [α739' - (α740' -> α739') ~ (α744' -> α747') - α747', L: 1 [(α740' -> α739') ~ (α744' -> α747'), [(α740' -> α739') - (α739' -> (α740' -> α739')) ~ (α741' -> (α744' -> α747')) - (α744' -> α747'), L: 0 [(α739' -> (α740' -> α739')) ~ (α741' -> (α744' -> α747')), (α739' -> (α740' -> α739')) :> (α741' -> (α744' -> α747'))]]]], α747' :> α749', α749' :> α748', α748' :> (α751' -> α809')] -//│ L: 0 [([α717'], [[[α615'']]],) ~ list[α688''], ([α717'], [[[α615'']]],) <: α619'', α619'' <: α634'', α634'' <: list[α688'']] -//│ L: 1 [([α717'], [[[α615'']]],) ~ list[α632''], ([α717'], [[[α615'']]],) <: α619'', α619'' <: α634'', [α634'' - ([[α634'']], [[α636'']],) ~ ([α635''], [α651''],) - α635'', L: 0 [([[α634'']], [[α636'']],) ~ ([α635''], [α651''],), ([[α634'']], [[α636'']],) <: α652'', α652'' <: α653'', α653'' <: ([α635''], [α651''],)]], α635'' <: list[α632'']] -//│ L: 2 [(α751' -> α809') ~ ([α742'], [α743'],), (α751' -> α809') <: α748', α748' <: α749', α749' <: α747', [α747' - (α744' -> α747') ~ (α740' -> α739') - α739', L: 1 [(α744' -> α747') ~ (α740' -> α739'), [(α744' -> α747') - (α741' -> (α744' -> α747')) ~ (α739' -> (α740' -> α739')) - (α740' -> α739'), L: 0 [(α741' -> (α744' -> α747')) ~ (α739' -> (α740' -> α739')), (α741' -> (α744' -> α747')) <: (α739' -> (α740' -> α739'))]]]], [α739' - (α739' -> (α740' -> α739')) ~ (α741' -> (α744' -> α747')) - α741', L: 0 [(α739' -> (α740' -> α739')) ~ (α741' -> (α744' -> α747')), (α739' -> (α740' -> α739')) :> (α741' -> (α744' -> α747'))]], α741' <: ([α742'], [α743'],)] -//│ L: 2 [list['a750'] ~ ([α824'], [α825'],), list['a750'] <: α748', α748' <: α749', α749' <: α747', [α747' - (α744' -> α747') ~ (α740' -> α739') - α739', L: 1 [(α744' -> α747') ~ (α740' -> α739'), [(α744' -> α747') - (α741' -> (α744' -> α747')) ~ (α739' -> (α740' -> α739')) - (α740' -> α739'), L: 0 [(α741' -> (α744' -> α747')) ~ (α739' -> (α740' -> α739')), (α741' -> (α744' -> α747')) <: (α739' -> (α740' -> α739'))]]]], α739' <: ([α824'], [α825'],)] -//│ L: 1 [([α717'], [[[α615'']]],) ~ list[α687''], ([α717'], [[[α615'']]],) <: α619'', α619'' <: α634'', [α634'' - ([[α634'']], [[α636'']],) ~ ([α635''], [α651''],) - α635'', L: 0 [([[α634'']], [[α636'']],) ~ ([α635''], [α651''],), ([[α634'']], [[α636'']],) <: α652'', α652'' <: α653'', α653'' <: ([α635''], [α651''],)]], [α635'' - ([α635''], [α651''],) ~ ([[α634'']], [[α636'']],) - α634'', L: 0 [([α635''], [α651''],) ~ ([[α634'']], [[α636'']],), ([α635''], [α651''],) :> α653'', α653'' :> α652'', α652'' :> ([[α634'']], [[α636'']],)]], α634'' <: list[α687'']] -//│ L: 1 [([α717'], [[[α615'']]],) ~ list[α621''], ([α717'], [[[α615'']]],) <: α619'', α619'' <: α634'', [α634'' - ([[α634'']], [[α636'']],) ~ ([α635''], [α651''],) - α635'', L: 0 [([[α634'']], [[α636'']],) ~ ([α635''], [α651''],), ([[α634'']], [[α636'']],) <: α652'', α652'' <: α653'', α653'' <: ([α635''], [α651''],)]], [α635'' - ([α635''], [α651''],) ~ ([[list[α621'']]], [[α636'']],) - list[α621''], L: 0 [([α635''], [α651''],) ~ ([[list[α621'']]], [[α636'']],), ([α635''], [α651''],) :> α653'', α653'' :> α652'', α652'' :> ([[list[α621'']]], [[α636'']],)]]] -//│ L: 0 [([α717'], [[[α615'']]],) ~ list[α633''], ([α717'], [[[α615'']]],) <: α619'', α619'' <: α634'', α634'' <: list[α633'']] -//│ L: 0 [(α685'' -> α674'') ~ list['a618''], (α685'' -> α674'') <: α616'', α616'' :> list['a618'']] -//│ L: 2 [list['a750'] ~ ([α742'], [α743'],), list['a750'] <: α748', α748' <: α749', α749' <: α747', [α747' - (α744' -> α747') ~ (α740' -> α739') - α739', L: 1 [(α744' -> α747') ~ (α740' -> α739'), [(α744' -> α747') - (α741' -> (α744' -> α747')) ~ (α739' -> (α740' -> α739')) - (α740' -> α739'), L: 0 [(α741' -> (α744' -> α747')) ~ (α739' -> (α740' -> α739')), (α741' -> (α744' -> α747')) <: (α739' -> (α740' -> α739'))]]]], [α739' - (α739' -> (α740' -> α739')) ~ (α741' -> (α744' -> α747')) - α741', L: 0 [(α739' -> (α740' -> α739')) ~ (α741' -> (α744' -> α747')), (α739' -> (α740' -> α739')) :> (α741' -> (α744' -> α747'))]], α741' <: ([α742'], [α743'],)] -//│ L: 2 [list[α693'] ~ (α737' -> α738'), list[α693'] :> α692', [α692' - (α692' -> α703') ~ ([α606'] -> α717') - α606', L: 1 [(α692' -> α703') ~ ([α606'] -> α717'), [(α692' -> α703') - (α691' -> (α692' -> α703')) ~ (['a617'] -> α716') - α716', L: 0 [(α691' -> (α692' -> α703')) ~ (['a617'] -> α716'), (α691' -> (α692' -> α703')) <: mulByDigit690', mulByDigit690' <: (['a617'] -> α716')]], α716' <: ([α606'] -> α717')]], α606' <: (α737' -> α738')] -//│ L: 1 [([α717'], [[[α615'']]],) ~ list[α688''], ([α717'], [[[α615'']]],) <: α619'', α619'' <: α634'', [α634'' - ([[α634'']], [[α636'']],) ~ ([α635''], [α651''],) - α635'', L: 0 [([[α634'']], [[α636'']],) ~ ([α635''], [α651''],), ([[α634'']], [[α636'']],) <: α652'', α652'' <: α653'', α653'' <: ([α635''], [α651''],)]], [α635'' - ([α635''], [α651''],) ~ ([[α634'']], [[α636'']],) - α634'', L: 0 [([α635''], [α651''],) ~ ([[α634'']], [[α636'']],), ([α635''], [α651''],) :> α653'', α653'' :> α652'', α652'' :> ([[α634'']], [[α636'']],)]], α634'' <: list[α688'']] -//│ L: 2 [([[int]], [[list['a822']]],) ~ list['a750'], ([[int]], [[list['a822']]],) <: α739', [α739' - (α740' -> α739') ~ (α744' -> α747') - α747', L: 1 [(α740' -> α739') ~ (α744' -> α747'), [(α740' -> α739') - (α739' -> (α740' -> α739')) ~ (α741' -> (α744' -> α747')) - (α744' -> α747'), L: 0 [(α739' -> (α740' -> α739')) ~ (α741' -> (α744' -> α747')), (α739' -> (α740' -> α739')) :> (α741' -> (α744' -> α747'))]]]], α747' :> α749', α749' :> α748', α748' :> list['a750']] +//│ L: 0 [([α692'], [[[α598'']]],) ~ list[α604''], ([α692'], [[[α598'']]],) <: α602'', α602'' <: α616'', α616'' <: list[α604'']] +//│ L: 1 [([α692'], [[[α598'']]],) ~ list[α666''], ([α692'], [[[α598'']]],) <: α602'', α602'' <: α616'', [α616'' - ([[α616'']], [[α618'']],) ~ ([α617''], [α633''],) - α617'', L: 0 [([[α616'']], [[α618'']],) ~ ([α617''], [α633''],), ([[α616'']], [[α618'']],) <: α634'', α634'' <: α635'', α635'' <: ([α617''], [α633''],)]], [α617'' - ([α617''], [α633''],) ~ ([[α616'']], [[α618'']],) - α616'', L: 0 [([α617''], [α633''],) ~ ([[α616'']], [[α618'']],), ([α617''], [α633''],) :> α635'', α635'' :> α634'', α634'' :> ([[α616'']], [[α618'']],)]], α616'' <: list[α666'']] +//│ L: 2 [([[int]], [[list['a792']]],) ~ (α724' -> α781'), ([[int]], [[list['a792']]],) <: α712', [α712' - (α713' -> α712') ~ (α717' -> α720') - α720', L: 1 [(α713' -> α712') ~ (α717' -> α720'), [(α713' -> α712') - (α712' -> (α713' -> α712')) ~ (α714' -> (α717' -> α720')) - (α717' -> α720'), L: 0 [(α712' -> (α713' -> α712')) ~ (α714' -> (α717' -> α720')), (α712' -> (α713' -> α712')) :> (α714' -> (α717' -> α720'))]]]], α720' :> α722', α722' :> α721', α721' :> (α724' -> α781')] +//│ L: 1 [([α692'], [[[α598'']]],) ~ list[α603''], ([α692'], [[[α598'']]],) <: α602'', α602'' <: α616'', [α616'' - ([[α616'']], [[α618'']],) ~ ([α617''], [α633''],) - α617'', L: 0 [([[α616'']], [[α618'']],) ~ ([α617''], [α633''],), ([[α616'']], [[α618'']],) <: α634'', α634'' <: α635'', α635'' <: ([α617''], [α633''],)]], [α617'' - ([α617''], [α633''],) ~ ([[α616'']], [[α618'']],) - α616'', L: 0 [([α617''], [α633''],) ~ ([[α616'']], [[α618'']],), ([α617''], [α633''],) :> α635'', α635'' :> α634'', α634'' :> ([[α616'']], [[α618'']],)]], α616'' <: list[α603'']] +//│ L: 2 [list['a723'] ~ ([α794'], [α795'],), list['a723'] <: α721', α721' <: α722', α722' <: α720', [α720' - (α717' -> α720') ~ (α713' -> α712') - α712', L: 1 [(α717' -> α720') ~ (α713' -> α712'), [(α717' -> α720') - (α714' -> (α717' -> α720')) ~ (α712' -> (α713' -> α712')) - (α713' -> α712'), L: 0 [(α714' -> (α717' -> α720')) ~ (α712' -> (α713' -> α712')), (α714' -> (α717' -> α720')) <: (α712' -> (α713' -> α712'))]]]], α712' <: ([α794'], [α795'],)] +//│ L: 2 [list['a723'] ~ (α724' -> α781'), list['a723'] <: α721', α721' <: α722', α722' <: α720', [α720' - (α717' -> α720') ~ (α713' -> α712') - α712', L: 1 [(α717' -> α720') ~ (α713' -> α712'), [(α717' -> α720') - (α714' -> (α717' -> α720')) ~ (α712' -> (α713' -> α712')) - (α713' -> α712'), L: 0 [(α714' -> (α717' -> α720')) ~ (α712' -> (α713' -> α712')), (α714' -> (α717' -> α720')) <: (α712' -> (α713' -> α712'))]]]], [α712' - (α713' -> α712') ~ (α717' -> α720') - α720', L: 1 [(α713' -> α712') ~ (α717' -> α720'), [(α713' -> α712') - (α712' -> (α713' -> α712')) ~ (α714' -> (α717' -> α720')) - (α717' -> α720'), L: 0 [(α712' -> (α713' -> α712')) ~ (α714' -> (α717' -> α720')), (α712' -> (α713' -> α712')) :> (α714' -> (α717' -> α720'))]]]], α720' :> α722', α722' :> α721', α721' :> (α724' -> α781')] +//│ L: 1 [([α692'], [[[α598'']]],) ~ list[α614''], ([α692'], [[[α598'']]],) <: α602'', α602'' <: α616'', [α616'' - ([[α616'']], [[α618'']],) ~ ([α617''], [α633''],) - α617'', L: 0 [([[α616'']], [[α618'']],) ~ ([α617''], [α633''],), ([[α616'']], [[α618'']],) <: α634'', α634'' <: α635'', α635'' <: ([α617''], [α633''],)]], α617'' <: list[α614'']] +//│ L: 1 [([α692'], [[[α598'']]],) ~ list[α604''], ([α692'], [[[α598'']]],) <: α602'', α602'' <: α616'', [α616'' - ([[α616'']], [[α618'']],) ~ ([α617''], [α633''],) - α617'', L: 0 [([[α616'']], [[α618'']],) ~ ([α617''], [α633''],), ([[α616'']], [[α618'']],) <: α634'', α634'' <: α635'', α635'' <: ([α617''], [α633''],)]], [α617'' - ([α617''], [α633''],) ~ ([[list[α604'']]], [[α618'']],) - list[α604''], L: 0 [([α617''], [α633''],) ~ ([[list[α604'']]], [[α618'']],), ([α617''], [α633''],) :> α635'', α635'' :> α634'', α634'' :> ([[list[α604'']]], [[α618'']],)]]] +//│ L: 2 [([[int]], [[list['a792']]],) ~ list['a723'], ([[int]], [[list['a792']]],) <: α712', [α712' - (α713' -> α712') ~ (α717' -> α720') - α720', L: 1 [(α713' -> α712') ~ (α717' -> α720'), [(α713' -> α712') - (α712' -> (α713' -> α712')) ~ (α714' -> (α717' -> α720')) - (α717' -> α720'), L: 0 [(α712' -> (α713' -> α712')) ~ (α714' -> (α717' -> α720')), (α712' -> (α713' -> α712')) :> (α714' -> (α717' -> α720'))]]]], α720' :> α722', α722' :> α721', α721' :> list['a723']] +//│ L: 2 [(α724' -> α781') ~ ([α715'], [α716'],), (α724' -> α781') <: α721', α721' <: α722', α722' <: α720', [α720' - (α717' -> α720') ~ (α713' -> α712') - α712', L: 1 [(α717' -> α720') ~ (α713' -> α712'), [(α717' -> α720') - (α714' -> (α717' -> α720')) ~ (α712' -> (α713' -> α712')) - (α713' -> α712'), L: 0 [(α714' -> (α717' -> α720')) ~ (α712' -> (α713' -> α712')), (α714' -> (α717' -> α720')) <: (α712' -> (α713' -> α712'))]]]], [α712' - (α712' -> (α713' -> α712')) ~ (α714' -> (α717' -> α720')) - α714', L: 0 [(α712' -> (α713' -> α712')) ~ (α714' -> (α717' -> α720')), (α712' -> (α713' -> α712')) :> (α714' -> (α717' -> α720'))]], α714' <: ([α715'], [α716'],)] +//│ L: 2 [list['a723'] ~ ([α715'], [α716'],), list['a723'] <: α721', α721' <: α722', α722' <: α720', [α720' - (α717' -> α720') ~ (α713' -> α712') - α712', L: 1 [(α717' -> α720') ~ (α713' -> α712'), [(α717' -> α720') - (α714' -> (α717' -> α720')) ~ (α712' -> (α713' -> α712')) - (α713' -> α712'), L: 0 [(α714' -> (α717' -> α720')) ~ (α712' -> (α713' -> α712')), (α714' -> (α717' -> α720')) <: (α712' -> (α713' -> α712'))]]]], [α712' - (α712' -> (α713' -> α712')) ~ (α714' -> (α717' -> α720')) - α714', L: 0 [(α712' -> (α713' -> α712')) ~ (α714' -> (α717' -> α720')), (α712' -> (α713' -> α712')) :> (α714' -> (α717' -> α720'))]], α714' <: ([α715'], [α716'],)] +//│ L: 0 [([α692'], [[[α598'']]],) ~ list[α603''], ([α692'], [[[α598'']]],) <: α602'', α602'' <: α616'', α616'' <: list[α603'']] +//│ L: 0 [([α692'], [[[α598'']]],) ~ list[α666''], ([α692'], [[[α598'']]],) <: α602'', α602'' <: α616'', α616'' <: list[α666'']] +//│ L: 2 [(α724' -> α781') ~ ([α794'], [α795'],), (α724' -> α781') <: α721', α721' <: α722', α722' <: α720', [α720' - (α717' -> α720') ~ (α713' -> α712') - α712', L: 1 [(α717' -> α720') ~ (α713' -> α712'), [(α717' -> α720') - (α714' -> (α717' -> α720')) ~ (α712' -> (α713' -> α712')) - (α713' -> α712'), L: 0 [(α714' -> (α717' -> α720')) ~ (α712' -> (α713' -> α712')), (α714' -> (α717' -> α720')) <: (α712' -> (α713' -> α712'))]]]], α712' <: ([α794'], [α795'],)] +//│ L: 2 [list[α673'] ~ (α710' -> α711'), list[α673'] :> α672', [α672' - (α672' -> α686') ~ ([α589'] -> α692') - α589', L: 1 [(α672' -> α686') ~ ([α589'] -> α692'), [(α672' -> α686') - (α671' -> (α672' -> α686')) ~ (['a600'] -> α691') - α691', L: 0 [(α671' -> (α672' -> α686')) ~ (['a600'] -> α691'), (α671' -> (α672' -> α686')) <: mulByDigit670', mulByDigit670' <: (['a600'] -> α691')]], α691' <: ([α589'] -> α692')]], α589' <: (α710' -> α711')] +//│ L: 1 [([α692'], [[[α598'']]],) ~ list[α668''], ([α692'], [[[α598'']]],) <: α602'', α602'' <: α616'', [α616'' - ([[α616'']], [[α618'']],) ~ ([α617''], [α633''],) - α617'', L: 0 [([[α616'']], [[α618'']],) ~ ([α617''], [α633''],), ([[α616'']], [[α618'']],) <: α634'', α634'' <: α635'', α635'' <: ([α617''], [α633''],)]], [α617'' - ([α617''], [α633''],) ~ ([[α616'']], [[α618'']],) - α616'', L: 0 [([α617''], [α633''],) ~ ([[α616'']], [[α618'']],), ([α617''], [α633''],) :> α635'', α635'' :> α634'', α634'' :> ([[α616'']], [[α618'']],)]], α616'' <: list[α668'']] +//│ L: 0 [([α692'], [[[α598'']]],) ~ list[α615''], ([α692'], [[[α598'']]],) <: α602'', α602'' <: α616'', α616'' <: list[α615'']] +//│ L: 0 [(α664'' -> α655'') ~ list['a601''], (α664'' -> α655'') <: α599'', α599'' :> list['a601'']] +//│ L: 1 [([α692'], [[[α598'']]],) ~ list[α615''], ([α692'], [[[α598'']]],) <: α602'', α602'' <: α616'', [α616'' - ([[α616'']], [[α618'']],) ~ ([α617''], [α633''],) - α617'', L: 0 [([[α616'']], [[α618'']],) ~ ([α617''], [α633''],), ([[α616'']], [[α618'']],) <: α634'', α634'' <: α635'', α635'' <: ([α617''], [α633''],)]], [α617'' - ([α617''], [α633''],) ~ ([[α616'']], [[α618'']],) - α616'', L: 0 [([α617''], [α633''],) ~ ([[α616'']], [[α618'']],), ([α617''], [α633''],) :> α635'', α635'' :> α634'', α634'' :> ([[α616'']], [[α618'']],)]], α616'' <: list[α615'']] +//│ L: 0 [([α692'], [[[α598'']]],) ~ list[α668''], ([α692'], [[[α598'']]],) <: α602'', α602'' <: α616'', α616'' <: list[α668'']] ////////// file 2361 @@ -1589,7 +1589,7 @@ let rec additivePersistence n = | h::t -> if (addNumbs (h :: t)) >= 10 then false else true;; //│ [ERROR] Type `bool` does not match `int` //│ -//│ (bool) ---> (?b) ---> (?a) <--- (int) +//│ (bool) ---> (?a) ---> (?b) <--- (int) //│ //│ ◉ (bool) comes from //│ │ - l.4 | h::t -> if (addNumbs (h :: t)) >= 10 then false else true;; @@ -1597,7 +1597,7 @@ let rec additivePersistence n = //│ │ - l.4 | h::t -> if (addNumbs (h :: t)) >= 10 then false else true;; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.4 | h::t -> if (addNumbs (h :: t)) >= 10 then false else true;; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.2 match digits n with @@ -1605,7 +1605,7 @@ let rec additivePersistence n = //│ │ | [] -> 0 ... //│ │ ^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.2 match digits n with //│ │ ^^^^^^^^^^^^^^^^^^^ //│ │ | [] -> 0 ... @@ -1617,6 +1617,6 @@ let rec additivePersistence n = //│ additivePersistence: 'a -> 'b //│ where //│ 'b = bool, int -//│ U max: 6, total: 56 +//│ U max: 4, total: 50 //│ UERR 1 errors -//│ L: 0 [bool ~ int, bool <: α891', α891' <: α881', α881' :> int] +//│ L: 0 [bool ~ int, bool <: α853', α853' <: α843', α843' :> int] diff --git a/shared/src/test/diff/ocaml/OcamlDataset.mls b/shared/src/test/diff/ocaml/OcamlDataset.mls index e3fd711..dddd329 100644 --- a/shared/src/test/diff/ocaml/OcamlDataset.mls +++ b/shared/src/test/diff/ocaml/OcamlDataset.mls @@ -277,7 +277,7 @@ let bigAdd l1 l2 = //│ bigAdd: list['a] -> 'b -> list[int] //│ where //│ 'b = list[int], list['c] -//│ U max: 33, total: 666 +//│ U max: 33, total: 665 //│ UERR 6 errors //│ L: 1 [list[([α203''], [α204''],)] ~ ([α212''], [α213''],), list[([α203''], [α204''],)] <: α206'', [α206'' - (α206'' -> (α207'' -> α206'')) ~ (α208'' -> (α209'' -> [α158''])) - α208'', L: 0 [(α206'' -> (α207'' -> α206'')) ~ (α208'' -> (α209'' -> [α158''])), (α206'' -> (α207'' -> α206'')) :> (α208'' -> (α209'' -> [α158'']))]], [α208'' - (α208'' -> (α209'' -> [α158''])) ~ (α206'' -> (α207'' -> α206'')) - α206'', L: 0 [(α208'' -> (α209'' -> [α158''])) ~ (α206'' -> (α207'' -> α206'')), (α208'' -> (α209'' -> [α158''])) <: (α206'' -> (α207'' -> α206''))]], α206'' <: ([α212''], [α213''],)] //│ L: 2 [list[([α203''], [α204''],)] ~ ([[α151'']], [[α154'']],), list[([α203''], [α204''],)] <: α206'', [α206'' - (α207'' -> α206'') ~ (α209'' -> [α158'']) - α158'', L: 1 [(α207'' -> α206'') ~ (α209'' -> [α158'']), [(α207'' -> α206'') - (α206'' -> (α207'' -> α206'')) ~ (α208'' -> (α209'' -> [α158''])) - (α209'' -> [α158'']), L: 0 [(α206'' -> (α207'' -> α206'')) ~ (α208'' -> (α209'' -> [α158''])), (α206'' -> (α207'' -> α206'')) :> (α208'' -> (α209'' -> [α158'']))]]]], α158'' :> α157'', α157'' :> ([[α151'']], [[α154'']],)] @@ -564,7 +564,7 @@ let rec sumList xs = sumListHelper 0 xs;; let rec additivePersistence n = sumList digitsOfInt n;; //│ [ERROR] Type `_ list` does not match `_ -> _` //│ -//│ (_ list) ~~~~ (?b) ~~~~ (?digitsOfInt) <--- (_ -> _) +//│ (_ list) ~~~~ (?a) ~~~~ (?digitsOfInt) <--- (_ -> _) //│ //│ ◉ (_ list) comes from //│ - l.2 match xs with | [] -> total | hd::tail -> sumListHelper (total + hd) tail;; @@ -573,10 +573,10 @@ let rec additivePersistence n = sumList digitsOfInt n;; //│ ▲ - l.2 match xs with | [] -> total | hd::tail -> sumListHelper (total + hd) tail;; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?c) is assumed for +//│ ◉ (?b) is assumed for //│ - l.2 match xs with | [] -> total | hd::tail -> sumListHelper (total + hd) tail;; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (int -> ?c) comes from +//│ ◉ (int -> ?b) comes from //│ ▲ - l.2 match xs with | [] -> total | hd::tail -> sumListHelper (total + hd) tail;; //│ │ ^^^^^^^^^^^^^ //│ │ - l.1 let rec sumListHelper total xs = @@ -586,22 +586,22 @@ let rec additivePersistence n = sumList digitsOfInt n;; //│ │ - l.1 let rec sumListHelper total xs = //│ │ ^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (int -> ?a) comes from +//│ ◉ (int -> ?c) comes from //│ - l.8 let rec sumList xs = sumListHelper 0 xs;; //│ ^^^^^^^^^^^^^ -//│ ◉ (?a) is assumed for +//│ ◉ (?c) is assumed for //│ │ - l.8 let rec sumList xs = sumListHelper 0 xs;; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b -> _) comes from +//│ ◉ (?a -> _) comes from //│ - l.8 let rec sumList xs = sumListHelper 0 xs;; //│ ^^^^^^^^^^^^^^^ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ - l.8 let rec sumList xs = sumListHelper 0 xs;; //│ ^^ //│ - l.8 let rec sumList xs = sumListHelper 0 xs;; //│ ^^ -//│ ◉ (?b -> _) comes from +//│ ◉ (?a -> _) comes from //│ │ - l.8 let rec sumList xs = sumListHelper 0 xs;; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.8 let rec sumList xs = sumListHelper 0 xs;; @@ -623,12 +623,12 @@ let rec additivePersistence n = sumList digitsOfInt n;; //│ ^^^^^^^^^^^^^^^^^^^^^^^ //│ [ERROR] Type `int` does not match `_ -> _` //│ -//│ (int) ~~~~ (?a) ---> (?b) <--- (?d) ~~~~ (?c) ~~~~ (?f) ---> (_ -> _) +//│ (int) ~~~~ (?e) ---> (?b) <--- (?f) ~~~~ (?c) ~~~~ (?a) ---> (_ -> _) //│ //│ ◉ (int) comes from //│ - l.8 let rec sumList xs = sumListHelper 0 xs;; //│ ^ -//│ ◉ (int -> ?e) comes from +//│ ◉ (int -> ?d) comes from //│ ▲ - l.8 let rec sumList xs = sumListHelper 0 xs;; //│ │ ^^^^^^^^^^^^^ //│ │ - l.1 let rec sumListHelper total xs = @@ -638,12 +638,12 @@ let rec additivePersistence n = sumList digitsOfInt n;; //│ ▲ - l.1 let rec sumListHelper total xs = //│ │ ^^^^^^^^^^^^^ //│ │ -//│ ◉ (?a -> _ -> ?b) comes from +//│ ◉ (?e -> _ -> ?b) comes from //│ - l.1 let rec sumListHelper total xs = //│ ^^^^^^^^^^ //│ match xs with | [] -> total | hd::tail -> sumListHelper (total + hd) tail;; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?a) is assumed for +//│ ◉ (?e) is assumed for //│ │ - l.1 let rec sumListHelper total xs = //│ │ ^^^^^ //│ │ - l.2 match xs with | [] -> total | hd::tail -> sumListHelper (total + hd) tail;; @@ -655,10 +655,10 @@ let rec additivePersistence n = sumList digitsOfInt n;; //│ ▲ - l.2 match xs with | [] -> total | hd::tail -> sumListHelper (total + hd) tail;; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?d) is assumed for +//│ ◉ (?f) is assumed for //│ - l.2 match xs with | [] -> total | hd::tail -> sumListHelper (total + hd) tail;; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ list -> ?d) comes from +//│ ◉ (_ list -> ?f) comes from //│ ▲ - l.2 match xs with | [] -> total | hd::tail -> sumListHelper (total + hd) tail;; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ @@ -675,10 +675,10 @@ let rec additivePersistence n = sumList digitsOfInt n;; //│ │ - l.1 let rec sumListHelper total xs = //│ │ ^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (int -> ?e) comes from +//│ ◉ (int -> ?d) comes from //│ - l.8 let rec sumList xs = sumListHelper 0 xs;; //│ ^^^^^^^^^^^^^ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.8 let rec sumList xs = sumListHelper 0 xs;; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ @@ -698,10 +698,10 @@ let rec additivePersistence n = sumList digitsOfInt n;; //│ │ - l.8 let rec sumList xs = sumListHelper 0 xs;; //│ │ ^^^^^^^ //│ ▼ -//│ ◉ (_ -> ?f) comes from +//│ ◉ (_ -> ?a) comes from //│ - l.9 let rec additivePersistence n = sumList digitsOfInt n;; //│ ^^^^^^^ -//│ ◉ (?f) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.9 let rec additivePersistence n = sumList digitsOfInt n;; //│ │ ^^^^^^^^^^^^^^^^^^^ //│ ▼ @@ -713,10 +713,10 @@ let rec additivePersistence n = sumList digitsOfInt n;; //│ digitsOfInt: int -> list[int] //│ sumList: list[int] -> int //│ additivePersistence: 'a -> 'b -//│ U max: 28, total: 273 +//│ U max: 20, total: 226 //│ UERR 2 errors -//│ L: 2 [int ~ ([α460'] -> α489'), [int - ([int] -> α470') ~ (α466' -> (α463' -> α464')) - α466', L: 0 [([int] -> α470') ~ (α466' -> (α463' -> α464')), ([int] -> α470') :> sumListHelper471', sumListHelper471' :> (α466' -> (α463' -> α464'))]], α466' <: α464', α464' :> α467', [α467' - ([list['a468']] -> α467') ~ ([α462'] -> α465') - α465', L: 1 [([list['a468']] -> α467') ~ ([α462'] -> α465'), ([list['a468']] -> α467') :> α469', [α469' - ([int] -> α469') ~ ([int] -> α470') - α470', L: 0 [([int] -> α469') ~ ([int] -> α470'), ([int] -> α469') :> sumListHelper471', sumListHelper471' <: ([int] -> α470')]], α470' <: ([α462'] -> α465')]], [α465' - (α462' -> α465') ~ ([digitsOfInt472'] -> α488') - α488', L: 0 [(α462' -> α465') ~ ([digitsOfInt472'] -> α488'), (α462' -> α465') <: sumList461', sumList461' <: ([digitsOfInt472'] -> α488')]], α488' <: ([α460'] -> α489')] -//│ L: 2 [list['a468'] ~ (α473' -> α484'), [list['a468'] - ([list['a468']] -> α467') ~ ([α462'] -> α465') - α462', L: 1 [([list['a468']] -> α467') ~ ([α462'] -> α465'), ([list['a468']] -> α467') :> α469', [α469' - ([int] -> α469') ~ ([int] -> α470') - α470', L: 0 [([int] -> α469') ~ ([int] -> α470'), ([int] -> α469') :> sumListHelper471', sumListHelper471' <: ([int] -> α470')]], α470' <: ([α462'] -> α465')]], [α462' - (α462' -> α465') ~ ([digitsOfInt472'] -> α488') - digitsOfInt472', L: 0 [(α462' -> α465') ~ ([digitsOfInt472'] -> α488'), (α462' -> α465') <: sumList461', sumList461' <: ([digitsOfInt472'] -> α488')]], digitsOfInt472' :> (α473' -> α484')] +//│ L: 2 [int ~ ([α452'] -> α477'), [int - ([int] -> α462') ~ (α458' -> (α455' -> α456')) - α458', L: 0 [([int] -> α462') ~ (α458' -> (α455' -> α456')), ([int] -> α462') :> sumListHelper463', sumListHelper463' :> (α458' -> (α455' -> α456'))]], α458' <: α456', α456' :> α459', [α459' - ([list['a460']] -> α459') ~ ([α454'] -> α457') - α457', L: 1 [([list['a460']] -> α459') ~ ([α454'] -> α457'), ([list['a460']] -> α459') :> α461', [α461' - ([int] -> α461') ~ ([int] -> α462') - α462', L: 0 [([int] -> α461') ~ ([int] -> α462'), ([int] -> α461') :> sumListHelper463', sumListHelper463' <: ([int] -> α462')]], α462' <: ([α454'] -> α457')]], [α457' - (α454' -> α457') ~ ([digitsOfInt464'] -> α476') - α476', L: 0 [(α454' -> α457') ~ ([digitsOfInt464'] -> α476'), (α454' -> α457') <: sumList453', sumList453' <: ([digitsOfInt464'] -> α476')]], α476' <: ([α452'] -> α477')] +//│ L: 2 [list['a460'] ~ (α465' -> α475'), [list['a460'] - ([list['a460']] -> α459') ~ ([α454'] -> α457') - α454', L: 1 [([list['a460']] -> α459') ~ ([α454'] -> α457'), ([list['a460']] -> α459') :> α461', [α461' - ([int] -> α461') ~ ([int] -> α462') - α462', L: 0 [([int] -> α461') ~ ([int] -> α462'), ([int] -> α461') :> sumListHelper463', sumListHelper463' <: ([int] -> α462')]], α462' <: ([α454'] -> α457')]], [α454' - (α454' -> α457') ~ ([digitsOfInt464'] -> α476') - digitsOfInt464', L: 0 [(α454' -> α457') ~ ([digitsOfInt464'] -> α476'), (α454' -> α457') <: sumList453', sumList453' <: ([digitsOfInt464'] -> α476')]], digitsOfInt464' :> (α465' -> α475')] // file 8776 // TODO list indexing here. skip this example? @@ -764,38 +764,38 @@ let rec matchHeads x = //│ ║ l.730: if (getHeads (explode x)) = [] //│ ╙── ^^^^^^^ //│ matchHeads: 'a -> bool -//│ U max: 20, total: 272 +//│ U max: 10, total: 205 //│ UERR 2 errors -//│ L: 0 [err ~ ([α536'] -> α537'), err <: ([α536'] -> α537')] -//│ L: 0 [err ~ ([α536'] -> α557'), err <: ([α536'] -> α557')] +//│ L: 0 [err ~ ([α516'] -> α517'), err <: ([α516'] -> α517')] +//│ L: 0 [err ~ ([α516'] -> α533'), err <: ([α516'] -> α533')] // TODO: parse correctly let explode s = let rec go i = if i >= (String.length s) then [] else (s.[i]) :: (go (i + 1)) in go 0;; -//│ [ERROR] Type `err` does not match `_ list -> _` +//│ [ERROR] Type `err` does not match `_ -> _` //│ -//│ (err) ---> (_ list -> _) +//│ (err) ---> (_ -> _) //│ //│ ◉ (err) comes from //│ │ - l.3 if i >= (String.length s) then [] else (s.[i]) :: (go (i + 1)) in -//│ │ ^^ +//│ │ ^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (_ list -> _) comes from +//│ ◉ (_ -> _) comes from //│ - l.3 if i >= (String.length s) then [] else (s.[i]) :: (go (i + 1)) in -//│ ^^ -//│ [ERROR] Type `err` does not match `_ -> _` +//│ ^^^^^^^^^^^^^ +//│ [ERROR] Type `err` does not match `_ list -> _` //│ -//│ (err) ---> (_ -> _) +//│ (err) ---> (_ list -> _) //│ //│ ◉ (err) comes from //│ │ - l.3 if i >= (String.length s) then [] else (s.[i]) :: (go (i + 1)) in -//│ │ ^^^^^^^^^^^^^ +//│ │ ^^ //│ ▼ -//│ ◉ (_ -> _) comes from +//│ ◉ (_ list -> _) comes from //│ - l.3 if i >= (String.length s) then [] else (s.[i]) :: (go (i + 1)) in -//│ ^^^^^^^^^^^^^ +//│ ^^ //│ ╔══[ERROR] identifier not found: String.length //│ ║ //│ ║ l.775: if i >= (String.length s) then [] else (s.[i]) :: (go (i + 1)) in @@ -804,11 +804,11 @@ let explode s = //│ ║ //│ ║ l.775: if i >= (String.length s) then [] else (s.[i]) :: (go (i + 1)) in //│ ╙── ^^ -//│ explode: 'b -> list['a] -//│ U max: 7, total: 73 +//│ explode: 'a -> list['b] +//│ U max: 6, total: 56 //│ UERR 2 errors -//│ L: 0 [err ~ ([α597'] -> α601''), err <: ([α597'] -> α601'')] -//│ L: 0 [err ~ ([list['a605'']] -> α607''), err <: ([list['a605'']] -> α607'')] +//│ L: 0 [err ~ (list[[α567'']] -> α573''), err <: (list[[α567'']] -> α573'')] +//│ L: 0 [err ~ ([α565'] -> α569''), err <: ([α565'] -> α569'')] // file 89 // TODO: parse properly @@ -837,7 +837,7 @@ let rec additivePersistence n = | h::t -> if (addNumbs (h :: t)) >= 10 then false else true;; //│ [ERROR] Type `bool` does not match `int` //│ -//│ (bool) ---> (?a) ---> (?b) <--- (int) +//│ (bool) ---> (?b) ---> (?a) <--- (int) //│ //│ ◉ (bool) comes from //│ │ - l.8 | h::t -> if (addNumbs (h :: t)) >= 10 then false else true;; @@ -845,7 +845,7 @@ let rec additivePersistence n = //│ │ - l.8 | h::t -> if (addNumbs (h :: t)) >= 10 then false else true;; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.8 | h::t -> if (addNumbs (h :: t)) >= 10 then false else true;; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.6 match digits n with @@ -853,7 +853,7 @@ let rec additivePersistence n = //│ │ | [] -> 0 ... //│ │ ^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.6 match digits n with //│ │ ^^^^^^^^^^^^^^^^^^^ //│ │ | [] -> 0 ... @@ -868,9 +868,9 @@ let rec additivePersistence n = //│ additivePersistence: 'a -> 'b //│ where //│ 'b = bool, int -//│ U max: 6, total: 137 +//│ U max: 5, total: 115 //│ UERR 1 errors -//│ L: 0 [bool ~ int, bool <: α677', α677' <: α667', α667' :> int] +//│ L: 0 [bool ~ int, bool <: α635', α635' <: α625', α625' :> int] // file 358 mod @@ -967,9 +967,9 @@ let rec build (rand,depth) = //│ 'build = (float -> int, int,) -> () -> expr, expr //│ U max: 3, total: 31 //│ UERR 3 errors -//│ L: 0 [(([α683'], [α684'],) -> α686') ~ expr, (([α683'], [α684'],) -> α686') <: build682', build682' <: α693', α693' :> build682', build682' <: α691', α691' <: expr] -//│ L: 0 [expr ~ (([[α683']], [[int]],) -> α692'), expr <: (([[α683']], [[int]],) -> α692')] -//│ L: 0 [expr ~ (([[α683']], [[int]],) -> α694'), expr <: (([[α683']], [[int]],) -> α694')] +//│ L: 0 [expr ~ (([[α641']], [[int]],) -> α650'), expr <: (([[α641']], [[int]],) -> α650')] +//│ L: 0 [(([α641'], [α642'],) -> α644') ~ expr, (([α641'], [α642'],) -> α644') <: build640', build640' <: α651', α651' :> build640', build640' <: α649', α649' <: expr] +//│ L: 0 [expr ~ (([[α641']], [[int]],) -> α652'), expr <: (([[α641']], [[int]],) -> α652')] // TODO file 1337 in separate file to avoid collisions @@ -1002,11 +1002,11 @@ let rec mulByDigit i l = //│ ◉ (int) comes from //│ - lib. let ( * ): int -> int -> int //│ ^^^ -//│ [ERROR] Type `_ list` does not match `int` +//│ [ERROR] Type `(int * int * int) list` does not match `int` //│ -//│ (_ list) ---> (?a) ---> (int) +//│ ((int * int * int) list) ---> (?a) ---> (int) //│ -//│ ◉ (_ list) comes from +//│ ◉ ((int * int * int) list) comes from //│ │ - l.3 let y = [1, 2, 3];; //│ │ ^^^^^^^^^ //│ │ - l.7 | h::t -> [remainder x y] @ (mulByDigit i t);; @@ -1027,10 +1027,10 @@ let rec mulByDigit i l = //│ x: 'a -> list[int] -> list[string] //│ y: list[(int, int, int,)] //│ mulByDigit: 'b -> list['a] -> list[int] -//│ U max: 7, total: 85 +//│ U max: 5, total: 55 //│ UERR 2 errors -//│ L: 0 [list['a723'] ~ int, list['a723'] <: α718', α718' <: int] -//│ L: 0 [(α720' -> [(list[α721'] -> list[α722'])]) ~ int, (α720' -> [(list[α721'] -> list[α722'])]) <: α717', α717' <: int] +//│ L: 0 [list[([[int]], [[int]], [[int]],)] ~ int, list[([[int]], [[int]], [[int]],)] <: α672', α672' <: int] +//│ L: 0 [(α674' -> [(list[α675'] -> list[α676'])]) ~ int, (α674' -> [(list[α675'] -> list[α676'])]) <: α671', α671' <: int] // file 344 mod @@ -1042,19 +1042,19 @@ let padZero l1 l2 = else (clone 0 (padLength l1 l2)) l2;; //│ [ERROR] Type `_ list` does not match `_ -> _` //│ -//│ (_ list) ---> (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?b) ---> (_ -> _) +//│ (_ list) ---> (?d) ~~~~ (?c) ~~~~ (?d) ~~~~ (?c) ~~~~ (?b) ---> (_ -> _) //│ //│ ◉ (_ list) comes from //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; -//│ │ ^^^^^^^^^^^^^^^^^^^^^^ +//│ │ ^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?e) comes from +//│ ◉ (_ -> ?d) comes from //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> _ -> ?e) comes from +//│ ◉ (_ -> _ -> ?d) comes from //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; @@ -1064,10 +1064,10 @@ let padZero l1 l2 = //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ ▼ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?a) comes from //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^ -//│ ◉ (?d) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^^^ //│ ▼ @@ -1081,10 +1081,10 @@ let padZero l1 l2 = //│ ▲ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^^^ //│ │ -//│ ◉ (?d) is assumed for +//│ ◉ (?a) is assumed for //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?a) comes from //│ ▲ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; @@ -1094,13 +1094,13 @@ let padZero l1 l2 = //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ ▼ -//│ ◉ (int -> ?a) comes from +//│ ◉ (int -> ?e) comes from //│ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ ^^^^^ -//│ ◉ (?a) is assumed for +//│ ◉ (?e) is assumed for //│ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ ^^^^^^^ -//│ ◉ (int -> ?a) comes from +//│ ◉ (int -> ?e) comes from //│ ▲ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ │ ^^^^^ //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; @@ -1110,19 +1110,19 @@ let padZero l1 l2 = //│ ▲ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ │ -//│ ◉ (_ -> _ -> ?e) comes from +//│ ◉ (_ -> _ -> ?d) comes from //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?e) comes from +//│ ◉ (_ -> ?d) comes from //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?e) comes from +//│ ◉ (_ -> ?d) comes from //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> _ -> ?e) comes from +//│ ◉ (_ -> _ -> ?d) comes from //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; @@ -1132,13 +1132,13 @@ let padZero l1 l2 = //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ ▼ -//│ ◉ (int -> ?a) comes from +//│ ◉ (int -> ?e) comes from //│ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ ^^^^^ -//│ ◉ (?a) is assumed for +//│ ◉ (?e) is assumed for //│ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ ^^^^^^^ -//│ ◉ (int -> ?a) comes from +//│ ◉ (int -> ?e) comes from //│ ▲ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ │ ^^^^^ //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; @@ -1148,10 +1148,10 @@ let padZero l1 l2 = //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ ▼ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?a) comes from //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^ -//│ ◉ (?d) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^^^ //│ ▼ @@ -1165,10 +1165,10 @@ let padZero l1 l2 = //│ ▲ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^^^ //│ │ -//│ ◉ (?d) is assumed for +//│ ◉ (?a) is assumed for //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?a) comes from //│ ▲ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; @@ -1178,10 +1178,10 @@ let padZero l1 l2 = //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ ▼ -//│ ◉ (int -> ?a) comes from +//│ ◉ (int -> ?e) comes from //│ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ ^^^^^ -//│ ◉ (?a) is assumed for +//│ ◉ (?e) is assumed for //│ │ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ │ ^^^^^^^ //│ ▼ @@ -1197,19 +1197,19 @@ let padZero l1 l2 = //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ [ERROR] Type `_ list` does not match `_ -> _` //│ -//│ (_ list) ---> (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?b) ---> (_ -> _) +//│ (_ list) ---> (?d) ~~~~ (?c) ~~~~ (?d) ~~~~ (?c) ~~~~ (?b) ---> (_ -> _) //│ //│ ◉ (_ list) comes from //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; -//│ │ ^^ +//│ │ ^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?e) comes from +//│ ◉ (_ -> ?d) comes from //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> _ -> ?e) comes from +//│ ◉ (_ -> _ -> ?d) comes from //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; @@ -1219,10 +1219,10 @@ let padZero l1 l2 = //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ ▼ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?a) comes from //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^ -//│ ◉ (?d) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^^^ //│ ▼ @@ -1236,10 +1236,10 @@ let padZero l1 l2 = //│ ▲ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^^^ //│ │ -//│ ◉ (?d) is assumed for +//│ ◉ (?a) is assumed for //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?a) comes from //│ ▲ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; @@ -1249,13 +1249,13 @@ let padZero l1 l2 = //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ ▼ -//│ ◉ (int -> ?a) comes from +//│ ◉ (int -> ?e) comes from //│ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ ^^^^^ -//│ ◉ (?a) is assumed for +//│ ◉ (?e) is assumed for //│ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ ^^^^^^^ -//│ ◉ (int -> ?a) comes from +//│ ◉ (int -> ?e) comes from //│ ▲ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ │ ^^^^^ //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; @@ -1265,19 +1265,19 @@ let padZero l1 l2 = //│ ▲ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ │ -//│ ◉ (_ -> _ -> ?e) comes from +//│ ◉ (_ -> _ -> ?d) comes from //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?e) comes from +//│ ◉ (_ -> ?d) comes from //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?e) comes from +//│ ◉ (_ -> ?d) comes from //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> _ -> ?e) comes from +//│ ◉ (_ -> _ -> ?d) comes from //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; @@ -1287,13 +1287,13 @@ let padZero l1 l2 = //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ ▼ -//│ ◉ (int -> ?a) comes from +//│ ◉ (int -> ?e) comes from //│ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ ^^^^^ -//│ ◉ (?a) is assumed for +//│ ◉ (?e) is assumed for //│ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ ^^^^^^^ -//│ ◉ (int -> ?a) comes from +//│ ◉ (int -> ?e) comes from //│ ▲ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ │ ^^^^^ //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; @@ -1303,10 +1303,10 @@ let padZero l1 l2 = //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ ▼ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?a) comes from //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^ -//│ ◉ (?d) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^^^ //│ ▼ @@ -1320,10 +1320,10 @@ let padZero l1 l2 = //│ ▲ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^^^ //│ │ -//│ ◉ (?d) is assumed for +//│ ◉ (?a) is assumed for //│ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ ^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?a) comes from //│ ▲ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; @@ -1333,10 +1333,10 @@ let padZero l1 l2 = //│ │ - l.1 let rec clone x n = if n > 0 then x :: (clone x (n - 1)) else [];; //│ │ ^^^^^ //│ ▼ -//│ ◉ (int -> ?a) comes from +//│ ◉ (int -> ?e) comes from //│ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ ^^^^^ -//│ ◉ (?a) is assumed for +//│ ◉ (?e) is assumed for //│ │ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ │ ^^^^^^^ //│ ▼ @@ -1350,15 +1350,13 @@ let padZero l1 l2 = //│ ◉ (_ -> _) comes from //│ - l.6 else (clone 0 (padLength l1 l2)) l2;; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ clone: 'b -> int -> 'c -//│ where -//│ 'c = list['b], list['a] +//│ clone: 'a -> int -> list['a] //│ padLength: list['a] -> list['b] -> int //│ padZero: list[list[int]] -> list['a] -> list[list[int]] //│ U max: 11, total: 195 //│ UERR 2 errors -//│ L: 2 [list['a776'] ~ ([α752'] -> α788'), list['a776'] <: α777', [α777' - (α779' -> α777') ~ ([int] -> α778') - α778', L: 1 [(α779' -> α777') ~ ([int] -> α778'), [(α779' -> α777') - (α774' -> (α779' -> α777')) ~ ([α774'] -> α780') - α780', L: 0 [(α774' -> (α779' -> α777')) ~ ([α774'] -> α780'), (α774' -> (α779' -> α777')) <: clone773', clone773' <: ([α774'] -> α780')]], α780' <: ([int] -> α778')]], [α778' - ([int] -> α778') ~ (α779' -> α777') - α777', L: 1 [([int] -> α778') ~ (α779' -> α777'), ([int] -> α778') :> α780', [α780' - ([α774'] -> α780') ~ ([int] -> α782') - α782', L: 0 [([α774'] -> α780') ~ ([int] -> α782'), ([α774'] -> α780') :> clone773', clone773' <: ([int] -> α782')]], [α782' - ([int] -> α782') ~ (α774' -> (α779' -> α777')) - (α779' -> α777'), L: 0 [([int] -> α782') ~ (α774' -> (α779' -> α777')), ([int] -> α782') :> clone773', clone773' :> (α774' -> (α779' -> α777'))]]]], [α777' - (α779' -> α777') ~ ([int] -> α778') - α778', L: 1 [(α779' -> α777') ~ ([int] -> α778'), [(α779' -> α777') - (α774' -> (α779' -> α777')) ~ ([int] -> α782') - α782', L: 0 [(α774' -> (α779' -> α777')) ~ ([int] -> α782'), (α774' -> (α779' -> α777')) <: clone773', clone773' <: ([int] -> α782')]], [α782' - ([int] -> α782') ~ ([α774'] -> α780') - α780', L: 0 [([int] -> α782') ~ ([α774'] -> α780'), ([int] -> α782') :> clone773', clone773' <: ([α774'] -> α780')]], α780' <: ([int] -> α778')]], [α778' - ([int] -> α778') ~ ([[int]] -> α787') - α787', L: 1 [([int] -> α778') ~ ([[int]] -> α787'), ([int] -> α778') :> α780', [α780' - ([α774'] -> α780') ~ ([int] -> α782') - α782', L: 0 [([α774'] -> α780') ~ ([int] -> α782'), ([α774'] -> α780') :> clone773', clone773' <: ([int] -> α782')]], α782' <: ([[int]] -> α787')]], α787' <: ([α752'] -> α788')] -//│ L: 2 [list['a775'] ~ ([α752'] -> α788'), list['a775'] <: α777', [α777' - (α779' -> α777') ~ ([int] -> α778') - α778', L: 1 [(α779' -> α777') ~ ([int] -> α778'), [(α779' -> α777') - (α774' -> (α779' -> α777')) ~ ([α774'] -> α780') - α780', L: 0 [(α774' -> (α779' -> α777')) ~ ([α774'] -> α780'), (α774' -> (α779' -> α777')) <: clone773', clone773' <: ([α774'] -> α780')]], α780' <: ([int] -> α778')]], [α778' - ([int] -> α778') ~ (α779' -> α777') - α777', L: 1 [([int] -> α778') ~ (α779' -> α777'), ([int] -> α778') :> α780', [α780' - ([α774'] -> α780') ~ ([int] -> α782') - α782', L: 0 [([α774'] -> α780') ~ ([int] -> α782'), ([α774'] -> α780') :> clone773', clone773' <: ([int] -> α782')]], [α782' - ([int] -> α782') ~ (α774' -> (α779' -> α777')) - (α779' -> α777'), L: 0 [([int] -> α782') ~ (α774' -> (α779' -> α777')), ([int] -> α782') :> clone773', clone773' :> (α774' -> (α779' -> α777'))]]]], [α777' - (α779' -> α777') ~ ([int] -> α778') - α778', L: 1 [(α779' -> α777') ~ ([int] -> α778'), [(α779' -> α777') - (α774' -> (α779' -> α777')) ~ ([int] -> α782') - α782', L: 0 [(α774' -> (α779' -> α777')) ~ ([int] -> α782'), (α774' -> (α779' -> α777')) <: clone773', clone773' <: ([int] -> α782')]], [α782' - ([int] -> α782') ~ ([α774'] -> α780') - α780', L: 0 [([int] -> α782') ~ ([α774'] -> α780'), ([int] -> α782') :> clone773', clone773' <: ([α774'] -> α780')]], α780' <: ([int] -> α778')]], [α778' - ([int] -> α778') ~ ([[int]] -> α787') - α787', L: 1 [([int] -> α778') ~ ([[int]] -> α787'), ([int] -> α778') :> α780', [α780' - ([α774'] -> α780') ~ ([int] -> α782') - α782', L: 0 [([α774'] -> α780') ~ ([int] -> α782'), ([α774'] -> α780') :> clone773', clone773' <: ([int] -> α782')]], α782' <: ([[int]] -> α787')]], α787' <: ([α752'] -> α788')] +//│ L: 2 [list[[α724']] ~ ([α702'] -> α738'), list[[α724']] <: α726', [α726' - (α728' -> α726') ~ ([int] -> α727') - α727', L: 1 [(α728' -> α726') ~ ([int] -> α727'), [(α728' -> α726') - (α724' -> (α728' -> α726')) ~ ([α724'] -> α729') - α729', L: 0 [(α724' -> (α728' -> α726')) ~ ([α724'] -> α729'), (α724' -> (α728' -> α726')) <: clone723', clone723' <: ([α724'] -> α729')]], α729' <: ([int] -> α727')]], [α727' - ([int] -> α727') ~ (α728' -> α726') - α726', L: 1 [([int] -> α727') ~ (α728' -> α726'), ([int] -> α727') :> α729', [α729' - ([α724'] -> α729') ~ ([int] -> α732') - α732', L: 0 [([α724'] -> α729') ~ ([int] -> α732'), ([α724'] -> α729') :> clone723', clone723' <: ([int] -> α732')]], [α732' - ([int] -> α732') ~ (α724' -> (α728' -> α726')) - (α728' -> α726'), L: 0 [([int] -> α732') ~ (α724' -> (α728' -> α726')), ([int] -> α732') :> clone723', clone723' :> (α724' -> (α728' -> α726'))]]]], [α726' - (α728' -> α726') ~ ([int] -> α727') - α727', L: 1 [(α728' -> α726') ~ ([int] -> α727'), [(α728' -> α726') - (α724' -> (α728' -> α726')) ~ ([int] -> α732') - α732', L: 0 [(α724' -> (α728' -> α726')) ~ ([int] -> α732'), (α724' -> (α728' -> α726')) <: clone723', clone723' <: ([int] -> α732')]], [α732' - ([int] -> α732') ~ ([α724'] -> α729') - α729', L: 0 [([int] -> α732') ~ ([α724'] -> α729'), ([int] -> α732') :> clone723', clone723' <: ([α724'] -> α729')]], α729' <: ([int] -> α727')]], [α727' - ([int] -> α727') ~ ([[int]] -> α737') - α737', L: 1 [([int] -> α727') ~ ([[int]] -> α737'), ([int] -> α727') :> α729', [α729' - ([α724'] -> α729') ~ ([int] -> α732') - α732', L: 0 [([α724'] -> α729') ~ ([int] -> α732'), ([α724'] -> α729') :> clone723', clone723' <: ([int] -> α732')]], α732' <: ([[int]] -> α737')]], α737' <: ([α702'] -> α738')] +//│ L: 2 [list['a725'] ~ ([α702'] -> α738'), list['a725'] <: α726', [α726' - (α728' -> α726') ~ ([int] -> α727') - α727', L: 1 [(α728' -> α726') ~ ([int] -> α727'), [(α728' -> α726') - (α724' -> (α728' -> α726')) ~ ([α724'] -> α729') - α729', L: 0 [(α724' -> (α728' -> α726')) ~ ([α724'] -> α729'), (α724' -> (α728' -> α726')) <: clone723', clone723' <: ([α724'] -> α729')]], α729' <: ([int] -> α727')]], [α727' - ([int] -> α727') ~ (α728' -> α726') - α726', L: 1 [([int] -> α727') ~ (α728' -> α726'), ([int] -> α727') :> α729', [α729' - ([α724'] -> α729') ~ ([int] -> α732') - α732', L: 0 [([α724'] -> α729') ~ ([int] -> α732'), ([α724'] -> α729') :> clone723', clone723' <: ([int] -> α732')]], [α732' - ([int] -> α732') ~ (α724' -> (α728' -> α726')) - (α728' -> α726'), L: 0 [([int] -> α732') ~ (α724' -> (α728' -> α726')), ([int] -> α732') :> clone723', clone723' :> (α724' -> (α728' -> α726'))]]]], [α726' - (α728' -> α726') ~ ([int] -> α727') - α727', L: 1 [(α728' -> α726') ~ ([int] -> α727'), [(α728' -> α726') - (α724' -> (α728' -> α726')) ~ ([int] -> α732') - α732', L: 0 [(α724' -> (α728' -> α726')) ~ ([int] -> α732'), (α724' -> (α728' -> α726')) <: clone723', clone723' <: ([int] -> α732')]], [α732' - ([int] -> α732') ~ ([α724'] -> α729') - α729', L: 0 [([int] -> α732') ~ ([α724'] -> α729'), ([int] -> α732') :> clone723', clone723' <: ([α724'] -> α729')]], α729' <: ([int] -> α727')]], [α727' - ([int] -> α727') ~ ([[int]] -> α737') - α737', L: 1 [([int] -> α727') ~ ([[int]] -> α737'), ([int] -> α727') :> α729', [α729' - ([α724'] -> α729') ~ ([int] -> α732') - α732', L: 0 [([α724'] -> α729') ~ ([int] -> α732'), ([α724'] -> α729') :> clone723', clone723' <: ([int] -> α732')]], α732' <: ([[int]] -> α737')]], α737' <: ([α702'] -> α738')] // file 2736 [TODO different part of file has errors] let rec addHelper (t,u) = @@ -1392,7 +1390,7 @@ let bigMul l1 l2 = //│ (_ -> _) ---> (?a) <--- (_ list) //│ //│ ◉ (_ -> _) comes from -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^^^ //│ │ let add (l1,l2) = ... //│ │ ^^^^^^^^^^^^^^^^^^^^^ @@ -1415,21 +1413,21 @@ let bigMul l1 l2 = //│ ◉ (_ * _) comes from //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ //│ ▼ //│ ◉ (?b) is assumed for -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^ -//│ │ - l.-1371let padZero l1 l2 = +//│ │ - l.-1369let padZero l1 l2 = //│ │ ^^ //│ ▼ //│ ◉ (?a) is assumed for -//│ │ - l.-1371let padZero l1 l2 = +//│ │ - l.-1369let padZero l1 l2 = //│ │ ^^ -//│ │ - l.-1370 let diff = (List.length l1) - (List.length l2) in +//│ │ - l.-1368 let diff = (List.length l1) - (List.length l2) in //│ │ ^^ //│ ▼ //│ ◉ (_ list) comes from @@ -1442,21 +1440,21 @@ let bigMul l1 l2 = //│ ◉ (_ * _) comes from //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ //│ ▼ //│ ◉ (?b) is assumed for -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^ -//│ │ - l.-1371let padZero l1 l2 = +//│ │ - l.-1369let padZero l1 l2 = //│ │ ^^ //│ ▼ //│ ◉ (?a) is assumed for -//│ │ - l.-1371let padZero l1 l2 = +//│ │ - l.-1369let padZero l1 l2 = //│ │ ^^ -//│ │ - l.-1368 then (((clone 0 (-1 * diff)) @ l1), l2) +//│ │ - l.-1366 then (((clone 0 (-1 * diff)) @ l1), l2) //│ │ ^^ //│ ▼ //│ ◉ (_ list) comes from @@ -1464,52 +1462,52 @@ let bigMul l1 l2 = //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?b) ---> (?d) ~~~~ (?c) ---> (_ list) +//│ (_ * _) ---> (?e) ---> (?b) ~~~~ (?a) ---> (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.-1364let bigAdd l1 l2 = +//│ ◉ (?e) is assumed for +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^ //│ ▼ -//│ ◉ (?d) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?b) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?d * _ list) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?b * _ list) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?c) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for -//│ │ - l.-1369 if diff < 0 +//│ ◉ (?d) is assumed for +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c * _) comes from -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ - l.-1361 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?c) is assumed for -//│ │ - l.-1363 let add (l1,l2) = +//│ ◉ (?a) is assumed for +//│ │ - l.-1361 let add (l1,l2) = //│ │ ^^ -//│ │ - l.-1361 let base = List.combine l1 l2 in +//│ │ - l.-1359 let base = List.combine l1 l2 in //│ │ ^^ //│ ▼ //│ ◉ (_ list) comes from @@ -1517,60 +1515,60 @@ let bigMul l1 l2 = //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?b) ---> (?d) ~~~~ (?c) ---> (?e) ---> (_ list) +//│ (_ * _) ---> (?e) ---> (?b) ~~~~ (?a) ---> (?f) ---> (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.-1364let bigAdd l1 l2 = +//│ ◉ (?e) is assumed for +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^ //│ ▼ -//│ ◉ (?d) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?b) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?d * _ list) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?b * _ list) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?c) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?f) is assumed for -//│ │ - l.-1369 if diff < 0 +//│ ◉ (?d) is assumed for +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c * _) comes from -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ - l.-1361 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?c) is assumed for -//│ │ - l.-1363 let add (l1,l2) = +//│ ◉ (?a) is assumed for +//│ │ - l.-1361 let add (l1,l2) = //│ │ ^^ -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^ -//│ │ - l.-1371let padZero l1 l2 = +//│ │ - l.-1369let padZero l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?e) is assumed for -//│ │ - l.-1371let padZero l1 l2 = +//│ ◉ (?f) is assumed for +//│ │ - l.-1369let padZero l1 l2 = //│ │ ^^ -//│ │ - l.-1370 let diff = (List.length l1) - (List.length l2) in +//│ │ - l.-1368 let diff = (List.length l1) - (List.length l2) in //│ │ ^^ //│ ▼ //│ ◉ (_ list) comes from @@ -1578,232 +1576,232 @@ let bigMul l1 l2 = //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?b) ---> (?d) ~~~~ (?c) ~~~~ (_ list) +//│ (_ * _) ---> (?e) ---> (?b) ~~~~ (?a) ~~~~ (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.-1364let bigAdd l1 l2 = +//│ ◉ (?e) is assumed for +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^ //│ ▼ -//│ ◉ (?d) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?b) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?d * _ list) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?b * _ list) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?c) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for -//│ │ - l.-1369 if diff < 0 +//│ ◉ (?d) is assumed for +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c * _) comes from -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ - l.-1361 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?c) is assumed for -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a) is assumed for +//│ - l.-1361 let add (l1,l2) = //│ ^^ -//│ ◉ (?c * _) comes from -//│ ▲ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ ▲ - l.-1361 let add (l1,l2) = //│ │ ^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for -//│ ▲ - l.-1369 if diff < 0 +//│ ◉ (?d) is assumed for +//│ ▲ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ //│ ◉ (_ list * _) comes from -//│ - l.-1368 then (((clone 0 (-1 * diff)) @ l1), l2) +//│ - l.-1366 then (((clone 0 (-1 * diff)) @ l1), l2) //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ◉ (_ list) comes from -//│ - l.-1368 then (((clone 0 (-1 * diff)) @ l1), l2) +//│ - l.-1366 then (((clone 0 (-1 * diff)) @ l1), l2) //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ - lib. let (@): 'a list -> 'a list -> 'a list //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?b) ---> (?g) ~~~~ (?d) ---> (?e) ~~~~ (_ list) +//│ (_ * _) ---> (?f) ---> (?c) ~~~~ (?a) ---> (?g) ~~~~ (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.-1364let bigAdd l1 l2 = +//│ ◉ (?f) is assumed for +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^ //│ ▼ -//│ ◉ (?g) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?c) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?g * _ list) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?c * _ list) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?d) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?f) is assumed for -//│ │ - l.-1369 if diff < 0 +//│ ◉ (?e) is assumed for +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?d * _) comes from -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ - l.-1361 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ │ - l.-1363 let add (l1,l2) = +//│ ◉ (?a) is assumed for +//│ │ - l.-1361 let add (l1,l2) = //│ │ ^^ -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^ //│ ▼ -//│ ◉ (?e) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?g) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?e * _) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?g * _) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?h) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?h) is assumed for -//│ ▲ - l.-1369 if diff < 0 +//│ ◉ (?b) is assumed for +//│ ▲ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ //│ ◉ (_ list * _) comes from -//│ - l.-1368 then (((clone 0 (-1 * diff)) @ l1), l2) +//│ - l.-1366 then (((clone 0 (-1 * diff)) @ l1), l2) //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ◉ (_ list) comes from -//│ - l.-1368 then (((clone 0 (-1 * diff)) @ l1), l2) +//│ - l.-1366 then (((clone 0 (-1 * diff)) @ l1), l2) //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ - lib. let (@): 'a list -> 'a list -> 'a list //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?b) ---> (?d) ~~~~ (?c) ~~~~ (?d) ---> (_ list) +//│ (_ * _) ---> (?e) ---> (?b) ~~~~ (?a) ~~~~ (?b) ---> (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.-1364let bigAdd l1 l2 = +//│ ◉ (?e) is assumed for +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^ //│ ▼ -//│ ◉ (?d) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?b) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?d * _ list) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?b * _ list) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?c) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for -//│ │ - l.-1369 if diff < 0 +//│ ◉ (?d) is assumed for +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c * _) comes from -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ - l.-1361 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?c) is assumed for -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a) is assumed for +//│ - l.-1361 let add (l1,l2) = //│ ^^ -//│ ◉ (?c * _) comes from -//│ ▲ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ ▲ - l.-1361 let add (l1,l2) = //│ │ ^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for -//│ ▲ - l.-1369 if diff < 0 +//│ ◉ (?d) is assumed for +//│ ▲ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?a) is assumed for -//│ ▲ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?c) is assumed for +//│ ▲ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?d * _ list) comes from -//│ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?b * _ list) comes from +//│ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?d) is assumed for -//│ │ - l.-1371let padZero l1 l2 = +//│ ◉ (?b) is assumed for +//│ │ - l.-1369let padZero l1 l2 = //│ │ ^^ -//│ │ - l.-1370 let diff = (List.length l1) - (List.length l2) in +//│ │ - l.-1368 let diff = (List.length l1) - (List.length l2) in //│ │ ^^ //│ ▼ //│ ◉ (_ list) comes from @@ -1864,7 +1862,7 @@ let bigMul l1 l2 = //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ //│ ◉ (_ -> _) comes from -//│ - l.-1364let bigAdd l1 l2 = +//│ - l.-1362let bigAdd l1 l2 = //│ ^^^^ //│ let add (l1,l2) = ... //│ ^^^^^^^^^^^^^^^^^^^^^ @@ -1928,7 +1926,7 @@ let bigMul l1 l2 = //│ (_ -> _) ---> (?b) ---> (?c) ---> (?a) ~~~~ (?d) ---> (_ * _) //│ //│ ◉ (_ -> _) comes from -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^^^ //│ │ let add (l1,l2) = ... //│ │ ^^^^^^^^^^^^^^^^^^^^^ @@ -1987,23 +1985,23 @@ let bigMul l1 l2 = //│ (_ list) ~~~~ (?c) ---> (_ -> _) //│ //│ ◉ (_ list) comes from -//│ - l.-395 | h::t -> [remainder x y] @ (mulByDigit i t);; +//│ - l.-393 | h::t -> [remainder x y] @ (mulByDigit i t);; //│ ^ //│ ◉ (_ list -> _) comes from -//│ ▲ - l.-395 | h::t -> [remainder x y] @ (mulByDigit i t);; +//│ ▲ - l.-393 | h::t -> [remainder x y] @ (mulByDigit i t);; //│ │ ^^^^^^^^^^^^ //│ │ //│ ◉ (?a) is assumed for -//│ - l.-395 | h::t -> [remainder x y] @ (mulByDigit i t);; +//│ - l.-393 | h::t -> [remainder x y] @ (mulByDigit i t);; //│ ^^^^^^^^^^^^ //│ ◉ (_ -> ?a) comes from -//│ ▲ - l.-395 | h::t -> [remainder x y] @ (mulByDigit i t);; +//│ ▲ - l.-393 | h::t -> [remainder x y] @ (mulByDigit i t);; //│ │ ^^^^^^^^^^ -//│ │ - l.-398let rec mulByDigit i l = +//│ │ - l.-396let rec mulByDigit i l = //│ │ ^^^^^^^^^^ //│ │ //│ ◉ (?mulByDigit) is assumed for -//│ │ - l.-398let rec mulByDigit i l = +//│ │ - l.-396let rec mulByDigit i l = //│ │ ^^^^^^^^^^ //│ ▼ //│ ◉ (_ -> ?b) comes from @@ -2085,27 +2083,27 @@ let bigMul l1 l2 = //│ ◉ (_ list) comes from //│ ▲ - lib. let List.rev: 'a list -> 'a list //│ │ ^^^^^^^ -//│ │ - l.-397 match List.rev l with +//│ │ - l.-395 match List.rev l with //│ │ ^ //│ │ //│ ◉ (?c) is assumed for -//│ - l.-398let rec mulByDigit i l = +//│ - l.-396let rec mulByDigit i l = //│ ^ //│ ◉ (?c -> _) comes from -//│ - l.-398let rec mulByDigit i l = +//│ - l.-396let rec mulByDigit i l = //│ ^^^ //│ match List.rev l with ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ◉ (_ -> ?c -> _) comes from -//│ │ - l.-398let rec mulByDigit i l = +//│ │ - l.-396let rec mulByDigit i l = //│ │ ^^^^^ //│ │ match List.rev l with ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-398let rec mulByDigit i l = +//│ │ - l.-396let rec mulByDigit i l = //│ │ ^^^^^^^^^^ //│ ▼ //│ ◉ (?mulByDigit) is assumed for -//│ │ - l.-398let rec mulByDigit i l = +//│ │ - l.-396let rec mulByDigit i l = //│ │ ^^^^^^^^^^ //│ ▼ //│ ◉ (_ -> ?a) comes from @@ -2127,10 +2125,10 @@ let bigMul l1 l2 = //│ ^^ //│ [ERROR] Type `_ -> _` does not match `_ * _` //│ -//│ (_ -> _) ---> (?c) ---> (?d) ---> (?a) ~~~~ (?e) ~~~~ (?b) ---> (_ * _) +//│ (_ -> _) ---> (?a) ---> (?d) ---> (?e) ~~~~ (?c) ~~~~ (?b) ---> (_ * _) //│ //│ ◉ (_ -> _) comes from -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^^^ //│ │ let add (l1,l2) = ... //│ │ ^^^^^^^^^^^^^^^^^^^^^ @@ -2139,7 +2137,7 @@ let bigMul l1 l2 = //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.7 let (carry,res) = a in @@ -2153,17 +2151,17 @@ let bigMul l1 l2 = //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for +//│ ◉ (?e) is assumed for //│ - l.6 let (x1,x2) = x in //│ ^^^^^^^^^^^^^^^^^^ //│ let (carry,res) = a in ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?a) comes from +//│ ◉ (_ -> ?e) comes from //│ - l.5 let f a x = //│ ^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?b -> _ -> ?a) comes from +//│ ◉ (?b -> _ -> ?e) comes from //│ │ - l.5 let f a x = //│ │ ^^^^^ //│ │ let (x1,x2) = x in ... @@ -2171,20 +2169,20 @@ let bigMul l1 l2 = //│ │ - l.11 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ ▼ -//│ ◉ (?e -> _ -> ?e) comes from +//│ ◉ (?c -> _ -> ?c) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?e) comes from +//│ ◉ (_ -> ?c) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?e) is assumed for -//│ ◉ (?e -> _ -> ?e) comes from +//│ ◉ (?c) is assumed for +//│ ◉ (?c -> _ -> ?c) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ //│ │ - l.11 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ │ -//│ ◉ (?b -> _ -> ?a) comes from +//│ ◉ (?b -> _ -> ?e) comes from //│ - l.5 let f a x = //│ ^^^^^ //│ let (x1,x2) = x in ... @@ -2200,7 +2198,7 @@ let bigMul l1 l2 = //│ ^^^^^^^^^^^ //│ [ERROR] Type `_ list` does not match `_ * _` //│ -//│ (_ list) ---> (?c) ---> (?d) ---> (?a) ~~~~ (?e) ~~~~ (?b) ---> (_ * _) +//│ (_ list) ---> (?a) ---> (?d) ---> (?e) ~~~~ (?c) ~~~~ (?b) ---> (_ * _) //│ //│ ◉ (_ list) comes from //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in @@ -2208,7 +2206,7 @@ let bigMul l1 l2 = //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.7 let (carry,res) = a in @@ -2222,17 +2220,17 @@ let bigMul l1 l2 = //│ │ match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for +//│ ◉ (?e) is assumed for //│ - l.6 let (x1,x2) = x in //│ ^^^^^^^^^^^^^^^^^^ //│ let (carry,res) = a in ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?a) comes from +//│ ◉ (_ -> ?e) comes from //│ - l.5 let f a x = //│ ^^^ //│ let (x1,x2) = x in ... //│ ^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?b -> _ -> ?a) comes from +//│ ◉ (?b -> _ -> ?e) comes from //│ │ - l.5 let f a x = //│ │ ^^^^^ //│ │ let (x1,x2) = x in ... @@ -2240,20 +2238,20 @@ let bigMul l1 l2 = //│ │ - l.11 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ ▼ -//│ ◉ (?e -> _ -> ?e) comes from +//│ ◉ (?c -> _ -> ?c) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?e) comes from +//│ ◉ (_ -> ?c) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?e) is assumed for -//│ ◉ (?e -> _ -> ?e) comes from +//│ ◉ (?c) is assumed for +//│ ◉ (?c -> _ -> ?c) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ //│ │ - l.11 let (carry,res) = List.fold_left f base args in [carry] @ res;; //│ │ ^ //│ │ -//│ ◉ (?b -> _ -> ?a) comes from +//│ ◉ (?b -> _ -> ?e) comes from //│ - l.5 let f a x = //│ ^^^^^ //│ let (x1,x2) = x in ... @@ -2360,257 +2358,257 @@ let bigMul l1 l2 = //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ //│ ◉ (_ -> _) comes from -//│ - l.-1364let bigAdd l1 l2 = +//│ - l.-1362let bigAdd l1 l2 = //│ ^^^^ //│ let add (l1,l2) = ... //│ ^^^^^^^^^^^^^^^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?b) ---> (?h) ~~~~ (?e) ---> (?f) ~~~~ (_ list) +//│ (_ * _) ---> (?f) ---> (?c) ~~~~ (?a) ---> (?g) ~~~~ (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.-1364let bigAdd l1 l2 = +//│ ◉ (?f) is assumed for +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^ //│ ▼ -//│ ◉ (?h) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?c) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?h * _ list) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?c * _ list) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?d) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?g) is assumed for -//│ │ - l.-1369 if diff < 0 +//│ ◉ (?e) is assumed for +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e * _) comes from -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ - l.-1361 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?e) is assumed for -//│ │ - l.-1363 let add (l1,l2) = +//│ ◉ (?a) is assumed for +//│ │ - l.-1361 let add (l1,l2) = //│ │ ^^ -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^ //│ ▼ -//│ ◉ (?f) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?g) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?f * _) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?g * _) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?i) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?i) is assumed for -//│ - l.-1369 if diff < 0 +//│ ◉ (?b) is assumed for +//│ - l.-1367 if diff < 0 //│ ^^^^^^^^^^^ //│ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?i) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> _ -> ?i) comes from -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> _ -> ?b) comes from +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ ▼ -//│ ◉ (?d -> _ -> ?d) comes from +//│ ◉ (?h -> _ -> ?h) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?h) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?d) is assumed for -//│ ◉ (_ -> ?d) comes from +//│ ◉ (?h) is assumed for +//│ ◉ (_ -> ?h) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?d -> _ -> ?d) comes from +//│ ◉ (?h -> _ -> ?h) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ │ -//│ ◉ (_ -> _ -> ?i) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> _ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?i) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^ -//│ ◉ (?i) is assumed for -//│ ▲ - l.-1369 if diff < 0 +//│ ◉ (?b) is assumed for +//│ ▲ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ //│ ◉ (_ list * _) comes from -//│ - l.-1368 then (((clone 0 (-1 * diff)) @ l1), l2) +//│ - l.-1366 then (((clone 0 (-1 * diff)) @ l1), l2) //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ◉ (_ list) comes from -//│ - l.-1368 then (((clone 0 (-1 * diff)) @ l1), l2) +//│ - l.-1366 then (((clone 0 (-1 * diff)) @ l1), l2) //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ - lib. let (@): 'a list -> 'a list -> 'a list //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?b) ---> (?i) ~~~~ (?e) ---> (?g) ~~~~ (?f) ~~~~ (?g) ---> (_ list) +//│ (_ * _) ---> (?g) ---> (?c) ~~~~ (?a) ---> (?h) ~~~~ (?d) ~~~~ (?h) ---> (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.-1364let bigAdd l1 l2 = +//│ ◉ (?g) is assumed for +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^ //│ ▼ -//│ ◉ (?i) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?c) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?i * _ list) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?c * _ list) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?e) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?h) is assumed for -//│ │ - l.-1369 if diff < 0 +//│ ◉ (?f) is assumed for +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e * _) comes from -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ - l.-1361 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?e) is assumed for -//│ │ - l.-1363 let add (l1,l2) = +//│ ◉ (?a) is assumed for +//│ │ - l.-1361 let add (l1,l2) = //│ │ ^^ -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^ //│ ▼ -//│ ◉ (?g) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?h) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?g * _) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?h * _) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?j) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?j) is assumed for -//│ - l.-1369 if diff < 0 +//│ ◉ (?b) is assumed for +//│ - l.-1367 if diff < 0 //│ ^^^^^^^^^^^ //│ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?j) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> _ -> ?j) comes from -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> _ -> ?b) comes from +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ ▼ -//│ ◉ (?d -> _ -> ?d) comes from +//│ ◉ (?i -> _ -> ?i) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?i) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?d) is assumed for -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?i) is assumed for +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?f * _) comes from -//│ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?d * _) comes from +//│ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ ^^^^^^^ -//│ ◉ (?f) is assumed for -//│ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?d) is assumed for +//│ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ ^ -//│ ◉ (?f * _) comes from -//│ ▲ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?d * _) comes from +//│ ▲ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^^^^^^^ //│ │ -//│ ◉ (?d) is assumed for -//│ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?i) is assumed for +//│ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?i) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?d -> _ -> ?d) comes from +//│ ◉ (?i -> _ -> ?i) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ │ -//│ ◉ (_ -> _ -> ?j) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> _ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?j) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^ -//│ ◉ (?j) is assumed for -//│ ▲ - l.-1369 if diff < 0 +//│ ◉ (?b) is assumed for +//│ ▲ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?c) is assumed for -//│ ▲ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?j) is assumed for +//│ ▲ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?g * _) comes from -//│ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?h * _) comes from +//│ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ ^^^^^^^^ -//│ ◉ (?g) is assumed for -//│ │ - l.-1371let padZero l1 l2 = +//│ ◉ (?h) is assumed for +//│ │ - l.-1369let padZero l1 l2 = //│ │ ^^ -//│ │ - l.-1370 let diff = (List.length l1) - (List.length l2) in +//│ │ - l.-1368 let diff = (List.length l1) - (List.length l2) in //│ │ ^^ //│ ▼ //│ ◉ (_ list) comes from @@ -2618,146 +2616,146 @@ let bigMul l1 l2 = //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?b) ---> (?i) ~~~~ (?e) ---> (?g) ~~~~ (?f) ~~~~ (?g) <--- (?e) ---> (_ list) +//│ (_ * _) ---> (?g) ---> (?c) ~~~~ (?a) ---> (?h) ~~~~ (?d) ~~~~ (?h) <--- (?a) ---> (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.-1364let bigAdd l1 l2 = +//│ ◉ (?g) is assumed for +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^ //│ ▼ -//│ ◉ (?i) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?c) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?i * _ list) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?c * _ list) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?e) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?h) is assumed for -//│ │ - l.-1369 if diff < 0 +//│ ◉ (?f) is assumed for +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e * _) comes from -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ - l.-1361 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?e) is assumed for -//│ │ - l.-1363 let add (l1,l2) = +//│ ◉ (?a) is assumed for +//│ │ - l.-1361 let add (l1,l2) = //│ │ ^^ -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^ //│ ▼ -//│ ◉ (?g) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?h) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?g * _) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?h * _) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?j) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?j) is assumed for -//│ - l.-1369 if diff < 0 +//│ ◉ (?b) is assumed for +//│ - l.-1367 if diff < 0 //│ ^^^^^^^^^^^ //│ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?j) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> _ -> ?j) comes from -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> _ -> ?b) comes from +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ ▼ -//│ ◉ (?d -> _ -> ?d) comes from +//│ ◉ (?i -> _ -> ?i) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?i) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?d) is assumed for -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?i) is assumed for +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?f * _) comes from -//│ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?d * _) comes from +//│ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ ^^^^^^^ -//│ ◉ (?f) is assumed for -//│ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?d) is assumed for +//│ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ ^ -//│ ◉ (?f * _) comes from -//│ ▲ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?d * _) comes from +//│ ▲ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^^^^^^^ //│ │ -//│ ◉ (?d) is assumed for -//│ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?i) is assumed for +//│ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?i) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?d -> _ -> ?d) comes from +//│ ◉ (?i -> _ -> ?i) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ │ -//│ ◉ (_ -> _ -> ?j) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> _ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?j) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^ -//│ ◉ (?j) is assumed for -//│ ▲ - l.-1369 if diff < 0 +//│ ◉ (?b) is assumed for +//│ ▲ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?c) is assumed for -//│ ▲ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?j) is assumed for +//│ ▲ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?g * _) comes from -//│ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?h * _) comes from +//│ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ ^^^^^^^^ -//│ ◉ (?g) is assumed for -//│ ▲ - l.-1371let padZero l1 l2 = +//│ ◉ (?h) is assumed for +//│ ▲ - l.-1369let padZero l1 l2 = //│ │ ^^ -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^ -//│ │ - l.-1363 let add (l1,l2) = +//│ │ - l.-1361 let add (l1,l2) = //│ │ ^^ //│ │ -//│ ◉ (?e) is assumed for -//│ │ - l.-1363 let add (l1,l2) = +//│ ◉ (?a) is assumed for +//│ │ - l.-1361 let add (l1,l2) = //│ │ ^^ -//│ │ - l.-1361 let base = List.combine l1 l2 in +//│ │ - l.-1359 let base = List.combine l1 l2 in //│ │ ^^ //│ ▼ //│ ◉ (_ list) comes from @@ -2765,335 +2763,335 @@ let bigMul l1 l2 = //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?b) ---> (?i) ~~~~ (?e) ---> (?g) ~~~~ (?f) ~~~~ (?g) <--- (?e) ~~~~ (_ list) +//│ (_ * _) ---> (?g) ---> (?c) ~~~~ (?a) ---> (?h) ~~~~ (?d) ~~~~ (?h) <--- (?a) ~~~~ (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.-1364let bigAdd l1 l2 = +//│ ◉ (?g) is assumed for +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^ //│ ▼ -//│ ◉ (?i) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?c) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?i * _ list) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?c * _ list) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?e) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?h) is assumed for -//│ │ - l.-1369 if diff < 0 +//│ ◉ (?f) is assumed for +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e * _) comes from -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ - l.-1361 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?e) is assumed for -//│ │ - l.-1363 let add (l1,l2) = +//│ ◉ (?a) is assumed for +//│ │ - l.-1361 let add (l1,l2) = //│ │ ^^ -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^ //│ ▼ -//│ ◉ (?g) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?h) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?g * _) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?h * _) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?j) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?j) is assumed for -//│ - l.-1369 if diff < 0 +//│ ◉ (?b) is assumed for +//│ - l.-1367 if diff < 0 //│ ^^^^^^^^^^^ //│ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?j) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> _ -> ?j) comes from -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> _ -> ?b) comes from +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ ▼ -//│ ◉ (?d -> _ -> ?d) comes from +//│ ◉ (?i -> _ -> ?i) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?i) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?d) is assumed for -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?i) is assumed for +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?f * _) comes from -//│ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?d * _) comes from +//│ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ ^^^^^^^ -//│ ◉ (?f) is assumed for -//│ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?d) is assumed for +//│ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ ^ -//│ ◉ (?f * _) comes from -//│ ▲ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?d * _) comes from +//│ ▲ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^^^^^^^ //│ │ -//│ ◉ (?d) is assumed for -//│ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?i) is assumed for +//│ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?i) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?d -> _ -> ?d) comes from +//│ ◉ (?i -> _ -> ?i) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ │ -//│ ◉ (_ -> _ -> ?j) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> _ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?j) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^ -//│ ◉ (?j) is assumed for -//│ ▲ - l.-1369 if diff < 0 +//│ ◉ (?b) is assumed for +//│ ▲ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?c) is assumed for -//│ ▲ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?j) is assumed for +//│ ▲ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?g * _) comes from -//│ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?h * _) comes from +//│ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ ^^^^^^^^ -//│ ◉ (?g) is assumed for -//│ ▲ - l.-1371let padZero l1 l2 = +//│ ◉ (?h) is assumed for +//│ ▲ - l.-1369let padZero l1 l2 = //│ │ ^^ -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^ //│ │ -//│ ◉ (?e) is assumed for -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a) is assumed for +//│ - l.-1361 let add (l1,l2) = //│ ^^ -//│ ◉ (?e * _) comes from -//│ ▲ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ ▲ - l.-1361 let add (l1,l2) = //│ │ ^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?h) is assumed for -//│ ▲ - l.-1369 if diff < 0 +//│ ◉ (?f) is assumed for +//│ ▲ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ //│ ◉ (_ list * _) comes from -//│ - l.-1368 then (((clone 0 (-1 * diff)) @ l1), l2) +//│ - l.-1366 then (((clone 0 (-1 * diff)) @ l1), l2) //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ◉ (_ list) comes from -//│ - l.-1368 then (((clone 0 (-1 * diff)) @ l1), l2) +//│ - l.-1366 then (((clone 0 (-1 * diff)) @ l1), l2) //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ - lib. let (@): 'a list -> 'a list -> 'a list //│ ^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ---> (?b) ---> (?i) ~~~~ (?e) ---> (?g) ~~~~ (?f) ~~~~ (?g) <--- (?e) ~~~~ (?i) ---> (_ list) +//│ (_ * _) ---> (?g) ---> (?c) ~~~~ (?a) ---> (?h) ~~~~ (?d) ~~~~ (?h) <--- (?a) ~~~~ (?c) ---> (_ list) //│ //│ ◉ (_ * _) comes from //│ │ - l.8 match x2 with | [] -> [] | h::t -> bigAdd ((mulByDigit h l1), res) in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1364let bigAdd l1 l2 = +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ //│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.-1364let bigAdd l1 l2 = +//│ ◉ (?g) is assumed for +//│ │ - l.-1362let bigAdd l1 l2 = //│ │ ^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^ //│ ▼ -//│ ◉ (?i) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?c) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?i * _ list) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?c * _ list) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?e) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?h) is assumed for -//│ │ - l.-1369 if diff < 0 +//│ ◉ (?f) is assumed for +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e * _) comes from -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ - l.-1361 let add (l1,l2) = //│ ^^^^^^^ -//│ ◉ (?e) is assumed for -//│ │ - l.-1363 let add (l1,l2) = +//│ ◉ (?a) is assumed for +//│ │ - l.-1361 let add (l1,l2) = //│ │ ^^ -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^ //│ ▼ -//│ ◉ (?g) is assumed for -//│ - l.-1371let padZero l1 l2 = +//│ ◉ (?h) is assumed for +//│ - l.-1369let padZero l1 l2 = //│ ^^ -//│ ◉ (?g * _) comes from -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?h * _) comes from +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?j) is assumed for +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?j) is assumed for -//│ - l.-1369 if diff < 0 +//│ ◉ (?b) is assumed for +//│ - l.-1367 if diff < 0 //│ ^^^^^^^^^^^ //│ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?j) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> _ -> ?j) comes from -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> _ -> ?b) comes from +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ ▼ -//│ ◉ (?d -> _ -> ?d) comes from +//│ ◉ (?i -> _ -> ?i) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?i) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?d) is assumed for -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?i) is assumed for +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?f * _) comes from -//│ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?d * _) comes from +//│ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ ^^^^^^^ -//│ ◉ (?f) is assumed for -//│ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?d) is assumed for +//│ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ ^ -//│ ◉ (?f * _) comes from -//│ ▲ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?d * _) comes from +//│ ▲ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^^^^^^^ //│ │ -//│ ◉ (?d) is assumed for -//│ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ ◉ (?i) is assumed for +//│ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?i) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?d -> _ -> ?d) comes from +//│ ◉ (?i -> _ -> ?i) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ -//│ │ - l.-1359 let (_,res) = List.fold_left f base args in res in +//│ │ - l.-1357 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ │ -//│ ◉ (_ -> _ -> ?j) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> _ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?j) comes from -//│ - l.-1362 let f a x = padZero l1 l2 in +//│ ◉ (_ -> ?b) comes from +//│ - l.-1360 let f a x = padZero l1 l2 in //│ ^^^^^^^^^^^^^^^^^ -//│ ◉ (?j) is assumed for -//│ ▲ - l.-1369 if diff < 0 +//│ ◉ (?b) is assumed for +//│ ▲ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?c) is assumed for -//│ ▲ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?j) is assumed for +//│ ▲ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?g * _) comes from -//│ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?h * _) comes from +//│ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ ^^^^^^^^ -//│ ◉ (?g) is assumed for -//│ ▲ - l.-1371let padZero l1 l2 = +//│ ◉ (?h) is assumed for +//│ ▲ - l.-1369let padZero l1 l2 = //│ │ ^^ -//│ │ - l.-1362 let f a x = padZero l1 l2 in +//│ │ - l.-1360 let f a x = padZero l1 l2 in //│ │ ^^ //│ │ -//│ ◉ (?e) is assumed for -//│ - l.-1363 let add (l1,l2) = +//│ ◉ (?a) is assumed for +//│ - l.-1361 let add (l1,l2) = //│ ^^ -//│ ◉ (?e * _) comes from -//│ ▲ - l.-1363 let add (l1,l2) = +//│ ◉ (?a * _) comes from +//│ ▲ - l.-1361 let add (l1,l2) = //│ │ ^^^^^^^ -//│ │ - l.-1358 removeZero (add (padZero l1 l2));; +//│ │ - l.-1356 removeZero (add (padZero l1 l2));; //│ │ ^^^^^^^^^^^^^^^ -//│ │ - l.-1369 if diff < 0 +//│ │ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?h) is assumed for -//│ ▲ - l.-1369 if diff < 0 +//│ ◉ (?f) is assumed for +//│ ▲ - l.-1367 if diff < 0 //│ │ ^^^^^^^^^^^ //│ │ then (((clone 0 (-1 * diff)) @ l1), l2) ... //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ │ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?a) is assumed for -//│ ▲ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?e) is assumed for +//│ ▲ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?i * _ list) comes from -//│ - l.-1367 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; +//│ ◉ (?c * _ list) comes from +//│ - l.-1365 else if diff > 0 then (l1, ((clone 0 diff) @ l2)) else (l1, l2);; //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?i) is assumed for -//│ │ - l.-1371let padZero l1 l2 = +//│ ◉ (?c) is assumed for +//│ │ - l.-1369let padZero l1 l2 = //│ │ ^^ -//│ │ - l.-1370 let diff = (List.length l1) - (List.length l2) in +//│ │ - l.-1368 let diff = (List.length l1) - (List.length l2) in //│ │ ^^ //│ ▼ //│ ◉ (_ list) comes from @@ -3104,30 +3102,30 @@ let bigMul l1 l2 = //│ bigMul: 'b -> list[int] -> list[int] //│ where //│ 'b = list[int] -> list[('c, list['a],)], list['d] -//│ U max: 13, total: 367 +//│ U max: 13, total: 318 //│ UERR 22 errors -//│ L: 3 [([α1011'], [[[α867'']]],) ~ list[α872''], ([α1011'], [[[α867'']]],) <: α871'', α871'' <: α897'', [α897'' - ([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],) - α898'', L: 0 [([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],), ([[α897'']], [[list[α899'']]],) <: α940'', α940'' <: α941'', α941'' <: ([α898''], [α938''],)]], α898'' <: α965'', [α965'' - ([[α965'']], [[α936'']],) ~ ([α937''], [α935''],) - α937'', L: 2 [([[α965'']], [[α936'']],) ~ ([α937''], [α935''],), ([[α965'']], [[α936'']],) <: α966'', α966'' <: α967'', [α967'' - (α970'' -> [α967'']) ~ (α971'' -> α968'') - α968'', L: 1 [(α970'' -> [α967'']) ~ (α971'' -> α968''), [(α970'' -> [α967'']) - (α969'' -> (α970'' -> [α967''])) ~ (α968'' -> (α971'' -> α968'')) - (α971'' -> α968''), L: 0 [(α969'' -> (α970'' -> [α967''])) ~ (α968'' -> (α971'' -> α968'')), (α969'' -> (α970'' -> [α967''])) <: (α968'' -> (α971'' -> α968''))]]]], α968'' <: ([α937''], [α935''],)]], [α937'' - ([α937''], [α935''],) ~ ([[α965'']], [[α936'']],) - α965'', L: 2 [([α937''], [α935''],) ~ ([[α965'']], [[α936'']],), ([α937''], [α935''],) :> α968'', [α968'' - (α971'' -> α968'') ~ (α970'' -> [α967'']) - α967'', L: 1 [(α971'' -> α968'') ~ (α970'' -> [α967'']), [(α971'' -> α968'') - (α968'' -> (α971'' -> α968'')) ~ (α969'' -> (α970'' -> [α967''])) - (α970'' -> [α967'']), L: 0 [(α968'' -> (α971'' -> α968'')) ~ (α969'' -> (α970'' -> [α967''])), (α968'' -> (α971'' -> α968'')) :> (α969'' -> (α970'' -> [α967'']))]]]], α967'' :> α966'', α966'' :> ([[α965'']], [[α936'']],)]], α965'' :> α898'', [α898'' - ([α898''], [α938''],) ~ ([[α897'']], [[list[α899'']]],) - α897'', L: 0 [([α898''], [α938''],) ~ ([[α897'']], [[list[α899'']]],), ([α898''], [α938''],) :> α941'', α941'' :> α940'', α940'' :> ([[α897'']], [[list[α899'']]],)]], α897'' <: list[α872'']] -//│ L: 3 [([α1011'], [[[α867'']]],) ~ list[α942''], ([α1011'], [[[α867'']]],) <: α871'', α871'' <: α897'', [α897'' - ([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],) - α898'', L: 0 [([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],), ([[α897'']], [[list[α899'']]],) <: α940'', α940'' <: α941'', α941'' <: ([α898''], [α938''],)]], α898'' <: α965'', [α965'' - ([[α965'']], [[α936'']],) ~ ([α937''], [α935''],) - α937'', L: 2 [([[α965'']], [[α936'']],) ~ ([α937''], [α935''],), ([[α965'']], [[α936'']],) <: α966'', α966'' <: α967'', [α967'' - (α970'' -> [α967'']) ~ (α971'' -> α968'') - α968'', L: 1 [(α970'' -> [α967'']) ~ (α971'' -> α968''), [(α970'' -> [α967'']) - (α969'' -> (α970'' -> [α967''])) ~ (α968'' -> (α971'' -> α968'')) - (α971'' -> α968''), L: 0 [(α969'' -> (α970'' -> [α967''])) ~ (α968'' -> (α971'' -> α968'')), (α969'' -> (α970'' -> [α967''])) <: (α968'' -> (α971'' -> α968''))]]]], α968'' <: ([α937''], [α935''],)]], [α937'' - ([α937''], [α935''],) ~ ([[α965'']], [[α936'']],) - α965'', L: 2 [([α937''], [α935''],) ~ ([[α965'']], [[α936'']],), ([α937''], [α935''],) :> α968'', [α968'' - (α971'' -> α968'') ~ (α970'' -> [α967'']) - α967'', L: 1 [(α971'' -> α968'') ~ (α970'' -> [α967'']), [(α971'' -> α968'') - (α968'' -> (α971'' -> α968'')) ~ (α969'' -> (α970'' -> [α967''])) - (α970'' -> [α967'']), L: 0 [(α968'' -> (α971'' -> α968'')) ~ (α969'' -> (α970'' -> [α967''])), (α968'' -> (α971'' -> α968'')) :> (α969'' -> (α970'' -> [α967'']))]]]], α967'' :> α966'', α966'' :> ([[α965'']], [[α936'']],)]], α965'' :> α898'', α898'' <: list[α942'']] -//│ L: 1 [([α1011'], [[[α867'']]],) ~ list[α872''], ([α1011'], [[[α867'']]],) <: α871'', α871'' <: α897'', [α897'' - ([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],) - α898'', L: 0 [([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],), ([[α897'']], [[list[α899'']]],) <: α940'', α940'' <: α941'', α941'' <: ([α898''], [α938''],)]], [α898'' - ([α898''], [α938''],) ~ ([[α897'']], [[list[α899'']]],) - α897'', L: 0 [([α898''], [α938''],) ~ ([[α897'']], [[list[α899'']]],), ([α898''], [α938''],) :> α941'', α941'' :> α940'', α940'' :> ([[α897'']], [[list[α899'']]],)]], α897'' <: list[α872'']] -//│ L: 0 [([α1011'], [[[α867'']]],) ~ list[α872''], ([α1011'], [[[α867'']]],) <: α871'', α871'' <: α897'', α897'' <: list[α872'']] -//│ L: 2 [list['a1044'] ~ ([α1173'], [α1174'],), list['a1044'] <: α1042', α1042' <: α1043', α1043' <: α1041', [α1041' - (α1038' -> α1041') ~ (α1034' -> α1033') - α1033', L: 1 [(α1038' -> α1041') ~ (α1034' -> α1033'), [(α1038' -> α1041') - (α1035' -> (α1038' -> α1041')) ~ (α1033' -> (α1034' -> α1033')) - (α1034' -> α1033'), L: 0 [(α1035' -> (α1038' -> α1041')) ~ (α1033' -> (α1034' -> α1033')), (α1035' -> (α1038' -> α1041')) <: (α1033' -> (α1034' -> α1033'))]]]], α1033' <: ([α1173'], [α1174'],)] -//│ L: 3 [([α1011'], [[[α867'']]],) ~ list[α896''], ([α1011'], [[[α867'']]],) <: α871'', α871'' <: α897'', [α897'' - ([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],) - α898'', L: 0 [([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],), ([[α897'']], [[list[α899'']]],) <: α940'', α940'' <: α941'', α941'' <: ([α898''], [α938''],)]], α898'' <: α965'', [α965'' - ([[α965'']], [[α936'']],) ~ ([α937''], [α935''],) - α937'', L: 2 [([[α965'']], [[α936'']],) ~ ([α937''], [α935''],), ([[α965'']], [[α936'']],) <: α966'', α966'' <: α967'', [α967'' - (α970'' -> [α967'']) ~ (α971'' -> α968'') - α968'', L: 1 [(α970'' -> [α967'']) ~ (α971'' -> α968''), [(α970'' -> [α967'']) - (α969'' -> (α970'' -> [α967''])) ~ (α968'' -> (α971'' -> α968'')) - (α971'' -> α968''), L: 0 [(α969'' -> (α970'' -> [α967''])) ~ (α968'' -> (α971'' -> α968'')), (α969'' -> (α970'' -> [α967''])) <: (α968'' -> (α971'' -> α968''))]]]], α968'' <: ([α937''], [α935''],)]], [α937'' - ([α937''], [α935''],) ~ ([[α965'']], [[α936'']],) - α965'', L: 2 [([α937''], [α935''],) ~ ([[α965'']], [[α936'']],), ([α937''], [α935''],) :> α968'', [α968'' - (α971'' -> α968'') ~ (α970'' -> [α967'']) - α967'', L: 1 [(α971'' -> α968'') ~ (α970'' -> [α967'']), [(α971'' -> α968'') - (α968'' -> (α971'' -> α968'')) ~ (α969'' -> (α970'' -> [α967''])) - (α970'' -> [α967'']), L: 0 [(α968'' -> (α971'' -> α968'')) ~ (α969'' -> (α970'' -> [α967''])), (α968'' -> (α971'' -> α968'')) :> (α969'' -> (α970'' -> [α967'']))]]]], α967'' :> α966'', α966'' :> ([[α965'']], [[α936'']],)]], α965'' <: list[α896'']] -//│ L: 2 [list['a1044'] ~ (α1045' -> α1055'), list['a1044'] <: α1042', α1042' <: α1043', α1043' <: α1041', [α1041' - (α1038' -> α1041') ~ (α1034' -> α1033') - α1033', L: 1 [(α1038' -> α1041') ~ (α1034' -> α1033'), [(α1038' -> α1041') - (α1035' -> (α1038' -> α1041')) ~ (α1033' -> (α1034' -> α1033')) - (α1034' -> α1033'), L: 0 [(α1035' -> (α1038' -> α1041')) ~ (α1033' -> (α1034' -> α1033')), (α1035' -> (α1038' -> α1041')) <: (α1033' -> (α1034' -> α1033'))]]]], [α1033' - (α1034' -> α1033') ~ (α1038' -> α1041') - α1041', L: 1 [(α1034' -> α1033') ~ (α1038' -> α1041'), [(α1034' -> α1033') - (α1033' -> (α1034' -> α1033')) ~ (α1035' -> (α1038' -> α1041')) - (α1038' -> α1041'), L: 0 [(α1033' -> (α1034' -> α1033')) ~ (α1035' -> (α1038' -> α1041')), (α1033' -> (α1034' -> α1033')) :> (α1035' -> (α1038' -> α1041'))]]]], α1041' :> α1043', α1043' :> α1042', α1042' :> (α1045' -> α1055')] -//│ L: 2 [list['a1044'] ~ ([α1036'], [α1037'],), list['a1044'] <: α1042', α1042' <: α1043', α1043' <: α1041', [α1041' - (α1038' -> α1041') ~ (α1034' -> α1033') - α1033', L: 1 [(α1038' -> α1041') ~ (α1034' -> α1033'), [(α1038' -> α1041') - (α1035' -> (α1038' -> α1041')) ~ (α1033' -> (α1034' -> α1033')) - (α1034' -> α1033'), L: 0 [(α1035' -> (α1038' -> α1041')) ~ (α1033' -> (α1034' -> α1033')), (α1035' -> (α1038' -> α1041')) <: (α1033' -> (α1034' -> α1033'))]]]], [α1033' - (α1033' -> (α1034' -> α1033')) ~ (α1035' -> (α1038' -> α1041')) - α1035', L: 0 [(α1033' -> (α1034' -> α1033')) ~ (α1035' -> (α1038' -> α1041')), (α1033' -> (α1034' -> α1033')) :> (α1035' -> (α1038' -> α1041'))]], α1035' <: ([α1036'], [α1037'],)] -//│ L: 2 [(α1045' -> α1055') ~ ([α1173'], [α1174'],), (α1045' -> α1055') <: α1042', α1042' <: α1043', α1043' <: α1041', [α1041' - (α1038' -> α1041') ~ (α1034' -> α1033') - α1033', L: 1 [(α1038' -> α1041') ~ (α1034' -> α1033'), [(α1038' -> α1041') - (α1035' -> (α1038' -> α1041')) ~ (α1033' -> (α1034' -> α1033')) - (α1034' -> α1033'), L: 0 [(α1035' -> (α1038' -> α1041')) ~ (α1033' -> (α1034' -> α1033')), (α1035' -> (α1038' -> α1041')) <: (α1033' -> (α1034' -> α1033'))]]]], α1033' <: ([α1173'], [α1174'],)] -//│ L: 1 [([α1011'], [[[α867'']]],) ~ list[α939''], ([α1011'], [[[α867'']]],) <: α871'', α871'' <: α897'', [α897'' - ([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],) - α898'', L: 0 [([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],), ([[α897'']], [[list[α899'']]],) <: α940'', α940'' <: α941'', α941'' <: ([α898''], [α938''],)]], α898'' <: α965'', [α965'' - ([[α965'']], [[α936'']],) ~ ([[list[α939'']]], [[α936'']],) - list[α939''], L: 0 [([[α965'']], [[α936'']],) ~ ([[list[α939'']]], [[α936'']],), ([[α965'']], [[α936'']],) <: α966'', α966'' <: α967'', α967'' :> ([[list[α939'']]], [[α936'']],)]]] -//│ L: 2 [(α1045' -> α1055') ~ ([α1036'], [α1037'],), (α1045' -> α1055') <: α1042', α1042' <: α1043', α1043' <: α1041', [α1041' - (α1038' -> α1041') ~ (α1034' -> α1033') - α1033', L: 1 [(α1038' -> α1041') ~ (α1034' -> α1033'), [(α1038' -> α1041') - (α1035' -> (α1038' -> α1041')) ~ (α1033' -> (α1034' -> α1033')) - (α1034' -> α1033'), L: 0 [(α1035' -> (α1038' -> α1041')) ~ (α1033' -> (α1034' -> α1033')), (α1035' -> (α1038' -> α1041')) <: (α1033' -> (α1034' -> α1033'))]]]], [α1033' - (α1033' -> (α1034' -> α1033')) ~ (α1035' -> (α1038' -> α1041')) - α1035', L: 0 [(α1033' -> (α1034' -> α1033')) ~ (α1035' -> (α1038' -> α1041')), (α1033' -> (α1034' -> α1033')) :> (α1035' -> (α1038' -> α1041'))]], α1035' <: ([α1036'], [α1037'],)] -//│ L: 2 [list['a1000'] ~ (α1031' -> α1032'), [list['a1000'] - ([list['a1000']] -> α1008') ~ ([α855'] -> α1011') - α855', L: 1 [([list['a1000']] -> α1008') ~ ([α855'] -> α1011'), ([list['a1000']] -> α1008') :> α1009', [α1009' - ([α998'] -> α1009') ~ (['a869'] -> α1010') - α1010', L: 0 [([α998'] -> α1009') ~ (['a869'] -> α1010'), ([α998'] -> α1009') :> mulByDigit997', mulByDigit997' <: (['a869'] -> α1010')]], α1010' <: ([α855'] -> α1011')]], α855' <: (α1031' -> α1032')] -//│ L: 1 [([α1011'], [[[α867'']]],) ~ list[α873''], ([α1011'], [[[α867'']]],) <: α871'', α871'' <: α897'', [α897'' - ([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],) - α898'', L: 0 [([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],), ([[α897'']], [[list[α899'']]],) <: α940'', α940'' <: α941'', α941'' <: ([α898''], [α938''],)]], [α898'' - ([α898''], [α938''],) ~ ([[list[α873'']]], [[α924'']],) - list[α873''], L: 0 [([α898''], [α938''],) ~ ([[list[α873'']]], [[α924'']],), ([α898''], [α938''],) :> α941'', α941'' :> ([[list[α873'']]], [[α924'']],)]]] -//│ L: 2 [([[int]], [[list['a1171']]],) ~ (α1045' -> α1055'), ([[int]], [[list['a1171']]],) <: α1033', [α1033' - (α1034' -> α1033') ~ (α1038' -> α1041') - α1041', L: 1 [(α1034' -> α1033') ~ (α1038' -> α1041'), [(α1034' -> α1033') - (α1033' -> (α1034' -> α1033')) ~ (α1035' -> (α1038' -> α1041')) - (α1038' -> α1041'), L: 0 [(α1033' -> (α1034' -> α1033')) ~ (α1035' -> (α1038' -> α1041')), (α1033' -> (α1034' -> α1033')) :> (α1035' -> (α1038' -> α1041'))]]]], α1041' :> α1043', α1043' :> α1042', α1042' :> (α1045' -> α1055')] -//│ L: 2 [([[int]], [[list['a1171']]],) ~ list['a1044'], ([[int]], [[list['a1171']]],) <: α1033', [α1033' - (α1034' -> α1033') ~ (α1038' -> α1041') - α1041', L: 1 [(α1034' -> α1033') ~ (α1038' -> α1041'), [(α1034' -> α1033') - (α1033' -> (α1034' -> α1033')) ~ (α1035' -> (α1038' -> α1041')) - (α1038' -> α1041'), L: 0 [(α1033' -> (α1034' -> α1033')) ~ (α1035' -> (α1038' -> α1041')), (α1033' -> (α1034' -> α1033')) :> (α1035' -> (α1038' -> α1041'))]]]], α1041' :> α1043', α1043' :> α1042', α1042' :> list['a1044']] -//│ L: 3 [([α1011'], [[[α867'']]],) ~ list[α873''], ([α1011'], [[[α867'']]],) <: α871'', α871'' <: α897'', [α897'' - ([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],) - α898'', L: 0 [([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],), ([[α897'']], [[list[α899'']]],) <: α940'', α940'' <: α941'', α941'' <: ([α898''], [α938''],)]], α898'' <: α965'', [α965'' - ([[α965'']], [[α936'']],) ~ ([α937''], [α935''],) - α937'', L: 2 [([[α965'']], [[α936'']],) ~ ([α937''], [α935''],), ([[α965'']], [[α936'']],) <: α966'', α966'' <: α967'', [α967'' - (α970'' -> [α967'']) ~ (α971'' -> α968'') - α968'', L: 1 [(α970'' -> [α967'']) ~ (α971'' -> α968''), [(α970'' -> [α967'']) - (α969'' -> (α970'' -> [α967''])) ~ (α968'' -> (α971'' -> α968'')) - (α971'' -> α968''), L: 0 [(α969'' -> (α970'' -> [α967''])) ~ (α968'' -> (α971'' -> α968'')), (α969'' -> (α970'' -> [α967''])) <: (α968'' -> (α971'' -> α968''))]]]], α968'' <: ([α937''], [α935''],)]], [α937'' - ([α937''], [α935''],) ~ ([[α965'']], [[α936'']],) - α965'', L: 2 [([α937''], [α935''],) ~ ([[α965'']], [[α936'']],), ([α937''], [α935''],) :> α968'', [α968'' - (α971'' -> α968'') ~ (α970'' -> [α967'']) - α967'', L: 1 [(α971'' -> α968'') ~ (α970'' -> [α967'']), [(α971'' -> α968'') - (α968'' -> (α971'' -> α968'')) ~ (α969'' -> (α970'' -> [α967''])) - (α970'' -> [α967'']), L: 0 [(α968'' -> (α971'' -> α968'')) ~ (α969'' -> (α970'' -> [α967''])), (α968'' -> (α971'' -> α968'')) :> (α969'' -> (α970'' -> [α967'']))]]]], α967'' :> α966'', α966'' :> ([[α965'']], [[α936'']],)]], α965'' :> α898'', [α898'' - ([α898''], [α938''],) ~ ([[list[α873'']]], [[α924'']],) - list[α873''], L: 0 [([α898''], [α938''],) ~ ([[list[α873'']]], [[α924'']],), ([α898''], [α938''],) :> α941'', α941'' :> ([[list[α873'']]], [[α924'']],)]]] -//│ L: 3 [([α1011'], [[[α867'']]],) ~ list[α939''], ([α1011'], [[[α867'']]],) <: α871'', α871'' <: α897'', [α897'' - ([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],) - α898'', L: 0 [([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],), ([[α897'']], [[list[α899'']]],) <: α940'', α940'' <: α941'', α941'' <: ([α898''], [α938''],)]], α898'' <: α965'', [α965'' - ([[α965'']], [[α936'']],) ~ ([[list[α939'']]], [[α936'']],) - list[α939''], L: 2 [([[α965'']], [[α936'']],) ~ ([[list[α939'']]], [[α936'']],), ([[α965'']], [[α936'']],) <: α966'', α966'' <: α967'', [α967'' - (α970'' -> [α967'']) ~ (α971'' -> α968'') - α968'', L: 1 [(α970'' -> [α967'']) ~ (α971'' -> α968''), [(α970'' -> [α967'']) - (α969'' -> (α970'' -> [α967''])) ~ (α968'' -> (α971'' -> α968'')) - (α971'' -> α968''), L: 0 [(α969'' -> (α970'' -> [α967''])) ~ (α968'' -> (α971'' -> α968'')), (α969'' -> (α970'' -> [α967''])) <: (α968'' -> (α971'' -> α968''))]]]], [α968'' - (α971'' -> α968'') ~ (α970'' -> [α967'']) - α967'', L: 1 [(α971'' -> α968'') ~ (α970'' -> [α967'']), [(α971'' -> α968'') - (α968'' -> (α971'' -> α968'')) ~ (α969'' -> (α970'' -> [α967''])) - (α970'' -> [α967'']), L: 0 [(α968'' -> (α971'' -> α968'')) ~ (α969'' -> (α970'' -> [α967''])), (α968'' -> (α971'' -> α968'')) :> (α969'' -> (α970'' -> [α967'']))]]]], α967'' :> ([[list[α939'']]], [[α936'']],)]]] -//│ L: 0 [([α1011'], [[[α867'']]],) ~ list[α873''], ([α1011'], [[[α867'']]],) <: α871'', α871'' <: α897'', α897'' <: list[α873'']] -//│ L: 0 [(α996'' -> α934'') ~ list['a870''], (α996'' -> α934'') <: α868'', α868'' :> list['a870'']] -//│ L: 1 [([α1011'], [[[α867'']]],) ~ list[α942''], ([α1011'], [[[α867'']]],) <: α871'', α871'' <: α897'', [α897'' - ([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],) - α898'', L: 0 [([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],), ([[α897'']], [[list[α899'']]],) <: α940'', α940'' <: α941'', α941'' <: ([α898''], [α938''],)]], α898'' <: list[α942'']] -//│ L: 2 [list[α1001'] ~ (α1031' -> α1032'), list[α1001'] :> α999', [α999' - (α999' -> α1002') ~ ([α855'] -> α1011') - α855', L: 1 [(α999' -> α1002') ~ ([α855'] -> α1011'), [(α999' -> α1002') - (α998' -> (α999' -> α1002')) ~ (['a869'] -> α1010') - α1010', L: 0 [(α998' -> (α999' -> α1002')) ~ (['a869'] -> α1010'), (α998' -> (α999' -> α1002')) <: mulByDigit997', mulByDigit997' <: (['a869'] -> α1010')]], α1010' <: ([α855'] -> α1011')]], α855' <: (α1031' -> α1032')] -//│ L: 1 [([α1011'], [[[α867'']]],) ~ list[α896''], ([α1011'], [[[α867'']]],) <: α871'', α871'' <: α897'', [α897'' - ([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],) - α898'', L: 0 [([[α897'']], [[list[α899'']]],) ~ ([α898''], [α938''],), ([[α897'']], [[list[α899'']]],) <: α940'', α940'' <: α941'', α941'' <: ([α898''], [α938''],)]], α898'' <: α965'', α965'' <: list[α896'']] +//│ L: 3 [([α951'], [[[α809'']]],) ~ list[α884''], ([α951'], [[[α809'']]],) <: α813'', α813'' <: α839'', [α839'' - ([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],) - α840'', L: 0 [([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],), ([[α839'']], [[list[α841'']]],) <: α882'', α882'' <: α883'', α883'' <: ([α840''], [α880''],)]], α840'' <: α907'', [α907'' - ([[α907'']], [[α878'']],) ~ ([α879''], [α877''],) - α879'', L: 2 [([[α907'']], [[α878'']],) ~ ([α879''], [α877''],), ([[α907'']], [[α878'']],) <: α908'', α908'' <: α909'', [α909'' - (α912'' -> [α909'']) ~ (α913'' -> α910'') - α910'', L: 1 [(α912'' -> [α909'']) ~ (α913'' -> α910''), [(α912'' -> [α909'']) - (α911'' -> (α912'' -> [α909''])) ~ (α910'' -> (α913'' -> α910'')) - (α913'' -> α910''), L: 0 [(α911'' -> (α912'' -> [α909''])) ~ (α910'' -> (α913'' -> α910'')), (α911'' -> (α912'' -> [α909''])) <: (α910'' -> (α913'' -> α910''))]]]], α910'' <: ([α879''], [α877''],)]], [α879'' - ([α879''], [α877''],) ~ ([[α907'']], [[α878'']],) - α907'', L: 2 [([α879''], [α877''],) ~ ([[α907'']], [[α878'']],), ([α879''], [α877''],) :> α910'', [α910'' - (α913'' -> α910'') ~ (α912'' -> [α909'']) - α909'', L: 1 [(α913'' -> α910'') ~ (α912'' -> [α909'']), [(α913'' -> α910'') - (α910'' -> (α913'' -> α910'')) ~ (α911'' -> (α912'' -> [α909''])) - (α912'' -> [α909'']), L: 0 [(α910'' -> (α913'' -> α910'')) ~ (α911'' -> (α912'' -> [α909''])), (α910'' -> (α913'' -> α910'')) :> (α911'' -> (α912'' -> [α909'']))]]]], α909'' :> α908'', α908'' :> ([[α907'']], [[α878'']],)]], α907'' :> α840'', α840'' <: list[α884'']] +//│ L: 3 [([α951'], [[[α809'']]],) ~ list[α814''], ([α951'], [[[α809'']]],) <: α813'', α813'' <: α839'', [α839'' - ([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],) - α840'', L: 0 [([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],), ([[α839'']], [[list[α841'']]],) <: α882'', α882'' <: α883'', α883'' <: ([α840''], [α880''],)]], α840'' <: α907'', [α907'' - ([[α907'']], [[α878'']],) ~ ([α879''], [α877''],) - α879'', L: 2 [([[α907'']], [[α878'']],) ~ ([α879''], [α877''],), ([[α907'']], [[α878'']],) <: α908'', α908'' <: α909'', [α909'' - (α912'' -> [α909'']) ~ (α913'' -> α910'') - α910'', L: 1 [(α912'' -> [α909'']) ~ (α913'' -> α910''), [(α912'' -> [α909'']) - (α911'' -> (α912'' -> [α909''])) ~ (α910'' -> (α913'' -> α910'')) - (α913'' -> α910''), L: 0 [(α911'' -> (α912'' -> [α909''])) ~ (α910'' -> (α913'' -> α910'')), (α911'' -> (α912'' -> [α909''])) <: (α910'' -> (α913'' -> α910''))]]]], α910'' <: ([α879''], [α877''],)]], [α879'' - ([α879''], [α877''],) ~ ([[α907'']], [[α878'']],) - α907'', L: 2 [([α879''], [α877''],) ~ ([[α907'']], [[α878'']],), ([α879''], [α877''],) :> α910'', [α910'' - (α913'' -> α910'') ~ (α912'' -> [α909'']) - α909'', L: 1 [(α913'' -> α910'') ~ (α912'' -> [α909'']), [(α913'' -> α910'') - (α910'' -> (α913'' -> α910'')) ~ (α911'' -> (α912'' -> [α909''])) - (α912'' -> [α909'']), L: 0 [(α910'' -> (α913'' -> α910'')) ~ (α911'' -> (α912'' -> [α909''])), (α910'' -> (α913'' -> α910'')) :> (α911'' -> (α912'' -> [α909'']))]]]], α909'' :> α908'', α908'' :> ([[α907'']], [[α878'']],)]], α907'' :> α840'', [α840'' - ([α840''], [α880''],) ~ ([[α839'']], [[list[α841'']]],) - α839'', L: 0 [([α840''], [α880''],) ~ ([[α839'']], [[list[α841'']]],), ([α840''], [α880''],) :> α883'', α883'' :> α882'', α882'' :> ([[α839'']], [[list[α841'']]],)]], α839'' <: list[α814'']] +//│ L: 2 [([[int]], [[list['a1109']]],) ~ list['a982'], ([[int]], [[list['a1109']]],) <: α971', [α971' - (α972' -> α971') ~ (α976' -> α979') - α979', L: 1 [(α972' -> α971') ~ (α976' -> α979'), [(α972' -> α971') - (α971' -> (α972' -> α971')) ~ (α973' -> (α976' -> α979')) - (α976' -> α979'), L: 0 [(α971' -> (α972' -> α971')) ~ (α973' -> (α976' -> α979')), (α971' -> (α972' -> α971')) :> (α973' -> (α976' -> α979'))]]]], α979' :> α981', α981' :> α980', α980' :> list['a982']] +//│ L: 0 [([α951'], [[[α809'']]],) ~ list[α814''], ([α951'], [[[α809'']]],) <: α813'', α813'' <: α839'', α839'' <: list[α814'']] +//│ L: 1 [([α951'], [[[α809'']]],) ~ list[α838''], ([α951'], [[[α809'']]],) <: α813'', α813'' <: α839'', [α839'' - ([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],) - α840'', L: 0 [([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],), ([[α839'']], [[list[α841'']]],) <: α882'', α882'' <: α883'', α883'' <: ([α840''], [α880''],)]], α840'' <: α907'', α907'' <: list[α838'']] +//│ L: 0 [(α938'' -> α876'') ~ list['a812''], (α938'' -> α876'') <: α810'', α810'' :> list['a812'']] +//│ L: 2 [([[int]], [[list['a1109']]],) ~ (α983' -> α993'), ([[int]], [[list['a1109']]],) <: α971', [α971' - (α972' -> α971') ~ (α976' -> α979') - α979', L: 1 [(α972' -> α971') ~ (α976' -> α979'), [(α972' -> α971') - (α971' -> (α972' -> α971')) ~ (α973' -> (α976' -> α979')) - (α976' -> α979'), L: 0 [(α971' -> (α972' -> α971')) ~ (α973' -> (α976' -> α979')), (α971' -> (α972' -> α971')) :> (α973' -> (α976' -> α979'))]]]], α979' :> α981', α981' :> α980', α980' :> (α983' -> α993')] +//│ L: 2 [list['a982'] ~ (α983' -> α993'), list['a982'] <: α980', α980' <: α981', α981' <: α979', [α979' - (α976' -> α979') ~ (α972' -> α971') - α971', L: 1 [(α976' -> α979') ~ (α972' -> α971'), [(α976' -> α979') - (α973' -> (α976' -> α979')) ~ (α971' -> (α972' -> α971')) - (α972' -> α971'), L: 0 [(α973' -> (α976' -> α979')) ~ (α971' -> (α972' -> α971')), (α973' -> (α976' -> α979')) <: (α971' -> (α972' -> α971'))]]]], [α971' - (α972' -> α971') ~ (α976' -> α979') - α979', L: 1 [(α972' -> α971') ~ (α976' -> α979'), [(α972' -> α971') - (α971' -> (α972' -> α971')) ~ (α973' -> (α976' -> α979')) - (α976' -> α979'), L: 0 [(α971' -> (α972' -> α971')) ~ (α973' -> (α976' -> α979')), (α971' -> (α972' -> α971')) :> (α973' -> (α976' -> α979'))]]]], α979' :> α981', α981' :> α980', α980' :> (α983' -> α993')] +//│ L: 1 [([α951'], [[[α809'']]],) ~ list[α814''], ([α951'], [[[α809'']]],) <: α813'', α813'' <: α839'', [α839'' - ([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],) - α840'', L: 0 [([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],), ([[α839'']], [[list[α841'']]],) <: α882'', α882'' <: α883'', α883'' <: ([α840''], [α880''],)]], [α840'' - ([α840''], [α880''],) ~ ([[α839'']], [[list[α841'']]],) - α839'', L: 0 [([α840''], [α880''],) ~ ([[α839'']], [[list[α841'']]],), ([α840''], [α880''],) :> α883'', α883'' :> α882'', α882'' :> ([[α839'']], [[list[α841'']]],)]], α839'' <: list[α814'']] +//│ L: 3 [([α951'], [[[α809'']]],) ~ list[α838''], ([α951'], [[[α809'']]],) <: α813'', α813'' <: α839'', [α839'' - ([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],) - α840'', L: 0 [([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],), ([[α839'']], [[list[α841'']]],) <: α882'', α882'' <: α883'', α883'' <: ([α840''], [α880''],)]], α840'' <: α907'', [α907'' - ([[α907'']], [[α878'']],) ~ ([α879''], [α877''],) - α879'', L: 2 [([[α907'']], [[α878'']],) ~ ([α879''], [α877''],), ([[α907'']], [[α878'']],) <: α908'', α908'' <: α909'', [α909'' - (α912'' -> [α909'']) ~ (α913'' -> α910'') - α910'', L: 1 [(α912'' -> [α909'']) ~ (α913'' -> α910''), [(α912'' -> [α909'']) - (α911'' -> (α912'' -> [α909''])) ~ (α910'' -> (α913'' -> α910'')) - (α913'' -> α910''), L: 0 [(α911'' -> (α912'' -> [α909''])) ~ (α910'' -> (α913'' -> α910'')), (α911'' -> (α912'' -> [α909''])) <: (α910'' -> (α913'' -> α910''))]]]], α910'' <: ([α879''], [α877''],)]], [α879'' - ([α879''], [α877''],) ~ ([[α907'']], [[α878'']],) - α907'', L: 2 [([α879''], [α877''],) ~ ([[α907'']], [[α878'']],), ([α879''], [α877''],) :> α910'', [α910'' - (α913'' -> α910'') ~ (α912'' -> [α909'']) - α909'', L: 1 [(α913'' -> α910'') ~ (α912'' -> [α909'']), [(α913'' -> α910'') - (α910'' -> (α913'' -> α910'')) ~ (α911'' -> (α912'' -> [α909''])) - (α912'' -> [α909'']), L: 0 [(α910'' -> (α913'' -> α910'')) ~ (α911'' -> (α912'' -> [α909''])), (α910'' -> (α913'' -> α910'')) :> (α911'' -> (α912'' -> [α909'']))]]]], α909'' :> α908'', α908'' :> ([[α907'']], [[α878'']],)]], α907'' <: list[α838'']] +//│ L: 3 [([α951'], [[[α809'']]],) ~ list[α815''], ([α951'], [[[α809'']]],) <: α813'', α813'' <: α839'', [α839'' - ([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],) - α840'', L: 0 [([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],), ([[α839'']], [[list[α841'']]],) <: α882'', α882'' <: α883'', α883'' <: ([α840''], [α880''],)]], α840'' <: α907'', [α907'' - ([[α907'']], [[α878'']],) ~ ([α879''], [α877''],) - α879'', L: 2 [([[α907'']], [[α878'']],) ~ ([α879''], [α877''],), ([[α907'']], [[α878'']],) <: α908'', α908'' <: α909'', [α909'' - (α912'' -> [α909'']) ~ (α913'' -> α910'') - α910'', L: 1 [(α912'' -> [α909'']) ~ (α913'' -> α910''), [(α912'' -> [α909'']) - (α911'' -> (α912'' -> [α909''])) ~ (α910'' -> (α913'' -> α910'')) - (α913'' -> α910''), L: 0 [(α911'' -> (α912'' -> [α909''])) ~ (α910'' -> (α913'' -> α910'')), (α911'' -> (α912'' -> [α909''])) <: (α910'' -> (α913'' -> α910''))]]]], α910'' <: ([α879''], [α877''],)]], [α879'' - ([α879''], [α877''],) ~ ([[α907'']], [[α878'']],) - α907'', L: 2 [([α879''], [α877''],) ~ ([[α907'']], [[α878'']],), ([α879''], [α877''],) :> α910'', [α910'' - (α913'' -> α910'') ~ (α912'' -> [α909'']) - α909'', L: 1 [(α913'' -> α910'') ~ (α912'' -> [α909'']), [(α913'' -> α910'') - (α910'' -> (α913'' -> α910'')) ~ (α911'' -> (α912'' -> [α909''])) - (α912'' -> [α909'']), L: 0 [(α910'' -> (α913'' -> α910'')) ~ (α911'' -> (α912'' -> [α909''])), (α910'' -> (α913'' -> α910'')) :> (α911'' -> (α912'' -> [α909'']))]]]], α909'' :> α908'', α908'' :> ([[α907'']], [[α878'']],)]], α907'' :> α840'', [α840'' - ([α840''], [α880''],) ~ ([[list[α815'']]], [[α866'']],) - list[α815''], L: 0 [([α840''], [α880''],) ~ ([[list[α815'']]], [[α866'']],), ([α840''], [α880''],) :> α883'', α883'' :> ([[list[α815'']]], [[α866'']],)]]] +//│ L: 2 [(α983' -> α993') ~ ([α1111'], [α1112'],), (α983' -> α993') <: α980', α980' <: α981', α981' <: α979', [α979' - (α976' -> α979') ~ (α972' -> α971') - α971', L: 1 [(α976' -> α979') ~ (α972' -> α971'), [(α976' -> α979') - (α973' -> (α976' -> α979')) ~ (α971' -> (α972' -> α971')) - (α972' -> α971'), L: 0 [(α973' -> (α976' -> α979')) ~ (α971' -> (α972' -> α971')), (α973' -> (α976' -> α979')) <: (α971' -> (α972' -> α971'))]]]], α971' <: ([α1111'], [α1112'],)] +//│ L: 2 [list['a982'] ~ ([α974'], [α975'],), list['a982'] <: α980', α980' <: α981', α981' <: α979', [α979' - (α976' -> α979') ~ (α972' -> α971') - α971', L: 1 [(α976' -> α979') ~ (α972' -> α971'), [(α976' -> α979') - (α973' -> (α976' -> α979')) ~ (α971' -> (α972' -> α971')) - (α972' -> α971'), L: 0 [(α973' -> (α976' -> α979')) ~ (α971' -> (α972' -> α971')), (α973' -> (α976' -> α979')) <: (α971' -> (α972' -> α971'))]]]], [α971' - (α971' -> (α972' -> α971')) ~ (α973' -> (α976' -> α979')) - α973', L: 0 [(α971' -> (α972' -> α971')) ~ (α973' -> (α976' -> α979')), (α971' -> (α972' -> α971')) :> (α973' -> (α976' -> α979'))]], α973' <: ([α974'], [α975'],)] +//│ L: 2 [(α983' -> α993') ~ ([α974'], [α975'],), (α983' -> α993') <: α980', α980' <: α981', α981' <: α979', [α979' - (α976' -> α979') ~ (α972' -> α971') - α971', L: 1 [(α976' -> α979') ~ (α972' -> α971'), [(α976' -> α979') - (α973' -> (α976' -> α979')) ~ (α971' -> (α972' -> α971')) - (α972' -> α971'), L: 0 [(α973' -> (α976' -> α979')) ~ (α971' -> (α972' -> α971')), (α973' -> (α976' -> α979')) <: (α971' -> (α972' -> α971'))]]]], [α971' - (α971' -> (α972' -> α971')) ~ (α973' -> (α976' -> α979')) - α973', L: 0 [(α971' -> (α972' -> α971')) ~ (α973' -> (α976' -> α979')), (α971' -> (α972' -> α971')) :> (α973' -> (α976' -> α979'))]], α973' <: ([α974'], [α975'],)] +//│ L: 2 [list[α943'] ~ (α969' -> α970'), list[α943'] :> α941', [α941' - (α941' -> α944') ~ ([α797'] -> α951') - α797', L: 1 [(α941' -> α944') ~ ([α797'] -> α951'), [(α941' -> α944') - (α940' -> (α941' -> α944')) ~ (['a811'] -> α950') - α950', L: 0 [(α940' -> (α941' -> α944')) ~ (['a811'] -> α950'), (α940' -> (α941' -> α944')) <: mulByDigit939', mulByDigit939' <: (['a811'] -> α950')]], α950' <: ([α797'] -> α951')]], α797' <: (α969' -> α970')] +//│ L: 3 [([α951'], [[[α809'']]],) ~ list[α881''], ([α951'], [[[α809'']]],) <: α813'', α813'' <: α839'', [α839'' - ([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],) - α840'', L: 0 [([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],), ([[α839'']], [[list[α841'']]],) <: α882'', α882'' <: α883'', α883'' <: ([α840''], [α880''],)]], α840'' <: α907'', [α907'' - ([[α907'']], [[α878'']],) ~ ([[list[α881'']]], [[α878'']],) - list[α881''], L: 2 [([[α907'']], [[α878'']],) ~ ([[list[α881'']]], [[α878'']],), ([[α907'']], [[α878'']],) <: α908'', α908'' <: α909'', [α909'' - (α912'' -> [α909'']) ~ (α913'' -> α910'') - α910'', L: 1 [(α912'' -> [α909'']) ~ (α913'' -> α910''), [(α912'' -> [α909'']) - (α911'' -> (α912'' -> [α909''])) ~ (α910'' -> (α913'' -> α910'')) - (α913'' -> α910''), L: 0 [(α911'' -> (α912'' -> [α909''])) ~ (α910'' -> (α913'' -> α910'')), (α911'' -> (α912'' -> [α909''])) <: (α910'' -> (α913'' -> α910''))]]]], [α910'' - (α913'' -> α910'') ~ (α912'' -> [α909'']) - α909'', L: 1 [(α913'' -> α910'') ~ (α912'' -> [α909'']), [(α913'' -> α910'') - (α910'' -> (α913'' -> α910'')) ~ (α911'' -> (α912'' -> [α909''])) - (α912'' -> [α909'']), L: 0 [(α910'' -> (α913'' -> α910'')) ~ (α911'' -> (α912'' -> [α909''])), (α910'' -> (α913'' -> α910'')) :> (α911'' -> (α912'' -> [α909'']))]]]], α909'' :> ([[list[α881'']]], [[α878'']],)]]] +//│ L: 1 [([α951'], [[[α809'']]],) ~ list[α884''], ([α951'], [[[α809'']]],) <: α813'', α813'' <: α839'', [α839'' - ([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],) - α840'', L: 0 [([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],), ([[α839'']], [[list[α841'']]],) <: α882'', α882'' <: α883'', α883'' <: ([α840''], [α880''],)]], α840'' <: list[α884'']] +//│ L: 0 [([α951'], [[[α809'']]],) ~ list[α815''], ([α951'], [[[α809'']]],) <: α813'', α813'' <: α839'', α839'' <: list[α815'']] +//│ L: 1 [([α951'], [[[α809'']]],) ~ list[α815''], ([α951'], [[[α809'']]],) <: α813'', α813'' <: α839'', [α839'' - ([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],) - α840'', L: 0 [([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],), ([[α839'']], [[list[α841'']]],) <: α882'', α882'' <: α883'', α883'' <: ([α840''], [α880''],)]], [α840'' - ([α840''], [α880''],) ~ ([[list[α815'']]], [[α866'']],) - list[α815''], L: 0 [([α840''], [α880''],) ~ ([[list[α815'']]], [[α866'']],), ([α840''], [α880''],) :> α883'', α883'' :> ([[list[α815'']]], [[α866'']],)]]] +//│ L: 2 [list['a982'] ~ ([α1111'], [α1112'],), list['a982'] <: α980', α980' <: α981', α981' <: α979', [α979' - (α976' -> α979') ~ (α972' -> α971') - α971', L: 1 [(α976' -> α979') ~ (α972' -> α971'), [(α976' -> α979') - (α973' -> (α976' -> α979')) ~ (α971' -> (α972' -> α971')) - (α972' -> α971'), L: 0 [(α973' -> (α976' -> α979')) ~ (α971' -> (α972' -> α971')), (α973' -> (α976' -> α979')) <: (α971' -> (α972' -> α971'))]]]], α971' <: ([α1111'], [α1112'],)] +//│ L: 1 [([α951'], [[[α809'']]],) ~ list[α881''], ([α951'], [[[α809'']]],) <: α813'', α813'' <: α839'', [α839'' - ([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],) - α840'', L: 0 [([[α839'']], [[list[α841'']]],) ~ ([α840''], [α880''],), ([[α839'']], [[list[α841'']]],) <: α882'', α882'' <: α883'', α883'' <: ([α840''], [α880''],)]], α840'' <: α907'', [α907'' - ([[α907'']], [[α878'']],) ~ ([[list[α881'']]], [[α878'']],) - list[α881''], L: 0 [([[α907'']], [[α878'']],) ~ ([[list[α881'']]], [[α878'']],), ([[α907'']], [[α878'']],) <: α908'', α908'' <: α909'', α909'' :> ([[list[α881'']]], [[α878'']],)]]] +//│ L: 2 [list['a942'] ~ (α969' -> α970'), [list['a942'] - ([list['a942']] -> α948') ~ ([α797'] -> α951') - α797', L: 1 [([list['a942']] -> α948') ~ ([α797'] -> α951'), ([list['a942']] -> α948') :> α949', [α949' - ([α940'] -> α949') ~ (['a811'] -> α950') - α950', L: 0 [([α940'] -> α949') ~ (['a811'] -> α950'), ([α940'] -> α949') :> mulByDigit939', mulByDigit939' <: (['a811'] -> α950')]], α950' <: ([α797'] -> α951')]], α797' <: (α969' -> α970')] // file 335 let fixpointHelper f = @@ -3187,7 +3185,7 @@ let fixpoint (f,b) = wwhile ((fixpointHelper f), b);; //│ fixpoint: ('a, 'b,) -> 'b //│ U max: 10, total: 58 //│ UERR 1 errors -//│ L: 2 [([α1207'] -> α1212') ~ ([[[α1215']]], [[bool]],), ([α1207'] -> α1212') :> α1206', [α1206' - ([α1206'], [α1207'],) ~ ([[α1217']], [[α1204']],) - α1217', L: 1 [([α1206'], [α1207'],) ~ ([[α1217']], [[α1204']],), [([α1206'], [α1207'],) - (([α1206'], [α1207'],) -> α1211') ~ (([[α1217']], [[α1204']],) -> α1219') - ([[α1217']], [[α1204']],), L: 0 [(([α1206'], [α1207'],) -> α1211') ~ (([[α1217']], [[α1204']],) -> α1219'), (([α1206'], [α1207'],) -> α1211') <: wwhile1205', wwhile1205' <: (([[α1217']], [[α1204']],) -> α1219')]]]], α1217' :> α1218', α1218' :> ([[[α1215']]], [[bool]],)] +//│ L: 2 [([α1143'] -> α1148') ~ ([[[α1151']]], [[bool]],), ([α1143'] -> α1148') :> α1142', [α1142' - ([α1142'], [α1143'],) ~ ([[α1153']], [[α1140']],) - α1153', L: 1 [([α1142'], [α1143'],) ~ ([[α1153']], [[α1140']],), [([α1142'], [α1143'],) - (([α1142'], [α1143'],) -> α1147') ~ (([[α1153']], [[α1140']],) -> α1155') - ([[α1153']], [[α1140']],), L: 0 [(([α1142'], [α1143'],) -> α1147') ~ (([[α1153']], [[α1140']],) -> α1155'), (([α1142'], [α1143'],) -> α1147') <: wwhile1141', wwhile1141' <: (([[α1153']], [[α1140']],) -> α1155')]]]], α1153' :> α1154', α1154' :> ([[[α1151']]], [[bool]],)] // file 3 mod @@ -3243,7 +3241,7 @@ let bigAdd l1 l2 = //│ ^^^^^^^^^^^^^^^ //│ [ERROR] Type `_ * _` does not match `_ list` //│ -//│ (_ * _) ~~~~ (?a) ~~~~ (?b) ~~~~ (?c) ---> (?d) <--- (_ list) +//│ (_ * _) ~~~~ (?b) ~~~~ (?c) ~~~~ (?d) ---> (?a) <--- (_ list) //│ //│ ◉ (_ * _) comes from //│ - lib. let List.combine: 'a list -> 'b list -> ('a * 'b) list @@ -3254,11 +3252,11 @@ let bigAdd l1 l2 = //│ │ - l.25 let args = List.rev (List.combine l1 l2) in //│ │ ^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a list) comes from +//│ ◉ (?b list) comes from //│ - lib. let List.rev: 'a list -> 'a list //│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from +//│ ◉ (?b) is assumed for +//│ ◉ (?b list) comes from //│ │ - lib. let List.rev: 'a list -> 'a list //│ │ ^^^^^^^ //│ │ - l.25 let args = List.rev (List.combine l1 l2) in @@ -3266,36 +3264,36 @@ let bigAdd l1 l2 = //│ │ - l.26 let (_,res) = List.fold_left f base args in res in //│ │ ^^^^ //│ ▼ -//│ ◉ (?b list) comes from +//│ ◉ (?c list) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^ -//│ ◉ (?b) is assumed for -//│ ◉ (?b -> _) comes from +//│ ◉ (?c) is assumed for +//│ ◉ (?c -> _) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (_ -> ?b -> _) comes from +//│ ◉ (_ -> ?c -> _) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ //│ │ - l.26 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ │ -//│ ◉ (_ -> ?c -> _) comes from +//│ ◉ (_ -> ?d -> _) comes from //│ - l.14 let f a x = //│ ^^^^^ //│ let (carry,currentSum) = a in ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?c -> _) comes from +//│ ◉ (?d -> _) comes from //│ - l.14 let f a x = //│ ^^^ //│ let (carry,currentSum) = a in ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?c) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.14 let f a x = //│ │ ^ //│ │ - l.16 if x = [] //│ │ ^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.16 if x = [] //│ │ ^^ //│ │ @@ -3304,25 +3302,25 @@ let bigAdd l1 l2 = //│ ^^ //│ [ERROR] Type `_ list` does not match `_ * _` //│ -//│ (_ list) ---> (?c) <--- (?b) ~~~~ (?a) ~~~~ (?b) ---> (_ * _) +//│ (_ list) ---> (?a) <--- (?c) ~~~~ (?b) ~~~~ (?c) ---> (_ * _) //│ //│ ◉ (_ list) comes from //│ │ - l.16 if x = [] //│ │ ^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.16 if x = [] //│ │ ^ //│ │ -//│ ◉ (?b) is assumed for +//│ ◉ (?c) is assumed for //│ - l.14 let f a x = //│ ^ -//│ ◉ (?b -> _) comes from +//│ ◉ (?c -> _) comes from //│ - l.14 let f a x = //│ ^^^ //│ let (carry,currentSum) = a in ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?b -> _) comes from +//│ ◉ (_ -> ?c -> _) comes from //│ │ - l.14 let f a x = //│ │ ^^^^^ //│ │ let (carry,currentSum) = a in ... @@ -3330,33 +3328,33 @@ let bigAdd l1 l2 = //│ │ - l.26 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ ▼ -//│ ◉ (_ -> ?a -> _) comes from +//│ ◉ (_ -> ?b -> _) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (?a -> _) comes from +//│ ◉ (?b -> _) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a -> _) comes from +//│ ◉ (?b) is assumed for +//│ ◉ (?b -> _) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^ -//│ ◉ (_ -> ?a -> _) comes from +//│ ◉ (_ -> ?b -> _) comes from //│ ▲ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ │ ^^^^^^^^^^^^^^ //│ │ - l.26 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ │ -//│ ◉ (_ -> ?b -> _) comes from +//│ ◉ (_ -> ?c -> _) comes from //│ - l.14 let f a x = //│ ^^^^^ //│ let (carry,currentSum) = a in ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?b -> _) comes from +//│ ◉ (?c -> _) comes from //│ - l.14 let f a x = //│ ^^^ //│ let (carry,currentSum) = a in ... //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?b) is assumed for +//│ ◉ (?c) is assumed for //│ │ - l.14 let f a x = //│ │ ^ //│ │ - l.19 (let (toSum1,toSum2) = x in @@ -3369,11 +3367,11 @@ let bigAdd l1 l2 = //│ padZero: list[int] -> list[int] -> (list[int], list[int],) //│ removeZero: list[int] -> list[int] //│ bigAdd: list[int] -> list[int] -> list[int] -//│ U max: 35, total: 551 +//│ U max: 33, total: 532 //│ UERR 3 errors -//│ L: 0 [list['a1304'''] ~ ([α1308'''], [α1309'''],), list['a1304'''] <: α1303''', α1303''' :> α1299''', α1299''' <: ([α1308'''], [α1309'''],)] -//│ L: 2 [([α1313''], [α1314''],) ~ list['a1325''], [([α1313''], [α1314''],) - list[([α1313''], [α1314''],)] ~ list[α1331''] - α1331'', L: 0 [list[([α1313''], [α1314''],)] ~ list[α1331''], list[([α1313''], [α1314''],)] <: list[α1331'']]], [α1331'' - list[α1331''] ~ list[α1316''] - α1316'', L: 0 [list[α1331''] ~ list[α1316''], list[α1331''] <: list[α1316'']]], [α1316'' - (α1316'' -> α1315'') ~ (α1322'' -> α1327'') - α1322'', L: 1 [(α1316'' -> α1315'') ~ (α1322'' -> α1327''), [(α1316'' -> α1315'') - (α1315'' -> (α1316'' -> α1315'')) ~ (α1317'' -> (α1322'' -> α1327'')) - (α1322'' -> α1327''), L: 0 [(α1315'' -> (α1316'' -> α1315'')) ~ (α1317'' -> (α1322'' -> α1327'')), (α1315'' -> (α1316'' -> α1315'')) :> (α1317'' -> (α1322'' -> α1327''))]]]], α1322'' <: α1326'', α1326'' :> list['a1325'']] -//│ L: 2 [list['a1325''] ~ ([α1323''], [α1324''],), list['a1325''] <: α1326'', α1326'' :> α1322'', [α1322'' - (α1322'' -> α1327'') ~ (α1316'' -> α1315'') - α1316'', L: 1 [(α1322'' -> α1327'') ~ (α1316'' -> α1315''), [(α1322'' -> α1327'') - (α1317'' -> (α1322'' -> α1327'')) ~ (α1315'' -> (α1316'' -> α1315'')) - (α1316'' -> α1315''), L: 0 [(α1317'' -> (α1322'' -> α1327'')) ~ (α1315'' -> (α1316'' -> α1315'')), (α1317'' -> (α1322'' -> α1327'')) <: (α1315'' -> (α1316'' -> α1315''))]]]], [α1316'' - (α1316'' -> α1315'') ~ (α1322'' -> α1327'') - α1322'', L: 1 [(α1316'' -> α1315'') ~ (α1322'' -> α1327''), [(α1316'' -> α1315'') - (α1315'' -> (α1316'' -> α1315'')) ~ (α1317'' -> (α1322'' -> α1327'')) - (α1322'' -> α1327''), L: 0 [(α1315'' -> (α1316'' -> α1315'')) ~ (α1317'' -> (α1322'' -> α1327'')), (α1315'' -> (α1316'' -> α1315'')) :> (α1317'' -> (α1322'' -> α1327''))]]]], α1322'' <: ([α1323''], [α1324''],)] +//│ L: 2 [list['a1263''] ~ ([α1261''], [α1262''],), list['a1263''] <: α1264'', α1264'' :> α1260'', [α1260'' - (α1260'' -> α1257'') ~ (α1252'' -> α1251'') - α1252'', L: 1 [(α1260'' -> α1257'') ~ (α1252'' -> α1251''), [(α1260'' -> α1257'') - (α1253'' -> (α1260'' -> α1257'')) ~ (α1251'' -> (α1252'' -> α1251'')) - (α1252'' -> α1251''), L: 0 [(α1253'' -> (α1260'' -> α1257'')) ~ (α1251'' -> (α1252'' -> α1251'')), (α1253'' -> (α1260'' -> α1257'')) <: (α1251'' -> (α1252'' -> α1251''))]]]], [α1252'' - (α1252'' -> α1251'') ~ (α1260'' -> α1257'') - α1260'', L: 1 [(α1252'' -> α1251'') ~ (α1260'' -> α1257''), [(α1252'' -> α1251'') - (α1251'' -> (α1252'' -> α1251'')) ~ (α1253'' -> (α1260'' -> α1257'')) - (α1260'' -> α1257''), L: 0 [(α1251'' -> (α1252'' -> α1251'')) ~ (α1253'' -> (α1260'' -> α1257'')), (α1251'' -> (α1252'' -> α1251'')) :> (α1253'' -> (α1260'' -> α1257''))]]]], α1260'' <: ([α1261''], [α1262''],)] +//│ L: 2 [([α1249''], [α1250''],) ~ list['a1263''], [([α1249''], [α1250''],) - list[([α1249''], [α1250''],)] ~ list[α1266''] - α1266'', L: 0 [list[([α1249''], [α1250''],)] ~ list[α1266''], list[([α1249''], [α1250''],)] <: list[α1266'']]], [α1266'' - list[α1266''] ~ list[α1252''] - α1252'', L: 0 [list[α1266''] ~ list[α1252''], list[α1266''] <: list[α1252'']]], [α1252'' - (α1252'' -> α1251'') ~ (α1260'' -> α1257'') - α1260'', L: 1 [(α1252'' -> α1251'') ~ (α1260'' -> α1257''), [(α1252'' -> α1251'') - (α1251'' -> (α1252'' -> α1251'')) ~ (α1253'' -> (α1260'' -> α1257'')) - (α1260'' -> α1257''), L: 0 [(α1251'' -> (α1252'' -> α1251'')) ~ (α1253'' -> (α1260'' -> α1257'')), (α1251'' -> (α1252'' -> α1251'')) :> (α1253'' -> (α1260'' -> α1257''))]]]], α1260'' <: α1264'', α1264'' :> list['a1263'']] +//│ L: 0 [list['a1240'''] ~ ([α1244'''], [α1245'''],), list['a1240'''] <: α1239''', α1239''' :> α1235''', α1235''' <: ([α1244'''], [α1245'''],)] // file 1935 let rec clone x n = if n <= 0 then [] else x :: (clone x (n - 1));; @@ -3413,7 +3411,7 @@ let bigAdd l1 l2 = //│ ^^^^^^^ //│ [ERROR] Type `int` does not match `_ * _` //│ -//│ (int) <--- (?a) ~~~~ (?b) ---> (_ * _) +//│ (int) <--- (?b) ~~~~ (?a) ---> (_ * _) //│ //│ ◉ (int) comes from //│ ▲ - lib. let (+): int -> int -> int @@ -3421,19 +3419,19 @@ let bigAdd l1 l2 = //│ │ - l.14 let f a x = (a + x) mod 10 in //│ │ ^ //│ │ -//│ ◉ (?a) is assumed for +//│ ◉ (?b) is assumed for //│ - l.14 let f a x = (a + x) mod 10 in //│ ^ -//│ ◉ (?a -> _ -> int) comes from +//│ ◉ (?b -> _ -> int) comes from //│ │ - l.14 let f a x = (a + x) mod 10 in //│ │ ^^^^^^^^^^^^^^^^^^^^ //│ │ - l.17 let (_,res) = List.fold_left f base args in res in //│ │ ^ //│ ▼ -//│ ◉ (?b -> _ -> ?b) comes from +//│ ◉ (?a -> _ -> ?a) comes from //│ - lib. let List.fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a //│ ^^^^^^^^^^^^^^ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.17 let (_,res) = List.fold_left f base args in res in //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ @@ -3476,11 +3474,11 @@ let bigAdd l1 l2 = //│ padZero: list[int] -> list[int] -> (list[int], list[int],) //│ removeZero: list[int] -> list[int] //│ bigAdd: list[int] -> list[int] -> list[int] -//│ U max: 63, total: 556 +//│ U max: 63, total: 550 //│ UERR 3 errors -//│ L: 0 [int ~ ([α1493''], [α1494''],), int <: α1486'', α1486'' <: ([α1493''], [α1494''],)] -//│ L: 2 [int ~ ([α1493''], [α1494''],), [int - (α1489'' -> [int]) ~ (α1487'' -> α1486'') - α1486'', L: 1 [(α1489'' -> [int]) ~ (α1487'' -> α1486''), [(α1489'' -> [int]) - (α1488'' -> (α1489'' -> [int])) ~ (α1486'' -> (α1487'' -> α1486'')) - (α1487'' -> α1486''), L: 0 [(α1488'' -> (α1489'' -> [int])) ~ (α1486'' -> (α1487'' -> α1486'')), (α1488'' -> (α1489'' -> [int])) <: (α1486'' -> (α1487'' -> α1486''))]]]], α1486'' <: ([α1493''], [α1494''],)] -//│ L: 1 [int ~ ([α1493''], [α1494''],), int :> α1488'', [α1488'' - (α1488'' -> (α1489'' -> [int])) ~ (α1486'' -> (α1487'' -> α1486'')) - α1486'', L: 0 [(α1488'' -> (α1489'' -> [int])) ~ (α1486'' -> (α1487'' -> α1486'')), (α1488'' -> (α1489'' -> [int])) <: (α1486'' -> (α1487'' -> α1486''))]], α1486'' <: ([α1493''], [α1494''],)] +//│ L: 0 [int ~ ([α1427''], [α1428''],), int <: α1420'', α1420'' <: ([α1427''], [α1428''],)] +//│ L: 1 [int ~ ([α1427''], [α1428''],), int :> α1422'', [α1422'' - (α1422'' -> (α1423'' -> [int])) ~ (α1420'' -> (α1421'' -> α1420'')) - α1420'', L: 0 [(α1422'' -> (α1423'' -> [int])) ~ (α1420'' -> (α1421'' -> α1420'')), (α1422'' -> (α1423'' -> [int])) <: (α1420'' -> (α1421'' -> α1420''))]], α1420'' <: ([α1427''], [α1428''],)] +//│ L: 2 [int ~ ([α1427''], [α1428''],), [int - (α1423'' -> [int]) ~ (α1421'' -> α1420'') - α1420'', L: 1 [(α1423'' -> [int]) ~ (α1421'' -> α1420''), [(α1423'' -> [int]) - (α1422'' -> (α1423'' -> [int])) ~ (α1420'' -> (α1421'' -> α1420'')) - (α1421'' -> α1420''), L: 0 [(α1422'' -> (α1423'' -> [int])) ~ (α1420'' -> (α1421'' -> α1420'')), (α1422'' -> (α1423'' -> [int])) <: (α1420'' -> (α1421'' -> α1420''))]]]], α1420'' <: ([α1427''], [α1428''],)] @@ -3491,26 +3489,26 @@ let rec wwhile (f,b) = match f b with | (b',c') -> if c' then wwhile (f, b') else b';; //│ [ERROR] Type `_ * _` does not match `_ -> (_ * bool)` //│ -//│ (_ * _) <--- (?b) ~~~~ (_ -> (_ * bool)) +//│ (_ * _) <--- (?a) ~~~~ (_ -> (_ * bool)) //│ //│ ◉ (_ * _) comes from //│ ▲ - l.-351 match f b with | (num,expr) -> if expr then wwhile (f, num) else num;; //│ │ ^^^^^^^^^^ //│ │ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ - l.-351 match f b with | (num,expr) -> if expr then wwhile (f, num) else num;; //│ ^^^ -//│ ◉ (_ -> ?b) comes from +//│ ◉ (_ -> ?a) comes from //│ ▲ - l.-351 match f b with | (num,expr) -> if expr then wwhile (f, num) else num;; //│ │ ^ //│ │ -//│ ◉ (?a) is assumed for +//│ ◉ (?b) is assumed for //│ - l.-352let rec wwhile (f,b) = //│ ^ -//│ ◉ (?a * _) comes from +//│ ◉ (?b * _) comes from //│ - l.-352let rec wwhile (f,b) = //│ ^^^^^ -//│ ◉ ((?a * _) -> _) comes from +//│ ◉ ((?b * _) -> _) comes from //│ │ - l.-352let rec wwhile (f,b) = //│ │ ^^^^^^^ //│ │ match f b with | (num,expr) -> if expr then wwhile (f, num) else num;; @@ -3543,7 +3541,7 @@ let rec wwhile (f,b) = //│ 'wwhile = ('a -> ('a, bool,), 'a,) -> 'b, ('a -> ('a, bool,), 'b,) -> 'b //│ U max: 10, total: 70 //│ UERR 1 errors -//│ L: 3 [([α1571'], [α1576'],) ~ (α1578' -> ([α1581'], [[bool]],)), ([α1571'], [α1576'],) :> α1575', [α1575' - ([α1570'] -> α1575') ~ (α1577' -> (α1578' -> ([α1581'], [[bool]],))) - (α1578' -> ([α1581'], [[bool]],)), L: 2 [([α1570'] -> α1575') ~ (α1577' -> (α1578' -> ([α1581'], [[bool]],))), ([α1570'] -> α1575') :> α1569', [α1569' - ([α1569'], [α1570'],) ~ ([[(α1577' -> (α1578' -> ([α1581'], [[bool]],)))]], [[α1567']],) - (α1577' -> (α1578' -> ([α1581'], [[bool]],))), L: 1 [([α1569'], [α1570'],) ~ ([[(α1577' -> (α1578' -> ([α1581'], [[bool]],)))]], [[α1567']],), [([α1569'], [α1570'],) - (([α1569'], [α1570'],) -> α1574') ~ (([[(α1577' -> (α1578' -> ([α1581'], [[bool]],)))]], [[α1567']],) -> α1582') - ([[(α1577' -> (α1578' -> ([α1581'], [[bool]],)))]], [[α1567']],), L: 0 [(([α1569'], [α1570'],) -> α1574') ~ (([[(α1577' -> (α1578' -> ([α1581'], [[bool]],)))]], [[α1567']],) -> α1582'), (([α1569'], [α1570'],) -> α1574') <: wwhile1568', wwhile1568' <: (([[(α1577' -> (α1578' -> ([α1581'], [[bool]],)))]], [[α1567']],) -> α1582')]]]]]]] +//│ L: 3 [([α1505'], [α1510'],) ~ (α1512' -> ([α1515'], [[bool]],)), ([α1505'], [α1510'],) :> α1509', [α1509' - ([α1504'] -> α1509') ~ (α1511' -> (α1512' -> ([α1515'], [[bool]],))) - (α1512' -> ([α1515'], [[bool]],)), L: 2 [([α1504'] -> α1509') ~ (α1511' -> (α1512' -> ([α1515'], [[bool]],))), ([α1504'] -> α1509') :> α1503', [α1503' - ([α1503'], [α1504'],) ~ ([[(α1511' -> (α1512' -> ([α1515'], [[bool]],)))]], [[α1501']],) - (α1511' -> (α1512' -> ([α1515'], [[bool]],))), L: 1 [([α1503'], [α1504'],) ~ ([[(α1511' -> (α1512' -> ([α1515'], [[bool]],)))]], [[α1501']],), [([α1503'], [α1504'],) - (([α1503'], [α1504'],) -> α1508') ~ (([[(α1511' -> (α1512' -> ([α1515'], [[bool]],)))]], [[α1501']],) -> α1516') - ([[(α1511' -> (α1512' -> ([α1515'], [[bool]],)))]], [[α1501']],), L: 0 [(([α1503'], [α1504'],) -> α1508') ~ (([[(α1511' -> (α1512' -> ([α1515'], [[bool]],)))]], [[α1501']],) -> α1516'), (([α1503'], [α1504'],) -> α1508') <: wwhile1502', wwhile1502' <: (([[(α1511' -> (α1512' -> ([α1515'], [[bool]],)))]], [[α1501']],) -> α1516')]]]]]]] @@ -3642,9 +3640,9 @@ let rec additivePersistence n = //│ lt10: int -> bool //│ sumList: list[int] -> int //│ additivePersistence: int -> int -//│ U max: 9, total: 157 +//│ U max: 9, total: 137 //│ UERR 1 errors -//│ L: 1 [int ~ ([additivePersistence1637'] -> α1673'), int <: α1658', [α1658' - (α1656' -> α1658') ~ ([list['a1657']] -> α1659') - α1659', L: 0 [(α1656' -> α1658') ~ ([list['a1657']] -> α1659'), (α1656' -> α1658') <: sumList1655', sumList1655' <: ([list['a1657']] -> α1659')]], [α1659' - ([list['a1657']] -> α1659') ~ (α1656' -> α1658') - α1658', L: 0 [([list['a1657']] -> α1659') ~ (α1656' -> α1658'), ([list['a1657']] -> α1659') :> sumList1655', sumList1655' :> (α1656' -> α1658')]], [α1658' - (α1656' -> α1658') ~ ([α1660'] -> α1672') - α1672', L: 0 [(α1656' -> α1658') ~ ([α1660'] -> α1672'), (α1656' -> α1658') <: sumList1655', sumList1655' <: ([α1660'] -> α1672')]], α1672' <: ([additivePersistence1637'] -> α1673')] +//│ L: 1 [int ~ ([additivePersistence1569'] -> α1601'), int <: α1588', [α1588' - (α1586' -> α1588') ~ ([list['a1587']] -> α1589') - α1589', L: 0 [(α1586' -> α1588') ~ ([list['a1587']] -> α1589'), (α1586' -> α1588') <: sumList1585', sumList1585' <: ([list['a1587']] -> α1589')]], [α1589' - ([list['a1587']] -> α1589') ~ (α1586' -> α1588') - α1588', L: 0 [([list['a1587']] -> α1589') ~ (α1586' -> α1588'), ([list['a1587']] -> α1589') :> sumList1585', sumList1585' :> (α1586' -> α1588')]], [α1588' - (α1586' -> α1588') ~ ([α1590'] -> α1600') - α1600', L: 0 [(α1586' -> α1588') ~ ([α1590'] -> α1600'), (α1586' -> α1588') <: sumList1585', sumList1585' <: ([α1590'] -> α1600')]], α1600' <: ([additivePersistence1569'] -> α1601')] @@ -3674,7 +3672,7 @@ let removeDuplicates l = //│ ^ //│ [ERROR] Type `_ -> _` does not match `_ list` //│ -//│ (_ -> _) ~~~~ (?a) ~~~~ (_ list) +//│ (_ -> _) ~~~~ (?a) ---> (_ list) //│ //│ ◉ (_ -> _) comes from //│ - l.1 let rec filter l a = @@ -3697,28 +3695,24 @@ let removeDuplicates l = //│ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in //│ ^^^^^^ //│ ◉ (?a) is assumed for -//│ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in -//│ ^^^^^^^^^^^^^^ -//│ ◉ (_ * ?a) comes from -//│ │ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in -//│ │ ^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (_ * _ list) comes from -//│ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in -//│ ^^^^^^^^^^^^^^^^^^^ +//│ │ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in +//│ │ ^^^^^^^^^^^^^^ +//│ ▼ //│ ◉ (_ list) comes from +//│ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in +//│ ^^^^^^^^^^^^^^^^^^^ //│ [ERROR] Type `_ -> _` does not match `_ list` //│ -//│ (_ -> _) <--- (?c) ~~~~ (?b) ~~~~ (?a) ~~~~ (_ list) +//│ (_ -> _) <--- (?a) ~~~~ (?b) ~~~~ (?c) ---> (_ list) //│ //│ ◉ (_ -> _) comes from //│ ▲ - l.4 | h::t -> if a = h then filter t a else h :: (filter t a);; //│ │ ^^^^^^^^ //│ │ -//│ ◉ (?c) is assumed for +//│ ◉ (?a) is assumed for //│ - l.4 | h::t -> if a = h then filter t a else h :: (filter t a);; //│ ^^^^^^^^ -//│ ◉ (_ list -> ?c) comes from +//│ ◉ (_ list -> ?a) comes from //│ ▲ - l.4 | h::t -> if a = h then filter t a else h :: (filter t a);; //│ │ ^^^^^^ //│ │ - l.1 let rec filter l a = @@ -3744,23 +3738,19 @@ let removeDuplicates l = //│ │ - l.1 let rec filter l a = //│ │ ^^^^^^ //│ ▼ -//│ ◉ (_ -> ?a) comes from +//│ ◉ (_ -> ?c) comes from //│ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in //│ ^^^^^^ -//│ ◉ (?a) is assumed for -//│ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in -//│ ^^^^^^^^^^^^^^ -//│ ◉ (_ * ?a) comes from -//│ │ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in -//│ │ ^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (_ * _ list) comes from -//│ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in -//│ ^^^^^^^^^^^^^^^^^^^ +//│ ◉ (?c) is assumed for +//│ │ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in +//│ │ ^^^^^^^^^^^^^^ +//│ ▼ //│ ◉ (_ list) comes from +//│ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in +//│ ^^^^^^^^^^^^^^^^^^^ //│ [ERROR] Type `_ -> _` does not match `_ list` //│ -//│ (_ -> _) <--- (?b) ~~~~ (?c) ~~~~ (?b) ~~~~ (?a) ~~~~ (_ list) +//│ (_ -> _) <--- (?b) ~~~~ (?a) ~~~~ (?b) ~~~~ (?c) ---> (_ list) //│ //│ ◉ (_ -> _) comes from //│ ▲ - l.4 | h::t -> if a = h then filter t a else h :: (filter t a);; @@ -3779,13 +3769,13 @@ let removeDuplicates l = //│ │ - l.1 let rec filter l a = //│ │ ^^^^^^ //│ ▼ -//│ ◉ (_ list -> ?c) comes from +//│ ◉ (_ list -> ?a) comes from //│ - l.4 | h::t -> if a = h then filter t a else h :: (filter t a);; //│ ^^^^^^ -//│ ◉ (?c) is assumed for +//│ ◉ (?a) is assumed for //│ - l.4 | h::t -> if a = h then filter t a else h :: (filter t a);; //│ ^^^^^^^^ -//│ ◉ (_ list -> ?c) comes from +//│ ◉ (_ list -> ?a) comes from //│ ▲ - l.4 | h::t -> if a = h then filter t a else h :: (filter t a);; //│ │ ^^^^^^ //│ │ - l.1 let rec filter l a = @@ -3811,28 +3801,26 @@ let removeDuplicates l = //│ │ - l.1 let rec filter l a = //│ │ ^^^^^^ //│ ▼ -//│ ◉ (_ -> ?a) comes from +//│ ◉ (_ -> ?c) comes from //│ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in //│ ^^^^^^ -//│ ◉ (?a) is assumed for -//│ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in -//│ ^^^^^^^^^^^^^^ -//│ ◉ (_ * ?a) comes from -//│ │ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in -//│ │ ^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (_ * _ list) comes from -//│ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in -//│ ^^^^^^^^^^^^^^^^^^^ +//│ ◉ (?c) is assumed for +//│ │ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in +//│ │ ^^^^^^^^^^^^^^ +//│ ▼ //│ ◉ (_ list) comes from -//│ filter: list['a] -> 'b -> list['b] +//│ - l.11 let rest' = h :: (filter (t h)) in helper (seen', rest') in +//│ ^^^^^^^^^^^^^^^^^^^ +//│ filter: list['a] -> 'b -> 'c +//│ where +//│ 'c = list['a], list['b] //│ removeDuplicates: list[list['a]] -> list['a] -//│ U max: 18, total: 218 +//│ U max: 11, total: 181 //│ UERR 4 errors -//│ L: 1 [([α1707'''] -> α1706''') ~ list['a1699''], ([α1707'''] -> α1706''') :> α1711''', [α1711''' - ([list['a1702''']] -> α1711''') ~ ([list['a1702''']] -> α1709''') - α1709''', L: 0 [([list['a1702''']] -> α1711''') ~ ([list['a1702''']] -> α1709'''), ([list['a1702''']] -> α1711''') :> filter1700''', filter1700''' <: ([list['a1702''']] -> α1709''')]], [α1709''' - ([list['a1702''']] -> α1709''') ~ (α1713''' -> α1714''') - α1714''', L: 0 [([list['a1702''']] -> α1709''') ~ (α1713''' -> α1714'''), ([list['a1702''']] -> α1709''') :> filter1700''', filter1700''' <: (α1713''' -> α1714''')]], [α1714''' - ([['a1698'']], [α1714'''],) ~ ('a1699'', list['a1699''],) - list['a1699''], L: 0 [([['a1698'']], [α1714'''],) ~ ('a1699'', list['a1699''],), ([['a1698'']], [α1714'''],) <: ('a1699'', list['a1699''],)]]] -//│ L: 1 [([α1707'''] -> α1705''') ~ list['a1699''], ([α1707'''] -> α1705''') :> α1709''', [α1709''' - ([list['a1702''']] -> α1709''') ~ ([list['a1702''']] -> α1711''') - α1711''', L: 0 [([list['a1702''']] -> α1709''') ~ ([list['a1702''']] -> α1711'''), ([list['a1702''']] -> α1709''') :> filter1700''', filter1700''' <: ([list['a1702''']] -> α1711''')]], [α1711''' - ([list['a1702''']] -> α1711''') ~ ([list['a1702''']] -> α1709''') - α1709''', L: 0 [([list['a1702''']] -> α1711''') ~ ([list['a1702''']] -> α1709'''), ([list['a1702''']] -> α1711''') :> filter1700''', filter1700''' <: ([list['a1702''']] -> α1709''')]], [α1709''' - ([list['a1702''']] -> α1709''') ~ (α1713''' -> α1714''') - α1714''', L: 0 [([list['a1702''']] -> α1709''') ~ (α1713''' -> α1714'''), ([list['a1702''']] -> α1709''') :> filter1700''', filter1700''' <: (α1713''' -> α1714''')]], [α1714''' - ([['a1698'']], [α1714'''],) ~ ('a1699'', list['a1699''],) - list['a1699''], L: 0 [([['a1698'']], [α1714'''],) ~ ('a1699'', list['a1699''],), ([['a1698'']], [α1714'''],) <: ('a1699'', list['a1699''],)]]] -//│ L: 1 [(α1707''' -> α1710''') ~ list['a1699''], [(α1707''' -> α1710''') - (α1701''' -> (α1707''' -> α1710''')) ~ (α1713''' -> α1714''') - α1714''', L: 0 [(α1701''' -> (α1707''' -> α1710''')) ~ (α1713''' -> α1714'''), (α1701''' -> (α1707''' -> α1710''')) <: filter1700''', filter1700''' <: (α1713''' -> α1714''')]], [α1714''' - ([['a1698'']], [α1714'''],) ~ ('a1699'', list['a1699''],) - list['a1699''], L: 0 [([['a1698'']], [α1714'''],) ~ ('a1699'', list['a1699''],), ([['a1698'']], [α1714'''],) <: ('a1699'', list['a1699''],)]]] -//│ L: 0 [list['a1698''] ~ (['a1698''] -> α1713'''), list['a1698''] <: (['a1698''] -> α1713''')] +//│ L: 1 [([α1632'''] -> α1634''') ~ list[['a1626'']], ([α1632'''] -> α1634''') :> α1638''', [α1638''' - ([list['a1630''']] -> α1638''') ~ ([list['a1630''']] -> α1636''') - α1636''', L: 0 [([list['a1630''']] -> α1638''') ~ ([list['a1630''']] -> α1636'''), ([list['a1630''']] -> α1638''') :> filter1628''', filter1628''' <: ([list['a1630''']] -> α1636''')]], [α1636''' - ([list['a1630''']] -> α1636''') ~ ([list['a1630''']] -> α1638''') - α1638''', L: 0 [([list['a1630''']] -> α1636''') ~ ([list['a1630''']] -> α1638'''), ([list['a1630''']] -> α1636''') :> filter1628''', filter1628''' <: ([list['a1630''']] -> α1638''')]], [α1638''' - ([list['a1630''']] -> α1638''') ~ (α1641''' -> α1642''') - α1642''', L: 0 [([list['a1630''']] -> α1638''') ~ (α1641''' -> α1642'''), ([list['a1630''']] -> α1638''') :> filter1628''', filter1628''' <: (α1641''' -> α1642''')]], α1642''' <: list[['a1626'']]] +//│ L: 0 [list['a1626''] ~ (['a1626''] -> α1641'''), list['a1626''] <: (['a1626''] -> α1641''')] +//│ L: 1 [(α1632''' -> α1637''') ~ list[['a1626'']], [(α1632''' -> α1637''') - (α1629''' -> (α1632''' -> α1637''')) ~ (α1641''' -> α1642''') - α1642''', L: 0 [(α1629''' -> (α1632''' -> α1637''')) ~ (α1641''' -> α1642'''), (α1629''' -> (α1632''' -> α1637''')) <: filter1628''', filter1628''' <: (α1641''' -> α1642''')]], α1642''' <: list[['a1626'']]] +//│ L: 1 [([α1632'''] -> α1635''') ~ list[['a1626'']], ([α1632'''] -> α1635''') :> α1636''', [α1636''' - ([list['a1630''']] -> α1636''') ~ ([list['a1630''']] -> α1638''') - α1638''', L: 0 [([list['a1630''']] -> α1636''') ~ ([list['a1630''']] -> α1638'''), ([list['a1630''']] -> α1636''') :> filter1628''', filter1628''' <: ([list['a1630''']] -> α1638''')]], [α1638''' - ([list['a1630''']] -> α1638''') ~ (α1641''' -> α1642''') - α1642''', L: 0 [([list['a1630''']] -> α1638''') ~ (α1641''' -> α1642'''), ([list['a1630''']] -> α1638''') :> filter1628''', filter1628''' <: (α1641''' -> α1642''')]], α1642''' <: list[['a1626'']]] // file 0221 @@ -3855,12 +3843,12 @@ let rec assoc (d,k,l) = | h::t -> let (f,s) = h in if k = f then s h else assoc d k t;; //│ [ERROR] Type `_ * _ * _` does not match `_ -> _` //│ -//│ (?b * _ * _) ~~~~ (?b) ---> (?c) ~~~~ (?a) ---> (_ -> _) +//│ (?a * _ * _) ~~~~ (?a) ---> (?b) ~~~~ (?c) ---> (_ -> _) //│ -//│ ◉ (?b * _ * _) comes from +//│ ◉ (?a * _ * _) comes from //│ - l.1 let rec assoc (d,k,l) = //│ ^^^^^^^ -//│ ◉ ((?b * _ * _) -> ?c) comes from +//│ ◉ ((?a * _ * _) -> ?b) comes from //│ │ - l.1 let rec assoc (d,k,l) = //│ │ ^^^^^^^^^ //│ │ match l with ... @@ -3872,21 +3860,21 @@ let rec assoc (d,k,l) = //│ │ - l.1 let rec assoc (d,k,l) = //│ │ ^^^^^ //│ ▼ -//│ ◉ (?b -> ?a) comes from +//│ ◉ (?a -> ?c) comes from //│ - l.4 | h::t -> let (f,s) = h in if k = f then s h else assoc d k t;; //│ ^^^^^ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let rec assoc (d,k,l) = //│ │ ^ //│ │ - l.3 | [] -> d //│ │ ^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?b) is assumed for //│ - l.2 match l with //│ ^^^^^^^^^^^^ //│ | [] -> d ... //│ ^^^^^^^^^^^^^ -//│ ◉ ((?b * _ * _) -> ?c) comes from +//│ ◉ ((?a * _ * _) -> ?b) comes from //│ │ - l.1 let rec assoc (d,k,l) = //│ │ ^^^^^^^^^ //│ │ match l with ... @@ -3898,10 +3886,10 @@ let rec assoc (d,k,l) = //│ │ - l.1 let rec assoc (d,k,l) = //│ │ ^^^^^ //│ ▼ -//│ ◉ (?b -> ?a) comes from +//│ ◉ (?a -> ?c) comes from //│ - l.4 | h::t -> let (f,s) = h in if k = f then s h else assoc d k t;; //│ ^^^^^ -//│ ◉ (?a) is assumed for +//│ ◉ (?c) is assumed for //│ │ - l.4 | h::t -> let (f,s) = h in if k = f then s h else assoc d k t;; //│ │ ^^^^^^^ //│ ▼ @@ -3916,4 +3904,4 @@ let rec assoc (d,k,l) = //│ 'e = list[('d, 'a -> ('b, 'c, 'e,),)] //│ U max: 10, total: 35 //│ UERR 1 errors -//│ L: 1 [([α1783'], [α1784'], [α1785'],) ~ ([α1784'] -> α1795'), [([α1783'], [α1784'], [α1785'],) - (([α1783'], [α1784'], [α1785'],) -> α1786') ~ ([α1783'] -> α1794') - α1783', L: 0 [(([α1783'], [α1784'], [α1785'],) -> α1786') ~ ([α1783'] -> α1794'), (([α1783'], [α1784'], [α1785'],) -> α1786') <: assoc1782', assoc1782' <: ([α1783'] -> α1794')]], α1783' <: α1786', [α1786' - (([α1783'], [α1784'], [α1785'],) -> α1786') ~ ([α1783'] -> α1794') - α1794', L: 0 [(([α1783'], [α1784'], [α1785'],) -> α1786') ~ ([α1783'] -> α1794'), (([α1783'], [α1784'], [α1785'],) -> α1786') <: assoc1782', assoc1782' <: ([α1783'] -> α1794')]], α1794' <: ([α1784'] -> α1795')] +//│ L: 1 [([α1696'], [α1697'], [α1698'],) ~ ([α1697'] -> α1708'), [([α1696'], [α1697'], [α1698'],) - (([α1696'], [α1697'], [α1698'],) -> α1699') ~ ([α1696'] -> α1707') - α1696', L: 0 [(([α1696'], [α1697'], [α1698'],) -> α1699') ~ ([α1696'] -> α1707'), (([α1696'], [α1697'], [α1698'],) -> α1699') <: assoc1695', assoc1695' <: ([α1696'] -> α1707')]], α1696' <: α1699', [α1699' - (([α1696'], [α1697'], [α1698'],) -> α1699') ~ ([α1696'] -> α1707') - α1707', L: 0 [(([α1696'], [α1697'], [α1698'],) -> α1699') ~ ([α1696'] -> α1707'), (([α1696'], [α1697'], [α1698'],) -> α1699') <: assoc1695', assoc1695' <: ([α1696'] -> α1707')]], α1707' <: ([α1697'] -> α1708')] diff --git a/shared/src/test/diff/ocaml/OcamlExprChecker.mls b/shared/src/test/diff/ocaml/OcamlExprChecker.mls index bc86aa8..c87264c 100644 --- a/shared/src/test/diff/ocaml/OcamlExprChecker.mls +++ b/shared/src/test/diff/ocaml/OcamlExprChecker.mls @@ -177,35 +177,23 @@ type ('a, 'b) heapD = HeapD of 'a * 'b list (("hi", 1) :: Nil) (("hi", 1) :: Nil):heap (("hi", 1) :: ("bye", 2) :: Nil):heap -//│ [ERROR] Type `_ list` does not match `heap` +//│ [ERROR] Type `(string * int) list` does not match `heap` //│ -//│ (_ list) ---> (heap) +//│ ((string * int) list) ---> (heap) //│ -//│ ◉ (_ list) comes from +//│ ◉ ((string * int) list) comes from //│ │ - l.2 (("hi", 1) :: Nil):heap //│ │ ^^^^^^^^^^^^^^^^^^ //│ ▼ //│ ◉ (heap) comes from //│ - l.2 (("hi", 1) :: Nil):heap //│ ^^^^ -//│ [ERROR] Type `_ list` does not match `heap` -//│ -//│ (_ list) ---> (heap) -//│ -//│ ◉ (_ list) comes from -//│ │ - l.3 (("hi", 1) :: ("bye", 2) :: Nil):heap -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (heap) comes from -//│ - l.3 (("hi", 1) :: ("bye", 2) :: Nil):heap -//│ ^^^^ //│ res: list[(string, int,)] //│ res: heap //│ res: heap -//│ U max: 3, total: 25 -//│ UERR 2 errors -//│ L: 0 [list['a123] ~ heap, list['a123] <: heap] -//│ L: 0 [list['a121] ~ heap, list['a121] <: heap] +//│ U max: 2, total: 6 +//│ UERR 1 errors +//│ L: 0 [list[([[string]], [[int]],)] ~ heap, list[([[string]], [[int]],)] <: heap] let update h str i = (str,i)::h //│ update: list[('a, 'b,)] -> 'a -> 'b -> list[('a, 'b,)] @@ -229,21 +217,21 @@ let interp2 = (fun (env:env) opt -> //│ ^^^^ //│ ╔══[ERROR] Unsupported pattern shape: //│ ║ -//│ ║ l.215: fun (env: env) _ -> [] +//│ ║ l.203: fun (env: env) _ -> [] //│ ╙── ^^^^^^^^^^^^ //│ res: err -> list['a] //│ ╔══[ERROR] Unsupported pattern shape: //│ ║ -//│ ║ l.216: let interp2 = (fun (env:env) opt -> +//│ ║ l.204: let interp2 = (fun (env:env) opt -> //│ ╙── ^^^^^^^^^^^^^ //│ ╔══[ERROR] identifier not found: opt //│ ║ -//│ ║ l.217: match opt with +//│ ║ l.205: match opt with //│ ╙── ^^^ //│ interp2: err -> int //│ U max: 1, total: 2 //│ UERR 1 errors -//│ L: 0 [err ~ option['a132'], err <: option['a132']] +//│ L: 0 [err ~ option['a99'], err <: option['a99']] let head xs = match xs with Cons(x, xs) -> x @@ -305,7 +293,7 @@ let checkagain (v: (int, int, (int, int))) = //│ │ ^ //│ ▼ //│ ◉ (int) comes from -//│ - l.-223let (+): int -> int -> int +//│ - l.-211let (+): int -> int -> int //│ ^^^ //│ [ERROR] Type `int` does not match `err` //│ @@ -344,24 +332,24 @@ let checkagain (v: (int, int, (int, int))) = //│ ^ //│ ╔══[ERROR] identifier not found: k //│ ║ -//│ ║ l.298: (a, b, (k, d)) -> a + b + k + d +//│ ║ l.286: (a, b, (k, d)) -> a + b + k + d //│ ╙── ^ //│ ╔══[ERROR] identifier not found: d //│ ║ -//│ ║ l.298: (a, b, (k, d)) -> a + b + k + d +//│ ║ l.286: (a, b, (k, d)) -> a + b + k + d //│ ╙── ^ //│ ╔══[ERROR] identifier not found: k //│ ║ -//│ ║ l.298: (a, b, (k, d)) -> a + b + k + d +//│ ║ l.286: (a, b, (k, d)) -> a + b + k + d //│ ╙── ^ //│ ╔══[ERROR] identifier not found: d //│ ║ -//│ ║ l.298: (a, b, (k, d)) -> a + b + k + d +//│ ║ l.286: (a, b, (k, d)) -> a + b + k + d //│ ╙── ^ //│ checkagain: (int, int, (int, int,),) -> int //│ U max: 3, total: 15 //│ UERR 2 errors -//│ L: 2 [int ~ err, [int - ([int], [int],) ~ ([[err]], [[err]],) - err, L: 1 [([int], [int],) ~ ([[err]], [[err]],), [([int], [int],) - ([int], [int], [([int], [int],)],) ~ ([α157'], [α158'], [α159'],) - α159', L: 0 [([int], [int], [([int], [int],)],) ~ ([α157'], [α158'], [α159'],), ([int], [int], [([int], [int],)],) :> α155', α155' <: ([α157'], [α158'], [α159'],)]], α159' <: ([[err]], [[err]],)]]] +//│ L: 2 [int ~ err, [int - ([int], [int],) ~ ([[err]], [[err]],) - err, L: 1 [([int], [int],) ~ ([[err]], [[err]],), [([int], [int],) - ([int], [int], [([int], [int],)],) ~ ([α124'], [α125'], [α126'],) - α126', L: 0 [([int], [int], [([int], [int],)],) ~ ([α124'], [α125'], [α126'],), ([int], [int], [([int], [int],)],) :> α122', α122' <: ([α124'], [α125'], [α126'],)]], α126' <: ([[err]], [[err]],)]]] //│ L: 0 [err ~ int, err <: int] let (<): 'a -> 'a -> bool @@ -412,47 +400,25 @@ let g x = x, if true then x else x [0, 1; 2, 3, 4] //│ [ERROR] Type `int * int * int` does not match `int * int` //│ -//│ (int * int * int) ~~~~ (?a0) ~~~~ (?a) ~~~~ (int * int) +//│ (int * int * int) ~~~~ (int * int) //│ //│ ◉ (int * int * int) comes from //│ - l.1 [0, 1; 2, 3, 4] //│ ^^^^^^^ -//│ ◉ ((int * int * int) * _ list) comes from +//│ ◉ ((int * int * int) list) comes from //│ │ - l.1 [0, 1; 2, 3, 4] //│ │ ^^^^^^^ //│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from +//│ ◉ ((int * int) list) comes from //│ - l.1 [0, 1; 2, 3, 4] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ - l.1 [0, 1; 2, 3, 4] -//│ ^^^^^^^ -//│ ◉ ((int * int) * ?a0 list) comes from -//│ │ - l.1 [0, 1; 2, 3, 4] -//│ │ ^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.1 [0, 1; 2, 3, 4] -//│ ^^^^^^^^^^^^^ -//│ ◉ (?a list) comes from -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.1 [0, 1; 2, 3, 4] -//│ │ ^^^^^^^^^^^^^ -//│ │ -//│ ◉ ((int * int) * ?a0 list) comes from -//│ - l.1 [0, 1; 2, 3, 4] -//│ ^^^^^^^^^^^^^ +//│ ^^^^^^^^^^^^^^^ //│ ◉ (int * int) comes from //│ - l.1 [0, 1; 2, 3, 4] //│ ^^^^ -//│ res: list['a] -//│ where -//│ 'a = (int, int, int,), (int, int,) -//│ U max: 3, total: 15 +//│ res: list[(int, int,)] +//│ U max: 1, total: 3 //│ UERR 1 errors -//│ L: 2 [([[int]], [[int]], [[int]],) ~ ([[int]], [[int]],), [([[int]], [[int]], [[int]],) - ([([[int]], [[int]], [[int]],)], [[list['a191]]],) ~ ('a190, list['a190],) - 'a190, L: 0 [([([[int]], [[int]], [[int]],)], [[list['a191]]],) ~ ('a190, list['a190],), ([([[int]], [[int]], [[int]],)], [[list['a191]]],) <: ('a190, list['a190],)]], ['a190 - list['a190] ~ list['a189] - 'a189, L: 1 [list['a190] ~ list['a189], [list['a190] - ([([[int]], [[int]],)], [[list['a190]]],) ~ ('a189, list['a189],) - list['a189], L: 0 [([([[int]], [[int]],)], [[list['a190]]],) ~ ('a189, list['a189],), ([([[int]], [[int]],)], [[list['a190]]],) <: ('a189, list['a189],)]]]], ['a189 - ('a189, list['a189],) ~ ([([[int]], [[int]],)], [[list['a190]]],) - ([[int]], [[int]],), L: 0 [('a189, list['a189],) ~ ([([[int]], [[int]],)], [[list['a190]]],), ('a189, list['a189],) :> ([([[int]], [[int]],)], [[list['a190]]],)]]] +//│ L: 1 [([[int]], [[int]], [[int]],) ~ ([[int]], [[int]],), [([[int]], [[int]], [[int]],) - list[([[int]], [[int]], [[int]],)] ~ list[([[int]], [[int]],)] - ([[int]], [[int]],), L: 0 [list[([[int]], [[int]], [[int]],)] ~ list[([[int]], [[int]],)], list[([[int]], [[int]], [[int]],)] <: list[([[int]], [[int]],)]]]] let increment x = match x with | 0 -> 1 @@ -497,5 +463,5 @@ let len ls = match ls with | "hd :: tl" -> 1 | [] -> 0 //│ 'b = list['a], string //│ U max: 1, total: 4 //│ UERR 1 errors -//│ L: 0 [string ~ list['a207'], string :> α205', α205' <: list['a207']] +//│ L: 0 [string ~ list['a162'], string :> α160', α160' <: list['a162']] diff --git a/shared/src/test/diff/ocaml/OcamlPresentation.mls b/shared/src/test/diff/ocaml/OcamlPresentation.mls index 280ca70..4ec9375 100644 --- a/shared/src/test/diff/ocaml/OcamlPresentation.mls +++ b/shared/src/test/diff/ocaml/OcamlPresentation.mls @@ -301,46 +301,7 @@ let wrap x = x :: [] let rec t = wrap (if true then 1 else t) //│ [ERROR] Type `_ list` does not match `int` //│ -//│ (_ list) ---> (?t) ---> (?b) ---> (?a) <--- (?b) <--- (int) -//│ -//│ ◉ (_ list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^ -//│ ▼ -//│ ◉ (?t) is assumed for -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^ -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^ -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^ -//│ ▼ -//│ ◉ (?a) is assumed for -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^ -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (?b) is assumed for -//│ ▲ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (int) comes from -//│ - l.2 let rec t = wrap (if true then 1 else t) -//│ ^ -//│ [ERROR] Type `_ list` does not match `int` -//│ -//│ (?a list) ---> (?t) ---> (?c) ---> (?b) ~~~~ (?a) ~~~~ (?b) <--- (?c) <--- (int) +//│ (?a list) ---> (?t) ---> (?b) ---> (?a) <--- (?b) <--- (int) //│ //│ ◉ (?a list) comes from //│ │ - l.1 let wrap x = x :: [] @@ -358,108 +319,13 @@ let rec t = wrap (if true then 1 else t) //│ │ - l.2 let rec t = wrap (if true then 1 else t) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ //│ ◉ (?b) is assumed for -//│ - l.1 let wrap x = x :: [] -//│ ^ -//│ ◉ (?b * _ list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?b * _ list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?b) is assumed for -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^ //│ │ - l.2 let rec t = wrap (if true then 1 else t) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (?c) is assumed for -//│ ▲ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (int) comes from -//│ - l.2 let rec t = wrap (if true then 1 else t) -//│ ^ -//│ [ERROR] Type `_ list` does not match `int` -//│ -//│ (?a0 list) ---> (?t) ---> (?b) ---> (?c) ~~~~ (?a0) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?c) <--- (?b) <--- (int) -//│ -//│ ◉ (?a0 list) comes from //│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^ -//│ ▼ -//│ ◉ (?t) is assumed for -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^ -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^ -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.2 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ ^ //│ ▼ -//│ ◉ (?c) is assumed for -//│ - l.1 let wrap x = x :: [] -//│ ^ -//│ ◉ (?c * ?a list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * ?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^ //│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^ -//│ ◉ (?c * ?a list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * ?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?c) is assumed for //│ ▲ - l.1 let wrap x = x :: [] //│ │ ^ //│ │ - l.2 let rec t = wrap (if true then 1 else t) @@ -475,13 +341,10 @@ let rec t = wrap (if true then 1 else t) //│ wrap: 'a -> list['a] //│ t: 't //│ where -//│ 't = list['a], int -//│ 'a = list['a], int -//│ U max: 5, total: 41 -//│ UERR 3 errors -//│ L: 2 [list['a84'] ~ int, list['a84'] <: t82', t82' <: α86', α86' <: α83', [α83' - ([[α83']], [[list['a85']]],) ~ ('a84', list['a84'],) - 'a84', L: 0 [([[α83']], [[list['a85']]],) ~ ('a84', list['a84'],), ([[α83']], [[list['a85']]],) <: ('a84', list['a84'],)]], ['a84' - list['a84'] ~ list['a85'] - 'a85', L: 1 [list['a84'] ~ list['a85'], [list['a84'] - ('a84', list['a84'],) ~ ([[α83']], [[list['a85']]],) - list['a85'], L: 0 [('a84', list['a84'],) ~ ([[α83']], [[list['a85']]],), ('a84', list['a84'],) :> ([[α83']], [[list['a85']]],)]]]], ['a85' - list['a85'] ~ list['a84'] - 'a84', L: 1 [list['a85'] ~ list['a84'], [list['a85'] - ([[α83']], [[list['a85']]],) ~ ('a84', list['a84'],) - list['a84'], L: 0 [([[α83']], [[list['a85']]],) ~ ('a84', list['a84'],), ([[α83']], [[list['a85']]],) <: ('a84', list['a84'],)]]]], ['a84' - ('a84', list['a84'],) ~ ([[α83']], [[list['a85']]],) - α83', L: 0 [('a84', list['a84'],) ~ ([[α83']], [[list['a85']]],), ('a84', list['a84'],) :> ([[α83']], [[list['a85']]],)]], α83' :> α86', α86' :> int] -//│ L: 1 [list['a84'] ~ int, list['a84'] <: t82', t82' <: α86', α86' <: α83', [α83' - ([[α83']], [[list['a85']]],) ~ ('a84', list['a84'],) - 'a84', L: 0 [([[α83']], [[list['a85']]],) ~ ('a84', list['a84'],), ([[α83']], [[list['a85']]],) <: ('a84', list['a84'],)]], ['a84' - ('a84', list['a84'],) ~ ([[α83']], [[list['a85']]],) - α83', L: 0 [('a84', list['a84'],) ~ ([[α83']], [[list['a85']]],), ('a84', list['a84'],) :> ([[α83']], [[list['a85']]],)]], α83' :> α86', α86' :> int] -//│ L: 0 [list['a84'] ~ int, list['a84'] <: t82', t82' <: α86', α86' <: α83', α83' :> α86', α86' :> int] +//│ 't = list['t], int +//│ U max: 3, total: 11 +//│ UERR 1 errors +//│ L: 0 [list[[α80']] ~ int, list[[α80']] <: t79', t79' <: α81', α81' <: α80', α80' :> α81', α81' :> int] let rec length ls = match ls with | hd :: tl -> 1 + length tl | [] -> 0 @@ -521,7 +384,7 @@ let weird x = (x + 1, length x) //│ 'b = list['a], int //│ U max: 4, total: 29 //│ UERR 1 errors -//│ L: 1 [list['a98'] ~ int, [list['a98'] - ([list['a98']] -> α100') ~ ([α95'] -> α101') - α95', L: 0 [([list['a98']] -> α100') ~ ([α95'] -> α101'), ([list['a98']] -> α100') :> length96', length96' <: ([α95'] -> α101')]], α95' <: int] +//│ L: 1 [list['a92'] ~ int, [list['a92'] - ([list['a92']] -> α94') ~ ([α89'] -> α95') - α89', L: 0 [([list['a92']] -> α94') ~ ([α89'] -> α95'), ([list['a92']] -> α94') :> length90', length90' <: ([α89'] -> α95')]], α89' <: int] let len ls = match ls with | "hd :: tl" -> 1 | [] -> 0 @@ -551,4 +414,4 @@ let len ls = match ls with | "hd :: tl" -> 1 | [] -> 0 //│ 'b = list['a], string //│ U max: 1, total: 4 //│ UERR 1 errors -//│ L: 0 [string ~ list['a106'], string :> α104', α104' <: list['a106']] +//│ L: 0 [string ~ list['a100'], string :> α98', α98' <: list['a100']] diff --git a/shared/src/test/diff/ocaml/Regression.mls b/shared/src/test/diff/ocaml/Regression.mls index f6a7852..8c6a779 100644 --- a/shared/src/test/diff/ocaml/Regression.mls +++ b/shared/src/test/diff/ocaml/Regression.mls @@ -49,11 +49,11 @@ let test2 = let (a, b) = test in [[b]] + 1 //│ ◉ (_ * _) comes from //│ - l.1 let test2 = let (a, b) = test in [[b]] + 1 //│ ^^^^^^ -//│ [ERROR] Type `_ list` does not match `int` +//│ [ERROR] Type `_ list list` does not match `int` //│ -//│ (_ list) ---> (int) +//│ (_ list list) ---> (int) //│ -//│ ◉ (_ list) comes from +//│ ◉ (_ list list) comes from //│ │ - l.1 let test2 = let (a, b) = test in [[b]] + 1 //│ │ ^^^^^ //│ ▼ @@ -61,10 +61,10 @@ let test2 = let (a, b) = test in [[b]] + 1 //│ - lib. let (+): int -> int -> int //│ ^^^ //│ test2: int -//│ U max: 2, total: 12 +//│ U max: 1, total: 4 //│ UERR 2 errors -//│ L: 0 [list['a48'] ~ int, list['a48'] <: int] //│ L: 0 [int ~ ([α46'], [α47'],), int <: ([α46'], [α47'],)] +//│ L: 0 [list[list[[[α47']]]] ~ int, list[list[[[α47']]]] <: int] let f x = x + 1 @@ -162,7 +162,7 @@ confluence true //│ 'a = bool, int //│ U max: 2, total: 7 //│ UERR 1 errors -//│ L: 0 [bool ~ int, bool <: α57, α57 <: α58, α58 :> int] +//│ L: 0 [bool ~ int, bool <: α53, α53 <: α54, α54 :> int] let x: int list @@ -251,7 +251,7 @@ if true then x else y //│ 'a = list[string], list[int] //│ U max: 1, total: 5 //│ UERR 1 errors -//│ L: 1 [string ~ int, [string - list[string] ~ list[int] - int, L: 0 [list[string] ~ list[int], list[string] <: α60, α60 :> list[int]]]] +//│ L: 1 [string ~ int, [string - list[string] ~ list[int] - int, L: 0 [list[string] ~ list[int], list[string] <: α56, α56 :> list[int]]]] Left 1 : int @@ -271,7 +271,7 @@ Left 1 : int //│ res: int //│ U max: 1, total: 2 //│ UERR 1 errors -//│ L: 0 [either[α61,α62] ~ int, either[α61,α62] <: int] +//│ L: 0 [either[α57,α58] ~ int, either[α57,α58] <: int] let confluence z = if true then z else 5 @@ -317,7 +317,7 @@ mkpair 1 "2" //│ 'a = string, int //│ U max: 2, total: 10 //│ UERR 1 errors -//│ L: 0 [string ~ int, string <: α73, α73 <: α74, α74 <: α75, α75 :> int] +//│ L: 0 [string ~ int, string <: α69, α69 <: α70, α70 <: α71, α71 :> int] let a = 1 @@ -390,9 +390,9 @@ g b //│ g: list[string] -> unit //│ U max: 3, total: 8 //│ UERR 3 errors -//│ L: 1 [bool ~ list[string], bool :> α79, [α79 - (α79 -> α80) ~ (list[string] -> unit) - list[string], L: 0 [(α79 -> α80) ~ (list[string] -> unit), (α79 -> α80) <: (list[string] -> unit)]]] +//│ L: 1 [bool ~ unit, bool <: α76, [α76 - (α75 -> α76) ~ (list[string] -> unit) - unit, L: 0 [(α75 -> α76) ~ (list[string] -> unit), (α75 -> α76) <: (list[string] -> unit)]]] +//│ L: 1 [bool ~ list[string], bool :> α75, [α75 - (α75 -> α76) ~ (list[string] -> unit) - list[string], L: 0 [(α75 -> α76) ~ (list[string] -> unit), (α75 -> α76) <: (list[string] -> unit)]]] //│ L: 0 [int ~ list[string], int <: list[string]] -//│ L: 1 [bool ~ unit, bool <: α80, [α80 - (α79 -> α80) ~ (list[string] -> unit) - unit, L: 0 [(α79 -> α80) ~ (list[string] -> unit), (α79 -> α80) <: (list[string] -> unit)]]] let wrap x = x :: [] //│ wrap: 'a -> list['a] @@ -401,98 +401,15 @@ let wrap x = x :: [] if true then wrap 1 else wrap true //│ [ERROR] Type `bool` does not match `int` //│ -//│ (bool) ---> (?d) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?b) <--- (int) +//│ (bool) ---> (?a) ~~~~ (?c) <--- (int) //│ //│ ◉ (bool) comes from //│ │ - l.1 if true then wrap 1 else wrap true //│ │ ^^^^ //│ ▼ -//│ ◉ (?d) is assumed for -//│ - l.-3 let wrap x = x :: [] -//│ ^ -//│ ◉ (?d * _ list) comes from -//│ │ - l.-3 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.-3 let wrap x = x :: [] -//│ ^^^^^^^ //│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ │ - l.-3 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 if true then wrap 1 else wrap true -//│ │ ^^^^^^^^^ -//│ │ - l.1 if true then wrap 1 else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?c) is assumed for -//│ ▲ - l.1 if true then wrap 1 else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 if true then wrap 1 else wrap true -//│ │ ^^^^^^ -//│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-3 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-3 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?b * _ list) comes from -//│ - l.-3 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?b) is assumed for -//│ ▲ - l.-3 let wrap x = x :: [] -//│ │ ^ -//│ │ -//│ ◉ (int) comes from -//│ - l.1 if true then wrap 1 else wrap true -//│ ^ -//│ [ERROR] Type `bool` does not match `int` -//│ -//│ (bool) ---> (?d) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?a2) ~~~~ (?a0) ~~~~ (?b) <--- (int) -//│ -//│ ◉ (bool) comes from -//│ │ - l.1 if true then wrap 1 else wrap true -//│ │ ^^^^ -//│ ▼ -//│ ◉ (?d) is assumed for //│ - l.-3 let wrap x = x :: [] //│ ^ -//│ ◉ (?d * ?a1 list) comes from -//│ │ - l.-3 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.-3 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.-3 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a1 list) comes from -//│ - l.-3 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ - l.-3 let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ - l.-3 let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a1 list) comes from -//│ │ - l.-3 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.-3 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ ◉ (?a) is assumed for //│ ◉ (?a list) comes from //│ │ - l.-3 let wrap x = x :: [] //│ │ ^^^^^^^ @@ -501,48 +418,16 @@ if true then wrap 1 else wrap true //│ │ - l.1 if true then wrap 1 else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.1 if true then wrap 1 else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 if true then wrap 1 else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-3 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-3 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?b * ?a2 list) comes from -//│ - l.-3 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a2 list) comes from -//│ - l.-3 let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a2) is assumed for -//│ ◉ (?a2 list) comes from -//│ - l.-3 let wrap x = x :: [] -//│ ^^ -//│ ◉ (?b * ?a2 list) comes from -//│ │ - l.-3 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-3 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-3 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?b * ?a2 list) comes from +//│ ◉ (?c list) comes from //│ - l.-3 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?b) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.-3 let wrap x = x :: [] //│ │ ^ //│ │ @@ -550,10 +435,9 @@ if true then wrap 1 else wrap true //│ - l.1 if true then wrap 1 else wrap true //│ ^ //│ res: list[bool] -//│ U max: 7, total: 33 -//│ UERR 2 errors -//│ L: 1 [bool ~ int, bool <: α89, [α89 - ([[α89]], [[list['a91]]],) ~ ('a90, list['a90],) - 'a90, L: 0 [([[α89]], [[list['a91]]],) ~ ('a90, list['a90],), ([[α89]], [[list['a91]]],) <: ('a90, list['a90],)]], ['a90 - list['a90] ~ list['a87] - 'a87, L: 0 [list['a90] ~ list['a87], list['a90] <: α85, α85 :> list['a87]]], ['a87 - ('a87, list['a87],) ~ ([[α86]], [[list['a88]]],) - α86, L: 0 [('a87, list['a87],) ~ ([[α86]], [[list['a88]]],), ('a87, list['a87],) :> ([[α86]], [[list['a88]]],)]], α86 :> int] -//│ L: 2 [bool ~ int, bool <: α89, [α89 - ([[α89]], [[list['a91]]],) ~ ('a90, list['a90],) - 'a90, L: 0 [([[α89]], [[list['a91]]],) ~ ('a90, list['a90],), ([[α89]], [[list['a91]]],) <: ('a90, list['a90],)]], ['a90 - list['a90] ~ list['a91] - 'a91, L: 1 [list['a90] ~ list['a91], [list['a90] - ('a90, list['a90],) ~ ([[α89]], [[list['a91]]],) - list['a91], L: 0 [('a90, list['a90],) ~ ([[α89]], [[list['a91]]],), ('a90, list['a90],) :> ([[α89]], [[list['a91]]],)]]]], ['a91 - list['a91] ~ list['a90] - 'a90, L: 1 [list['a91] ~ list['a90], [list['a91] - ([[α89]], [[list['a91]]],) ~ ('a90, list['a90],) - list['a90], L: 0 [([[α89]], [[list['a91]]],) ~ ('a90, list['a90],), ([[α89]], [[list['a91]]],) <: ('a90, list['a90],)]]]], ['a90 - list['a90] ~ list['a87] - 'a87, L: 0 [list['a90] ~ list['a87], list['a90] <: α85, α85 :> list['a87]]], ['a87 - list['a87] ~ list['a88] - 'a88, L: 1 [list['a87] ~ list['a88], [list['a87] - ('a87, list['a87],) ~ ([[α86]], [[list['a88]]],) - list['a88], L: 0 [('a87, list['a87],) ~ ([[α86]], [[list['a88]]],), ('a87, list['a87],) :> ([[α86]], [[list['a88]]],)]]]], ['a88 - list['a88] ~ list['a87] - 'a87, L: 1 [list['a88] ~ list['a87], [list['a88] - ([[α86]], [[list['a88]]],) ~ ('a87, list['a87],) - list['a87], L: 0 [([[α86]], [[list['a88]]],) ~ ('a87, list['a87],), ([[α86]], [[list['a88]]],) <: ('a87, list['a87],)]]]], ['a87 - ('a87, list['a87],) ~ ([[α86]], [[list['a88]]],) - α86, L: 0 [('a87, list['a87],) ~ ([[α86]], [[list['a88]]],), ('a87, list['a87],) :> ([[α86]], [[list['a88]]],)]], α86 :> int] +//│ U max: 2, total: 11 +//│ UERR 1 errors +//│ L: 1 [bool ~ int, bool <: α80, [α80 - list[[α80]] ~ list[[α79]] - α79, L: 0 [list[[α80]] ~ list[[α79]], list[[α80]] <: α78, α78 :> list[[α79]]]], α79 :> int] if true then wrap (if true then 1 else false) else wrap true @@ -574,135 +458,61 @@ if true then wrap (if true then 1 else false) else wrap true //│ ◉ (int) comes from //│ - l.1 if true then wrap (if true then 1 else false) else wrap true //│ ^ -//│ [ERROR] Type `int` does not match `bool` +//│ [ERROR] Type `bool` does not match `int` //│ -//│ (int) ---> (?b) ---> (?c) ~~~~ (?a) ~~~~ (?c) <--- (?b) <--- (bool) +//│ (bool) ---> (?d) ~~~~ (?b) <--- (?c) <--- (int) //│ -//│ ◉ (int) comes from -//│ │ - l.1 if true then wrap (if true then 1 else false) else wrap true -//│ │ ^ -//│ │ - l.1 if true then wrap (if true then 1 else false) else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.1 if true then wrap (if true then 1 else false) else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?c) is assumed for -//│ - l.-161let wrap x = x :: [] -//│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-161let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.-161let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.-161let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from -//│ - l.-161let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?c) is assumed for -//│ ▲ - l.-161let wrap x = x :: [] -//│ │ ^ -//│ │ - l.1 if true then wrap (if true then 1 else false) else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (?b) is assumed for -//│ ▲ - l.1 if true then wrap (if true then 1 else false) else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ //│ ◉ (bool) comes from -//│ - l.1 if true then wrap (if true then 1 else false) else wrap true -//│ ^^^^^ -//│ [ERROR] Type `int` does not match `bool` -//│ -//│ (int) ---> (?b) ---> (?c) ~~~~ (?a0) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?c) <--- (?b) <--- (bool) -//│ -//│ ◉ (int) comes from -//│ │ - l.1 if true then wrap (if true then 1 else false) else wrap true -//│ │ ^ -//│ │ - l.1 if true then wrap (if true then 1 else false) else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for //│ │ - l.1 if true then wrap (if true then 1 else false) else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ ^^^^ //│ ▼ -//│ ◉ (?c) is assumed for -//│ - l.-161let wrap x = x :: [] -//│ ^ -//│ ◉ (?c * ?a list) comes from -//│ │ - l.-161let wrap x = x :: [] -//│ │ ^^^^^^^ +//│ ◉ (?d) is assumed for +//│ - l.-45let wrap x = x :: [] +//│ ^ +//│ ◉ (?d list) comes from +//│ │ - l.-45let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 if true then wrap (if true then 1 else false) else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 if true then wrap (if true then 1 else false) else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-161let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-161let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * ?a list) comes from -//│ - l.-161let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-161let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-161let wrap x = x :: [] -//│ ^^ -//│ ◉ (?c * ?a list) comes from -//│ │ - l.-161let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-161let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-161let wrap x = x :: [] -//│ │ ^^^^^^^ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 if true then wrap (if true then 1 else false) else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 if true then wrap (if true then 1 else false) else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?c * ?a list) comes from -//│ - l.-161let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?c) is assumed for -//│ ▲ - l.-161let wrap x = x :: [] -//│ │ ^ +//│ ◉ (?b list) comes from +//│ - l.-45let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?b) is assumed for +//│ ▲ - l.-45let wrap x = x :: [] +//│ │ ^ //│ │ - l.1 if true then wrap (if true then 1 else false) else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?b) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.1 if true then wrap (if true then 1 else false) else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (bool) comes from +//│ ◉ (int) comes from //│ - l.1 if true then wrap (if true then 1 else false) else wrap true -//│ ^^^^^ +//│ ^ //│ res: list[bool] -//│ U max: 8, total: 42 -//│ UERR 3 errors -//│ L: 0 [bool ~ int, bool <: α97, α97 :> int] -//│ L: 2 [int ~ bool, int <: α97, α97 <: α94, [α94 - ([[α94]], [[list['a96]]],) ~ ('a95, list['a95],) - 'a95, L: 0 [([[α94]], [[list['a96]]],) ~ ('a95, list['a95],), ([[α94]], [[list['a96]]],) <: ('a95, list['a95],)]], ['a95 - list['a95] ~ list['a96] - 'a96, L: 1 [list['a95] ~ list['a96], [list['a95] - ('a95, list['a95],) ~ ([[α94]], [[list['a96]]],) - list['a96], L: 0 [('a95, list['a95],) ~ ([[α94]], [[list['a96]]],), ('a95, list['a95],) :> ([[α94]], [[list['a96]]],)]]]], ['a96 - list['a96] ~ list['a95] - 'a95, L: 1 [list['a96] ~ list['a95], [list['a96] - ([[α94]], [[list['a96]]],) ~ ('a95, list['a95],) - list['a95], L: 0 [([[α94]], [[list['a96]]],) ~ ('a95, list['a95],), ([[α94]], [[list['a96]]],) <: ('a95, list['a95],)]]]], ['a95 - ('a95, list['a95],) ~ ([[α94]], [[list['a96]]],) - α94, L: 0 [('a95, list['a95],) ~ ([[α94]], [[list['a96]]],), ('a95, list['a95],) :> ([[α94]], [[list['a96]]],)]], α94 :> α97, α97 :> bool] -//│ L: 1 [int ~ bool, int <: α97, α97 <: α94, [α94 - ([[α94]], [[list['a96]]],) ~ ('a95, list['a95],) - 'a95, L: 0 [([[α94]], [[list['a96]]],) ~ ('a95, list['a95],), ([[α94]], [[list['a96]]],) <: ('a95, list['a95],)]], ['a95 - ('a95, list['a95],) ~ ([[α94]], [[list['a96]]],) - α94, L: 0 [('a95, list['a95],) ~ ([[α94]], [[list['a96]]],), ('a95, list['a95],) :> ([[α94]], [[list['a96]]],)]], α94 :> α97, α97 :> bool] +//│ U max: 4, total: 17 +//│ UERR 2 errors +//│ L: 0 [bool ~ int, bool <: α84, α84 :> int] +//│ L: 1 [bool ~ int, bool <: α85, [α85 - list[[α85]] ~ list[[α83]] - α83, L: 0 [list[[α85]] ~ list[[α83]], list[[α85]] <: α82, α82 :> list[[α83]]]], α83 :> α84, α84 :> int] let rec t = wrap (if true then 1 else t) //│ [ERROR] Type `_ list` does not match `int` //│ -//│ (_ list) ---> (?t) ---> (?b) ---> (?a) <--- (?b) <--- (int) +//│ (?a list) ---> (?t) ---> (?b) ---> (?a) <--- (?b) <--- (int) //│ -//│ ◉ (_ list) comes from -//│ │ - l.-301let wrap x = x :: [] +//│ ◉ (?a list) comes from +//│ │ - l.-111let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let rec t = wrap (if true then 1 else t) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -720,150 +530,16 @@ let rec t = wrap (if true then 1 else t) //│ ◉ (?b) is assumed for //│ │ - l.1 let rec t = wrap (if true then 1 else t) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.-301let wrap x = x :: [] +//│ │ - l.-111let wrap x = x :: [] //│ │ ^ //│ ▼ //│ ◉ (?a) is assumed for -//│ ▲ - l.-301let wrap x = x :: [] -//│ │ ^ -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (?b) is assumed for -//│ ▲ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (int) comes from -//│ - l.1 let rec t = wrap (if true then 1 else t) -//│ ^ -//│ [ERROR] Type `_ list` does not match `int` -//│ -//│ (?a list) ---> (?t) ---> (?c) ---> (?b) ~~~~ (?a) ~~~~ (?b) <--- (?c) <--- (int) -//│ -//│ ◉ (?a list) comes from -//│ │ - l.-301let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^ -//│ ▼ -//│ ◉ (?t) is assumed for -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^ -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^ -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?c) is assumed for -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for -//│ - l.-301let wrap x = x :: [] -//│ ^ -//│ ◉ (?b * _ list) comes from -//│ │ - l.-301let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.-301let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.-301let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?b * _ list) comes from -//│ - l.-301let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?b) is assumed for -//│ ▲ - l.-301let wrap x = x :: [] +//│ ▲ - l.-111let wrap x = x :: [] //│ │ ^ //│ │ - l.1 let rec t = wrap (if true then 1 else t) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?c) is assumed for -//│ ▲ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (int) comes from -//│ - l.1 let rec t = wrap (if true then 1 else t) -//│ ^ -//│ [ERROR] Type `_ list` does not match `int` -//│ -//│ (?a list) ---> (?t) ---> (?c) ---> (?b) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?a) ~~~~ (?b) <--- (?c) <--- (int) -//│ -//│ ◉ (?a list) comes from -//│ │ - l.-301let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^ -//│ ▼ -//│ ◉ (?t) is assumed for -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^ -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^ -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?c) is assumed for -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for -//│ - l.-301let wrap x = x :: [] -//│ ^ -//│ ◉ (?b * ?a0 list) comes from -//│ │ - l.-301let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.-301let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.-301let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?b * ?a0 list) comes from -//│ - l.-301let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0 list) comes from -//│ - l.-301let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ - l.-301let wrap x = x :: [] -//│ ^^ -//│ ◉ (?b * ?a0 list) comes from -//│ │ - l.-301let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.-301let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.-301let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?b * ?a0 list) comes from -//│ - l.-301let wrap x = x :: [] -//│ ^^^^^^^ //│ ◉ (?b) is assumed for -//│ ▲ - l.-301let wrap x = x :: [] -//│ │ ^ -//│ │ - l.1 let rec t = wrap (if true then 1 else t) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (?c) is assumed for //│ ▲ - l.1 let rec t = wrap (if true then 1 else t) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ @@ -872,13 +548,10 @@ let rec t = wrap (if true then 1 else t) //│ ^ //│ t: 't //│ where -//│ 't = list['a], int -//│ 'a = list['a], int -//│ U max: 5, total: 37 -//│ UERR 3 errors -//│ L: 1 [list['a104'] ~ int, list['a104'] <: t102', t102' <: α106', α106' <: α103', [α103' - ([[α103']], [[list['a105']]],) ~ ('a104', list['a104'],) - 'a104', L: 0 [([[α103']], [[list['a105']]],) ~ ('a104', list['a104'],), ([[α103']], [[list['a105']]],) <: ('a104', list['a104'],)]], ['a104' - ('a104', list['a104'],) ~ ([[α103']], [[list['a105']]],) - α103', L: 0 [('a104', list['a104'],) ~ ([[α103']], [[list['a105']]],), ('a104', list['a104'],) :> ([[α103']], [[list['a105']]],)]], α103' :> α106', α106' :> int] -//│ L: 0 [list['a104'] ~ int, list['a104'] <: t102', t102' <: α106', α106' <: α103', α103' :> α106', α106' :> int] -//│ L: 2 [list['a104'] ~ int, list['a104'] <: t102', t102' <: α106', α106' <: α103', [α103' - ([[α103']], [[list['a105']]],) ~ ('a104', list['a104'],) - 'a104', L: 0 [([[α103']], [[list['a105']]],) ~ ('a104', list['a104'],), ([[α103']], [[list['a105']]],) <: ('a104', list['a104'],)]], ['a104' - list['a104'] ~ list['a105'] - 'a105', L: 1 [list['a104'] ~ list['a105'], [list['a104'] - ('a104', list['a104'],) ~ ([[α103']], [[list['a105']]],) - list['a105'], L: 0 [('a104', list['a104'],) ~ ([[α103']], [[list['a105']]],), ('a104', list['a104'],) :> ([[α103']], [[list['a105']]],)]]]], ['a105' - list['a105'] ~ list['a104'] - 'a104', L: 1 [list['a105'] ~ list['a104'], [list['a105'] - ([[α103']], [[list['a105']]],) ~ ('a104', list['a104'],) - list['a104'], L: 0 [([[α103']], [[list['a105']]],) ~ ('a104', list['a104'],), ([[α103']], [[list['a105']]],) <: ('a104', list['a104'],)]]]], ['a104' - ('a104', list['a104'],) ~ ([[α103']], [[list['a105']]],) - α103', L: 0 [('a104', list['a104'],) ~ ([[α103']], [[list['a105']]],), ('a104', list['a104'],) :> ([[α103']], [[list['a105']]],)]], α103' :> α106', α106' :> int] +//│ 't = list['t], int +//│ U max: 3, total: 11 +//│ UERR 1 errors +//│ L: 0 [list[[α88']] ~ int, list[[α88']] <: t87', t87' <: α89', α89' <: α88', α88' :> α89', α89' :> int] let test z = if true then wrap z else wrap true @@ -886,17 +559,17 @@ let test z = if true then wrap z else wrap true let rec m = test (if true then 1 else m) //│ [ERROR] Type `_ list` does not match `int` //│ -//│ (_ list) ---> (?c) ---> (?m) ---> (?a) ---> (?b) <--- (?a) <--- (int) +//│ (_ list) ---> (?b) ---> (?m) ---> (?c) ---> (?a) <--- (?c) <--- (int) //│ //│ ◉ (_ list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ +//│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -912,19 +585,19 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for +//│ ◉ (?c) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?a) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ @@ -933,17 +606,17 @@ let rec m = test (if true then 1 else m) //│ ^ //│ [ERROR] Type `_ list` does not match `int` //│ -//│ (_ list) ---> (?c) ---> (?m) ---> (?a) ---> (?b) <--- (?a) <--- (int) +//│ (_ list) ---> (?b) ---> (?m) ---> (?c) ---> (?a) <--- (?c) <--- (int) //│ //│ ◉ (_ list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ +//│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -959,117 +632,87 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for +//│ ◉ (?c) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?a) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ //│ ◉ (int) comes from //│ - l.3 let rec m = test (if true then 1 else m) //│ ^ -//│ [ERROR] Type `_ list` does not match `int` +//│ [ERROR] Type `int` does not match `bool` //│ -//│ (_ list) ---> (?b) ---> (?m) ---> (?c) ---> (?e) ---> (?d) ~~~~ (?a) ~~~~ (?d) <--- (?e) <--- (?c) <--- (int) +//│ (int) ---> (?d) ---> (?b) ---> (?c) ~~~~ (?e) <--- (bool) //│ -//│ ◉ (_ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ ▼ -//│ ◉ (?m) is assumed for -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ +//│ ◉ (int) comes from //│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ +//│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?d) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?d * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?d * _ list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ //│ ◉ (?e) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (?c) is assumed for -//│ ▲ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ //│ │ -//│ ◉ (int) comes from -//│ - l.3 let rec m = test (if true then 1 else m) -//│ ^ -//│ [ERROR] Type `_ list` does not match `int` +//│ ◉ (bool) comes from +//│ - l.1 let test z = if true then wrap z else wrap true +//│ ^^^^ +//│ [ERROR] Type `_ list` does not match `bool` //│ -//│ (?a list) ---> (?b) ---> (?m) ---> (?c) ---> (?e) ---> (?d) ~~~~ (?a) ~~~~ (?d) <--- (?e) <--- (?c) <--- (int) +//│ (?c list) ---> (?a) ---> (?m) ---> (?d) ---> (?b) ---> (?c) ~~~~ (?e) <--- (bool) //│ -//│ ◉ (?a list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -1085,117 +728,40 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ ▼ -//│ ◉ (?e) is assumed for -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ ▼ -//│ ◉ (?d) is assumed for -//│ - l.-486let wrap x = x :: [] -//│ ^ -//│ ◉ (?d * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * _ list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ //│ ◉ (?d) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ -//│ ◉ (?e) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (?c) is assumed for -//│ ▲ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (int) comes from -//│ - l.3 let rec m = test (if true then 1 else m) -//│ ^ -//│ [ERROR] Type `int` does not match `bool` -//│ -//│ (int) ---> (?b) ---> (?f) ---> (?c) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?d) <--- (bool) -//│ -//│ ◉ (int) comes from -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ //│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * _ list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ //│ │ //│ ◉ (bool) comes from @@ -1203,17 +769,17 @@ let rec m = test (if true then 1 else m) //│ ^^^^ //│ [ERROR] Type `_ list` does not match `bool` //│ -//│ (?a0 list) ---> (?e) ---> (?m) ---> (?b) ---> (?f) ---> (?c) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?d) <--- (bool) +//│ (?e list) ---> (?a) ---> (?m) ---> (?d) ---> (?b) ---> (?c) ~~~~ (?e) <--- (bool) //│ -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -1229,74 +795,58 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ //│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * _ list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ //│ │ //│ ◉ (bool) comes from //│ - l.1 let test z = if true then wrap z else wrap true //│ ^^^^ -//│ [ERROR] Type `_ list` does not match `bool` +//│ [ERROR] Type `_ list` does not match `int` //│ -//│ (?a list) ---> (?e) ---> (?m) ---> (?b) ---> (?f) ---> (?c) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?d) <--- (bool) +//│ (?c list) ---> (?a) ---> (?m) ---> (?d) ---> (?b) ---> (?c) ~~~~ (?e) ~~~~ (?c) <--- (?b) <--- (?d) <--- (int) //│ -//│ ◉ (?a list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -1312,163 +862,94 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ //│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * _ list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^ -//│ │ -//│ ◉ (bool) comes from -//│ - l.1 let test z = if true then wrap z else wrap true -//│ ^^^^ -//│ [ERROR] Type `int` does not match `bool` -//│ -//│ (int) ---> (?b) ---> (?f) ---> (?c) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?d) <--- (bool) -//│ -//│ ◉ (int) comes from -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ ▼ -//│ ◉ (?f) is assumed for -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ ▼ -//│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ +//│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ +//│ │ ^^^^^^ //│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ //│ │ -//│ ◉ (bool) comes from -//│ - l.1 let test z = if true then wrap z else wrap true -//│ ^^^^ -//│ [ERROR] Type `_ list` does not match `bool` +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (int) comes from +//│ - l.3 let rec m = test (if true then 1 else m) +//│ ^ +//│ [ERROR] Type `_ list` does not match `int` //│ -//│ (?a1 list) ---> (?e) ---> (?m) ---> (?b) ---> (?f) ---> (?c) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?d) <--- (bool) +//│ (?e list) ---> (?a) ---> (?m) ---> (?d) ---> (?b) ---> (?c) ~~~~ (?e) ~~~~ (?c) <--- (?b) <--- (?d) <--- (int) //│ -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -1484,369 +965,75 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ //│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?e) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^ -//│ │ -//│ ◉ (bool) comes from -//│ - l.1 let test z = if true then wrap z else wrap true -//│ ^^^^ -//│ [ERROR] Type `_ list` does not match `bool` -//│ -//│ (?a0 list) ---> (?e) ---> (?m) ---> (?b) ---> (?f) ---> (?c) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?d) <--- (bool) -//│ -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?e) is assumed for -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ ▼ -//│ ◉ (?m) is assumed for -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ ▼ -//│ ◉ (?f) is assumed for -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ ▼ -//│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] -//│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^ -//│ │ -//│ ◉ (bool) comes from -//│ - l.1 let test z = if true then wrap z else wrap true -//│ ^^^^ -//│ [ERROR] Type `_ list` does not match `int` -//│ -//│ (?a1 list) ---> (?e) ---> (?m) ---> (?b) ---> (?f) ---> (?c) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?d) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?c) <--- (?f) <--- (?b) <--- (int) -//│ -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ //│ ◉ (?e) is assumed for -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ ▼ -//│ ◉ (?m) is assumed for -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ ▼ -//│ ◉ (?f) is assumed for -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ ▼ -//│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] -//│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?e) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ //│ ◉ (?c) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ @@ -1855,17 +1042,17 @@ let rec m = test (if true then 1 else m) //│ ^ //│ [ERROR] Type `_ list` does not match `int` //│ -//│ (?a0 list) ---> (?e) ---> (?m) ---> (?b) ---> (?f) ---> (?c) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?d) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?c) <--- (?f) <--- (?b) <--- (int) +//│ (?e list) ---> (?a) ---> (?m) ---> (?d) ---> (?b) ---> (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) <--- (?b) <--- (?d) <--- (int) //│ -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ +//│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -1881,297 +1068,90 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ //│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ //│ ◉ (?c) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ -//│ ◉ (?f) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (?b) is assumed for -//│ ▲ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (int) comes from -//│ - l.3 let rec m = test (if true then 1 else m) -//│ ^ -//│ [ERROR] Type `_ list` does not match `int` -//│ -//│ (?a1 list) ---> (?b) ---> (?m) ---> (?c) ---> (?e) ---> (?d) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?d) <--- (?e) <--- (?c) <--- (int) -//│ -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ ▼ -//│ ◉ (?m) is assumed for -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?c) is assumed for -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ ▼ -//│ ◉ (?e) is assumed for -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ ▼ -//│ ◉ (?d) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?d * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ ▼ -//│ ◉ (?m) is assumed for -//│ ▲ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (?b) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (_ * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (_ * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?b) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ -//│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -2187,38 +1167,30 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?d) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?d * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -2234,80 +1206,52 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (_ * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (_ * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * _ list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?c) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -2323,56 +1267,52 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * _ list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?c) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ @@ -2381,50 +1321,46 @@ let rec m = test (if true then 1 else m) //│ ^ //│ [ERROR] Type `bool` does not match `int` //│ -//│ (bool) ---> (?d) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?c) <--- (?f) <--- (?b) <--- (int) +//│ (bool) ---> (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) <--- (?b) <--- (?d) <--- (int) //│ //│ ◉ (bool) comes from //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^ //│ ▼ -//│ ◉ (?d) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -2440,67 +1376,67 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -2516,38 +1452,30 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ //│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -2563,80 +1491,52 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ //│ ◉ (?c) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -2652,75 +1552,71 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ //│ ◉ (?c) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ //│ ◉ (int) comes from //│ - l.3 let rec m = test (if true then 1 else m) //│ ^ -//│ [ERROR] Type `_ list` does not match `bool` +//│ [ERROR] Type `_ list` does not match `int` //│ -//│ (?a1 list) ---> (?e) ---> (?m) ---> (?b) ---> (?f) ---> (?c) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?d) <--- (bool) +//│ (?c list) ---> (?a) ---> (?m) ---> (?d) ---> (?b) ---> (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) <--- (?b) <--- (?d) <--- (int) //│ -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ +//│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -2736,38 +1632,30 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ //│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -2783,67 +1671,67 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -2859,38 +1747,30 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ //│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -2906,80 +1786,52 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ //│ ◉ (?c) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -2995,166 +1847,100 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ ▼ -//│ ◉ (?m) is assumed for -//│ ▲ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?e) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ -//│ │ -//│ ◉ (bool) comes from -//│ - l.1 let test z = if true then wrap z else wrap true -//│ ^^^^ -//│ [ERROR] Type `_ list` does not match `int` -//│ -//│ (?a0 list) ---> (?e) ---> (?m) ---> (?b) ---> (?f) ---> (?c) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?d) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?c) <--- (?f) <--- (?b) <--- (int) -//│ -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?e) is assumed for +//│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ ▼ -//│ ◉ (?m) is assumed for -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ +//│ │ ^ +//│ │ //│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (int) comes from +//│ - l.3 let rec m = test (if true then 1 else m) +//│ ^ +//│ [ERROR] Type `bool` does not match `_ list` +//│ +//│ (bool) ---> (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) <--- (?b) <--- (?d) <--- (?m) <--- (?a) <--- (?e list) +//│ +//│ ◉ (bool) comes from //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ ▼ -//│ ◉ (?f) is assumed for -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^ +//│ │ ^^^^ //│ ▼ -//│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -3170,25 +1956,29 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -3204,129 +1994,29 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?e) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?e) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ -//│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -3342,38 +2032,30 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ //│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -3389,80 +2071,52 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ //│ ◉ (?c) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -3478,75 +2132,89 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ //│ ◉ (?c) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ //│ │ -//│ ◉ (int) comes from -//│ - l.3 let rec m = test (if true then 1 else m) -//│ ^ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ //│ [ERROR] Type `_ list` does not match `bool` //│ -//│ (?a0 list) ---> (?e) ---> (?m) ---> (?b) ---> (?f) ---> (?c) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?d) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a) ~~~~ (?a1) ~~~~ (?d) <--- (bool) +//│ (?c list) ---> (?a) ---> (?m) ---> (?d) ---> (?b) ---> (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) <--- (bool) //│ -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -3562,79 +2230,4600 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ //│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ //│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ +//│ ◉ (bool) comes from +//│ - l.1 let test z = if true then wrap z else wrap true +//│ ^^^^ +//│ [ERROR] Type `int` does not match `_ list` +//│ +//│ (int) ---> (?d) ---> (?b) ---> (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) <--- (?b) <--- (?d) <--- (?m) <--- (?a) <--- (?e list) +//│ +//│ ◉ (int) comes from +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ [ERROR] Type `int` does not match `bool` +//│ +//│ (int) ---> (?d) ---> (?b) ---> (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) <--- (bool) +//│ +//│ ◉ (int) comes from +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ +//│ ◉ (bool) comes from +//│ - l.1 let test z = if true then wrap z else wrap true +//│ ^^^^ +//│ [ERROR] Type `int` does not match `_ list` +//│ +//│ (int) ---> (?d) ---> (?b) ---> (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) <--- (?b) <--- (?d) <--- (?m) <--- (?a) <--- (?c list) +//│ +//│ ◉ (int) comes from +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ [ERROR] Type `_ list` does not match `bool` +//│ +//│ (?e list) ---> (?a) ---> (?m) ---> (?d) ---> (?b) ---> (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) <--- (bool) +//│ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ +//│ ◉ (bool) comes from +//│ - l.1 let test z = if true then wrap z else wrap true +//│ ^^^^ +//│ [ERROR] Type `bool` does not match `_ list` +//│ +//│ (bool) ---> (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) ~~~~ (?e) ~~~~ (?c) <--- (?b) <--- (?d) <--- (?m) <--- (?a) <--- (?c list) +//│ +//│ ◉ (bool) comes from +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^ +//│ ▼ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?d) is assumed for +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?b) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ //│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] +//│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ ▼ -//│ ◉ (?m) is assumed for -//│ ▲ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^ -//│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ ^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?e) is assumed for -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^ -//│ ▼ +//│ │ //│ ◉ (?m) is assumed for //│ ▲ - l.3 let rec m = test (if true then 1 else m) //│ │ ^ @@ -3643,129 +6832,29 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ -//│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ -//│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -3781,38 +6870,52 @@ let rec m = test (if true then 1 else m) //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ ▼ //│ ◉ (?c) is assumed for -//│ - l.-486let wrap x = x :: [] +//│ - l.-159let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ +//│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -3828,80 +6931,30 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ -//│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ //│ ◉ (?c) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?b) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^ //│ │ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?b) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.3 let rec m = test (if true then 1 else m) //│ │ ^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -3917,25 +6970,29 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ +//│ │ ^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?c list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ +//│ │ ^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let rec m = test (if true then 1 else m) @@ -3951,96 +7008,116 @@ let rec m = test (if true then 1 else m) //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ +//│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?e list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.-486let wrap x = x :: [] +//│ ◉ (?e) is assumed for +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ - l.-159let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.-159let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^ +//│ │ ^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for -//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ ◉ (?a) is assumed for +//│ │ - l.1 let test z = if true then wrap z else wrap true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ ▼ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.1 let test z = if true then wrap z else wrap true -//│ │ ^^^^^^^^^ +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^ -//│ ◉ (?d * ?a list) comes from -//│ │ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a1 * ?a1 list) comes from -//│ - l.-486let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 * ?a1 list) comes from -//│ ▲ - l.-486let wrap x = x :: [] -//│ │ ^^^^^^^ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ //│ │ -//│ ◉ (?d * ?a list) comes from -//│ - l.-486let wrap x = x :: [] +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?d) is assumed for -//│ ▲ - l.-486let wrap x = x :: [] +//│ ◉ (?c) is assumed for +//│ ▲ - l.-159let wrap x = x :: [] //│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ //│ │ -//│ ◉ (bool) comes from -//│ - l.1 let test z = if true then wrap z else wrap true -//│ ^^^^ +//│ ◉ (?b) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?d) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ +//│ ◉ (?m) is assumed for +//│ ▲ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^ +//│ │ - l.3 let rec m = test (if true then 1 else m) +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ +//│ ◉ (?a) is assumed for +//│ ▲ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.1 let test z = if true then wrap z else wrap true +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?c list) comes from +//│ - l.-159let wrap x = x :: [] +//│ ^^^^^^^ //│ test: bool -> list[bool] //│ m: 'm //│ where -//│ 'm = int, bool, list['m], list['a] -//│ 'a = int, bool, list['a] -//│ U max: 56, total: 218 +//│ 'm = list['a], bool, int +//│ 'a = list['a], bool, int +//│ U max: 34, total: 155 //│ UERR 17 errors -//│ L: 1 [list['a122'] ~ bool, list['a122'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' :> list['a122']]], ['a122' - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - α121', L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]], α121' :> bool] -//│ L: 1 [list['a124'] ~ bool, list['a124'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' :> list['a122']]], ['a122' - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - α121', L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]], α121' :> bool] -//│ L: 2 [list['a124'] ~ int, list['a124'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - α121', L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]], [α121' - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - 'a122', L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - ('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],) - α127', L: 0 [('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],), ('a124', list['a124'],) :> ([[α127']], [[list['a126']]],)]], α127' :> α120', α120' :> α128', α128' :> int] -//│ L: 2 [list['a124'] ~ bool, list['a124'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - α121', L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]], α121' :> bool] -//│ L: 1 [list['a124'] ~ int, list['a124'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - ('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],) - α127', L: 0 [('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],), ('a124', list['a124'],) :> ([[α127']], [[list['a126']]],)]], α127' :> α120', α120' :> α128', α128' :> int] -//│ L: 1 [list['a122'] ~ int, list['a122'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - ('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],) - α127', L: 0 [('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],), ('a124', list['a124'],) :> ([[α127']], [[list['a126']]],)]], α127' :> α120', α120' :> α128', α128' :> int] -//│ L: 3 [bool ~ int, bool <: α121', [α121' - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - 'a122', L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 2 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - ('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],) - α127', L: 0 [('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],), ('a124', list['a124'],) :> ([[α127']], [[list['a126']]],)]], α127' :> α120', α120' :> α128', α128' :> m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - ('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],) - α127', L: 0 [('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],), ('a124', list['a124'],) :> ([[α127']], [[list['a126']]],)]], α127' :> α120', α120' :> α128', α128' :> int] -//│ L: 0 [list['a122'] ~ int, list['a122'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' :> α128', α128' :> int] -//│ L: 1 [int ~ bool, int <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' :> list['a122']]], ['a122' - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - α121', L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]], α121' :> bool] -//│ L: 2 [list['a122'] ~ int, list['a122'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - α121', L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]], [α121' - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - 'a122', L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - ('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],) - α127', L: 0 [('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],), ('a124', list['a124'],) :> ([[α127']], [[list['a126']]],)]], α127' :> α120', α120' :> α128', α128' :> int] -//│ L: 3 [list['a122'] ~ bool, list['a122'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 2 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - ('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],) - α127', L: 0 [('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],), ('a124', list['a124'],) :> ([[α127']], [[list['a126']]],)]], α127' :> α120', α120' :> α128', α128' :> m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a124']]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - α121', L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]], α121' :> bool] -//│ L: 2 [list['a122'] ~ bool, list['a122'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - α121', L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]], α121' :> bool] -//│ L: 2 [int ~ bool, int <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - α121', L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]], α121' :> bool] -//│ L: 3 [list['a124'] ~ int, list['a124'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a124']]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - α121', L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]], [α121' - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - 'a122', L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 2 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - ('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],) - α127', L: 0 [('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],), ('a124', list['a124'],) :> ([[α127']], [[list['a126']]],)]], α127' :> α120', α120' :> α128', α128' :> m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - ('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],) - α127', L: 0 [('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],), ('a124', list['a124'],) :> ([[α127']], [[list['a126']]],)]], α127' :> α120', α120' :> α128', α128' :> int] -//│ L: 3 [list['a122'] ~ int, list['a122'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 2 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - ('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],) - α127', L: 0 [('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],), ('a124', list['a124'],) :> ([[α127']], [[list['a126']]],)]], α127' :> α120', α120' :> α128', α128' :> m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - ('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],) - α127', L: 0 [('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],), ('a124', list['a124'],) :> ([[α127']], [[list['a126']]],)]], α127' :> α120', α120' :> α128', α128' :> int] -//│ L: 0 [list['a124'] ~ int, list['a124'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' :> α128', α128' :> int] -//│ L: 3 [list['a124'] ~ bool, list['a124'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a124']]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - α121', L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]], [α121' - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - 'a122', L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 2 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' <: α128', α128' <: α120', α120' <: α127', [α127' - ([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],) - 'a124', L: 0 [([[α127']], [[list['a126']]],) ~ ('a124', list['a124'],), ([[α127']], [[list['a126']]],) <: ('a124', list['a124'],)]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' :> list['a124']]], ['a124' - ('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],) - α127', L: 0 [('a124', list['a124'],) ~ ([[α127']], [[list['a126']]],), ('a124', list['a124'],) :> ([[α127']], [[list['a126']]],)]], α127' :> α120', α120' :> α128', α128' :> m119', m119' :> α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a124'] - 'a124', L: 0 [list['a122'] ~ list['a124'], list['a122'] <: α125', α125' <: m119', m119' :> α125', α125' :> list['a124']]], ['a124' - list['a124'] ~ list['a122'] - 'a122', L: 0 [list['a124'] ~ list['a122'], list['a124'] <: α125', α125' :> list['a122']]], ['a122' - list['a122'] ~ list['a123'] - 'a123', L: 1 [list['a122'] ~ list['a123'], [list['a122'] - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - list['a123'], L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]]]], ['a123' - list['a123'] ~ list['a122'] - 'a122', L: 1 [list['a123'] ~ list['a122'], [list['a123'] - ([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],) - list['a122'], L: 0 [([[α121']], [[list['a123']]],) ~ ('a122', list['a122'],), ([[α121']], [[list['a123']]],) <: ('a122', list['a122'],)]]]], ['a122' - ('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],) - α121', L: 0 [('a122', list['a122'],) ~ ([[α121']], [[list['a123']]],), ('a122', list['a122'],) :> ([[α121']], [[list['a123']]],)]], α121' :> bool] +//│ L: 2 [bool ~ list[[α99']], bool <: α99', [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]] +//│ L: 2 [list[[α100']] ~ bool, list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], α99' :> bool] +//│ L: 3 [list[[α99']] ~ bool, list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 1 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 2 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 1 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], α99' :> bool] +//│ L: 1 [list[[α99']] ~ int, list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> int] +//│ L: 1 [list[[α100']] ~ int, list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> int] +//│ L: 0 [list[[α99']] ~ int, list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' :> α102', α102' :> int] +//│ L: 2 [bool ~ int, bool <: α99', [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> int] +//│ L: 0 [list[[α100']] ~ int, list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' :> α102', α102' :> int] +//│ L: 3 [int ~ bool, int <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 1 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 2 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 1 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], α99' :> bool] +//│ L: 1 [list[[α99']] ~ bool, list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], α99' :> bool] +//│ L: 3 [bool ~ list[[α100']], bool <: α99', [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 1 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 2 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 1 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α100']]] +//│ L: 2 [list[[α100']] ~ int, list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> int] +//│ L: 2 [list[[α99']] ~ int, list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> int] +//│ L: 1 [int ~ bool, int <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], α99' :> bool] +//│ L: 3 [int ~ list[[α99']], int <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 1 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 2 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 1 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]] +//│ L: 3 [int ~ list[[α100']], int <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 1 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 2 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 1 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 1 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α100']]]], [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α99']]]], [α99' - list[[α99']] ~ list[[α100']] - α100', L: 0 [list[[α99']] ~ list[[α100']], list[[α99']] <: α101', α101' <: m97', m97' :> α101', α101' :> list[[α100']]]], α100' :> α98', α98' :> α102', α102' :> m97', m97' :> α101', α101' :> list[[α100']]] +//│ L: 1 [list[[α100']] ~ bool, list[[α100']] <: α101', α101' <: m97', m97' <: α102', α102' <: α98', α98' <: α100', [α100' - list[[α100']] ~ list[[α99']] - α99', L: 0 [list[[α100']] ~ list[[α99']], list[[α100']] <: α101', α101' :> list[[α99']]]], α99' :> bool] // FIXME implementation exception @@ -4092,13 +7169,13 @@ let rec digitsOfInt n = //│ ^^^ //│ ╔══[ERROR] identifier not found: remainder //│ ║ -//│ ║ l.4048: ((digitsOfInt n) / 10) @ [remainder];; +//│ ║ l.7125: ((digitsOfInt n) / 10) @ [remainder];; //│ ╙── ^^^^^^^^^ //│ digitsOfInt: 'digitsOfInt //│ where //│ 'digitsOfInt = 'a -> list[err], 'a -> 'b //│ 'b = list[err], int -//│ U max: 3, total: 23 +//│ U max: 2, total: 11 //│ UERR 2 errors -//│ L: 0 [int ~ list[α133'], int <: list[α133']] -//│ L: 1 [list[α133'] ~ int, [list[α133'] - (α132' -> [list[α133']]) ~ ([α132'] -> α134') - α134', L: 0 [(α132' -> [list[α133']]) ~ ([α132'] -> α134'), (α132' -> [list[α133']]) <: digitsOfInt131', digitsOfInt131' <: ([α132'] -> α134')]], α134' <: int] +//│ L: 0 [int ~ list[α107'], int <: list[α107']] +//│ L: 1 [list[α107'] ~ int, [list[α107'] - (α106' -> [list[α107']]) ~ ([α106'] -> α108') - α108', L: 0 [(α106' -> [list[α107']]) ~ ([α106'] -> α108'), (α106' -> [list[α107']]) <: digitsOfInt105', digitsOfInt105' <: ([α106'] -> α108')]], α108' <: int] diff --git a/shared/src/test/diff/ocaml/SurveyHard2.mls b/shared/src/test/diff/ocaml/SurveyHard2.mls index ca5da5a..0f6da0f 100644 --- a/shared/src/test/diff/ocaml/SurveyHard2.mls +++ b/shared/src/test/diff/ocaml/SurveyHard2.mls @@ -103,7 +103,7 @@ let bigAdd l1 l2 = //│ ◉ (_ * _) comes from //│ - l.14 let (_,res) = List.fold_left f base args in res in //│ ^^^^^^^ -//│ U max: 63, total: 470 +//│ U max: 63, total: 468 //│ UERR 3 errors //│ L: 2 [int ~ ([α127''], [α128''],), [int - (α123'' -> [int]) ~ (α121'' -> α120'') - α120'', L: 1 [(α123'' -> [int]) ~ (α121'' -> α120''), [(α123'' -> [int]) - (α122'' -> (α123'' -> [int])) ~ (α120'' -> (α121'' -> α120'')) - (α121'' -> α120''), L: 0 [(α122'' -> (α123'' -> [int])) ~ (α120'' -> (α121'' -> α120'')), (α122'' -> (α123'' -> [int])) <: (α120'' -> (α121'' -> α120''))]]]], α120'' <: ([α127''], [α128''],)] //│ L: 1 [int ~ ([α127''], [α128''],), int :> α122'', [α122'' - (α122'' -> (α123'' -> [int])) ~ (α120'' -> (α121'' -> α120'')) - α120'', L: 0 [(α122'' -> (α123'' -> [int])) ~ (α120'' -> (α121'' -> α120'')), (α122'' -> (α123'' -> [int])) <: (α120'' -> (α121'' -> α120''))]], α120'' <: ([α127''], [α128''],)] diff --git a/shared/src/test/diff/ocaml/SurveyHard3.mls b/shared/src/test/diff/ocaml/SurveyHard3.mls index a74ec56..c9d075e 100644 --- a/shared/src/test/diff/ocaml/SurveyHard3.mls +++ b/shared/src/test/diff/ocaml/SurveyHard3.mls @@ -181,9 +181,9 @@ let bigAdd l1 l2 = //│ ◉ (_ * _) comes from //│ - l.22 (let (toSum1,toSum2) = x in //│ ^^^^^^^^^^^^^^^ -//│ U max: 35, total: 551 +//│ U max: 33, total: 532 //│ UERR 3 errors -//│ L: 2 [([α127''], [α128''],) ~ list['a139''], [([α127''], [α128''],) - list[([α127''], [α128''],)] ~ list[α145''] - α145'', L: 0 [list[([α127''], [α128''],)] ~ list[α145''], list[([α127''], [α128''],)] <: list[α145'']]], [α145'' - list[α145''] ~ list[α130''] - α130'', L: 0 [list[α145''] ~ list[α130''], list[α145''] <: list[α130'']]], [α130'' - (α130'' -> α129'') ~ (α136'' -> α141'') - α136'', L: 1 [(α130'' -> α129'') ~ (α136'' -> α141''), [(α130'' -> α129'') - (α129'' -> (α130'' -> α129'')) ~ (α131'' -> (α136'' -> α141'')) - (α136'' -> α141''), L: 0 [(α129'' -> (α130'' -> α129'')) ~ (α131'' -> (α136'' -> α141'')), (α129'' -> (α130'' -> α129'')) :> (α131'' -> (α136'' -> α141''))]]]], α136'' <: α140'', α140'' :> list['a139'']] -//│ L: 2 [list['a139''] ~ ([α137''], [α138''],), list['a139''] <: α140'', α140'' :> α136'', [α136'' - (α136'' -> α141'') ~ (α130'' -> α129'') - α130'', L: 1 [(α136'' -> α141'') ~ (α130'' -> α129''), [(α136'' -> α141'') - (α131'' -> (α136'' -> α141'')) ~ (α129'' -> (α130'' -> α129'')) - (α130'' -> α129''), L: 0 [(α131'' -> (α136'' -> α141'')) ~ (α129'' -> (α130'' -> α129'')), (α131'' -> (α136'' -> α141'')) <: (α129'' -> (α130'' -> α129''))]]]], [α130'' - (α130'' -> α129'') ~ (α136'' -> α141'') - α136'', L: 1 [(α130'' -> α129'') ~ (α136'' -> α141''), [(α130'' -> α129'') - (α129'' -> (α130'' -> α129'')) ~ (α131'' -> (α136'' -> α141'')) - (α136'' -> α141''), L: 0 [(α129'' -> (α130'' -> α129'')) ~ (α131'' -> (α136'' -> α141'')), (α129'' -> (α130'' -> α129'')) :> (α131'' -> (α136'' -> α141''))]]]], α136'' <: ([α137''], [α138''],)] +//│ L: 2 [([α127''], [α128''],) ~ list['a141''], [([α127''], [α128''],) - list[([α127''], [α128''],)] ~ list[α144''] - α144'', L: 0 [list[([α127''], [α128''],)] ~ list[α144''], list[([α127''], [α128''],)] <: list[α144'']]], [α144'' - list[α144''] ~ list[α130''] - α130'', L: 0 [list[α144''] ~ list[α130''], list[α144''] <: list[α130'']]], [α130'' - (α130'' -> α129'') ~ (α138'' -> α135'') - α138'', L: 1 [(α130'' -> α129'') ~ (α138'' -> α135''), [(α130'' -> α129'') - (α129'' -> (α130'' -> α129'')) ~ (α131'' -> (α138'' -> α135'')) - (α138'' -> α135''), L: 0 [(α129'' -> (α130'' -> α129'')) ~ (α131'' -> (α138'' -> α135'')), (α129'' -> (α130'' -> α129'')) :> (α131'' -> (α138'' -> α135''))]]]], α138'' <: α142'', α142'' :> list['a141'']] +//│ L: 2 [list['a141''] ~ ([α139''], [α140''],), list['a141''] <: α142'', α142'' :> α138'', [α138'' - (α138'' -> α135'') ~ (α130'' -> α129'') - α130'', L: 1 [(α138'' -> α135'') ~ (α130'' -> α129''), [(α138'' -> α135'') - (α131'' -> (α138'' -> α135'')) ~ (α129'' -> (α130'' -> α129'')) - (α130'' -> α129''), L: 0 [(α131'' -> (α138'' -> α135'')) ~ (α129'' -> (α130'' -> α129'')), (α131'' -> (α138'' -> α135'')) <: (α129'' -> (α130'' -> α129''))]]]], [α130'' - (α130'' -> α129'') ~ (α138'' -> α135'') - α138'', L: 1 [(α130'' -> α129'') ~ (α138'' -> α135''), [(α130'' -> α129'') - (α129'' -> (α130'' -> α129'')) ~ (α131'' -> (α138'' -> α135'')) - (α138'' -> α135''), L: 0 [(α129'' -> (α130'' -> α129'')) ~ (α131'' -> (α138'' -> α135'')), (α129'' -> (α130'' -> α129'')) :> (α131'' -> (α138'' -> α135''))]]]], α138'' <: ([α139''], [α140''],)] //│ L: 0 [list['a118'''] ~ ([α122'''], [α123'''],), list['a118'''] <: α117''', α117''' :> α113''', α113''' <: ([α122'''], [α123'''],)] diff --git a/shared/src/test/diff/ocaml/SurveyMed1.mls b/shared/src/test/diff/ocaml/SurveyMed1.mls index 4e057a0..f02d233 100644 --- a/shared/src/test/diff/ocaml/SurveyMed1.mls +++ b/shared/src/test/diff/ocaml/SurveyMed1.mls @@ -8,20 +8,20 @@ let rec check cond = test (if cond then false else check (not cond)) cond //│ [ERROR] Type `_ list` does not match `bool` //│ -//│ (_ list) ---> (?d) ~~~~ (?b) ---> (?e) ---> (?f) ---> (?c) ~~~~ (?a) ~~~~ (?c) <--- (?f) <--- (?e) <--- (bool) +//│ (?f list) ---> (?c) ~~~~ (?b) ---> (?d) ---> (?a) ---> (?e) ~~~~ (?f) ~~~~ (?e) <--- (?a) <--- (?d) <--- (bool) //│ -//│ ◉ (_ list) comes from +//│ ◉ (?f list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ - l.3 let test z cond = if cond //│ ^^^^^^^ //│ then wrap z ... //│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ │ - l.7 let rec check cond = //│ │ ^^^^^^ //│ │ test (if cond then false else check (not cond)) cond @@ -42,37 +42,69 @@ let rec check cond = //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.4 then wrap z //│ │ ^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ - l.1 let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ +//│ │ - l.4 then wrap z +//│ │ ^^^^^^ +//│ │ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a * ?a list) comes from +//│ ◉ (?c) is assumed for +//│ ▲ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ │ - l.5 else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?f list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.1 let wrap x = x :: [] +//│ ◉ (?f) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?f list) comes from +//│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ +//│ │ - l.5 else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ ▲ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ │ - l.4 then wrap z +//│ │ ^^^^^^ //│ │ -//│ ◉ (?c * _ list) comes from +//│ ◉ (?e list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ ▲ - l.1 let wrap x = x :: [] //│ │ ^ //│ │ - l.4 then wrap z @@ -80,13 +112,13 @@ let rec check cond = //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ @@ -95,20 +127,20 @@ let rec check cond = //│ ^^^^^ //│ [ERROR] Type `_ list` does not match `bool` //│ -//│ (?a list) ---> (?d) ~~~~ (?b) ---> (?e) ---> (?f) ---> (?c) ~~~~ (?a) ~~~~ (?c) <--- (?f) <--- (?e) <--- (bool) +//│ (?e list) ---> (?c) ~~~~ (?b) ---> (?d) ---> (?a) ---> (?e) ~~~~ (?f) ~~~~ (?e) <--- (?a) <--- (?d) <--- (bool) //│ -//│ ◉ (?a list) comes from +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ - l.3 let test z cond = if cond //│ ^^^^^^^ //│ then wrap z ... //│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ │ - l.7 let rec check cond = //│ │ ^^^^^^ //│ │ test (if cond then false else check (not cond)) cond @@ -129,37 +161,69 @@ let rec check cond = //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.4 then wrap z //│ │ ^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ - l.1 let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ +//│ │ - l.4 then wrap z +//│ │ ^^^^^^ +//│ │ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a * ?a list) comes from +//│ ◉ (?c) is assumed for +//│ ▲ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ │ - l.5 else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?f list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.1 let wrap x = x :: [] +//│ ◉ (?f) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?f list) comes from +//│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ +//│ │ - l.5 else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ ▲ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ │ - l.4 then wrap z +//│ │ ^^^^^^ //│ │ -//│ ◉ (?c * _ list) comes from +//│ ◉ (?e list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ ▲ - l.1 let wrap x = x :: [] //│ │ ^ //│ │ - l.4 then wrap z @@ -167,13 +231,13 @@ let rec check cond = //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ @@ -182,20 +246,20 @@ let rec check cond = //│ ^^^^^ //│ [ERROR] Type `_ list` does not match `bool` //│ -//│ (?a0 list) ---> (?d) ~~~~ (?b) ---> (?f) ---> (?g) ---> (?c) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?e) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?a) ~~~~ (?c) <--- (?g) <--- (?f) <--- (bool) +//│ (?f list) ---> (?c) ~~~~ (?b) ---> (?d) ---> (?a) ---> (?e) ~~~~ (?f) ~~~~ (?e) <--- (?a) <--- (?d) <--- (bool) //│ -//│ ◉ (?a0 list) comes from +//│ ◉ (?f list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ - l.3 let test z cond = if cond //│ ^^^^^^^ //│ then wrap z ... //│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ │ - l.7 let rec check cond = //│ │ ^^^^^^ //│ │ test (if cond then false else check (not cond)) cond @@ -216,40 +280,66 @@ let rec check cond = //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ ▼ -//│ ◉ (?g) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.4 then wrap z //│ │ ^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ - l.1 let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.4 then wrap z //│ │ ^^^^^^ -//│ │ - l.3 let test z cond = if cond -//│ │ ^^^^^^^ -//│ │ then wrap z ... -//│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for +//│ - l.3 let test z cond = if cond +//│ ^^^^^^^ +//│ then wrap z ... +//│ ^^^^^^^^^^^^^^^ +//│ ◉ (_ -> ?c) comes from +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^^ +//│ │ test (if cond then false else check (not cond)) cond +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (?check) is assumed for +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (bool -> ?b) comes from +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^ +//│ ◉ (?b) is assumed for +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^ +//│ ◉ (bool -> ?b) comes from +//│ ▲ - l.8 test (if cond then false else check (not cond)) cond +//│ │ ^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (?check) is assumed for +//│ ▲ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (_ -> ?c) comes from +//│ - l.7 let rec check cond = +//│ ^^^^^^ +//│ test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -257,79 +347,15 @@ let rec check cond = //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from +//│ ◉ (?f list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?e * ?a1 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^ -//│ ◉ (?e * ?a1 list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?e * ?a1 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?e) is assumed for +//│ ◉ (?f) is assumed for //│ - l.1 let wrap x = x :: [] //│ ^ //│ - l.1 let wrap x = x :: [] //│ ^ -//│ ◉ (?e * ?a1 list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?e * ?a1 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^ -//│ ◉ (?e * ?a1 list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from +//│ ◉ (?f list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.5 else wrap true @@ -339,7 +365,7 @@ let rec check cond = //│ │ then wrap z ... //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -347,18 +373,10 @@ let rec check cond = //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ │ -//│ ◉ (?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from +//│ ◉ (?e list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ ▲ - l.1 let wrap x = x :: [] //│ │ ^ //│ │ - l.4 then wrap z @@ -366,13 +384,13 @@ let rec check cond = //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ -//│ ◉ (?g) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ @@ -381,20 +399,20 @@ let rec check cond = //│ ^^^^^ //│ [ERROR] Type `_ list` does not match `bool` //│ -//│ (?a list) ---> (?d) ~~~~ (?b) ---> (?f) ---> (?g) ---> (?c) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?e) ~~~~ (?a0) ~~~~ (?a1) ~~~~ (?a0) ~~~~ (?a) ~~~~ (?c) <--- (?g) <--- (?f) <--- (bool) +//│ (?e list) ---> (?c) ~~~~ (?b) ---> (?d) ---> (?a) ---> (?e) ~~~~ (?f) ~~~~ (?e) ~~~~ (?f) ~~~~ (?e) <--- (?a) <--- (?d) <--- (bool) //│ -//│ ◉ (?a list) comes from +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ - l.3 let test z cond = if cond //│ ^^^^^^^ //│ then wrap z ... //│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ │ - l.7 let rec check cond = //│ │ ^^^^^^ //│ │ test (if cond then false else check (not cond)) cond @@ -415,40 +433,66 @@ let rec check cond = //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ ▼ -//│ ◉ (?g) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.4 then wrap z //│ │ ^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ - l.1 let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.4 then wrap z //│ │ ^^^^^^ -//│ │ - l.3 let test z cond = if cond -//│ │ ^^^^^^^ -//│ │ then wrap z ... -//│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for +//│ - l.3 let test z cond = if cond +//│ ^^^^^^^ +//│ then wrap z ... +//│ ^^^^^^^^^^^^^^^ +//│ ◉ (_ -> ?c) comes from +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^^ +//│ │ test (if cond then false else check (not cond)) cond +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (?check) is assumed for +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (bool -> ?b) comes from +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^ +//│ ◉ (?b) is assumed for +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^ +//│ ◉ (bool -> ?b) comes from +//│ ▲ - l.8 test (if cond then false else check (not cond)) cond +//│ │ ^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (?check) is assumed for +//│ ▲ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (_ -> ?c) comes from +//│ - l.7 let rec check cond = +//│ ^^^^^^ +//│ test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -456,39 +500,67 @@ let rec check cond = //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from +//│ ◉ (?f list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?e * ?a1 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^ -//│ ◉ (?e * ?a1 list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.1 let wrap x = x :: [] +//│ ◉ (?f) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?f list) comes from +//│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ +//│ │ - l.5 else wrap true +//│ │ ^^^^^^^^^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.3 let test z cond = if cond +//│ ^^^^^^^ +//│ then wrap z ... +//│ ^^^^^^^^^^^^^^^ +//│ ◉ (_ -> ?c) comes from +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^^ +//│ │ test (if cond then false else check (not cond)) cond +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (?check) is assumed for +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (bool -> ?b) comes from +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^ +//│ ◉ (?b) is assumed for +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^ +//│ ◉ (bool -> ?b) comes from +//│ ▲ - l.8 test (if cond then false else check (not cond)) cond +//│ │ ^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (?check) is assumed for +//│ ▲ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (_ -> ?c) comes from +//│ - l.7 let rec check cond = +//│ ^^^^^^ +//│ test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ │ - l.4 then wrap z +//│ │ ^^^^^^ //│ │ -//│ ◉ (?e * ?a1 list) comes from +//│ ◉ (?e list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ //│ ◉ (?e) is assumed for @@ -496,39 +568,33 @@ let rec check cond = //│ ^ //│ - l.1 let wrap x = x :: [] //│ ^ -//│ ◉ (?e * ?a1 list) comes from +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ +//│ │ - l.4 then wrap z +//│ │ ^^^^^^ +//│ │ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from +//│ ◉ (?c) is assumed for +//│ ▲ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ │ - l.5 else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?f list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0 * ?a0 list) comes from -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?e * ?a1 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a1 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^ -//│ ◉ (?a1) is assumed for -//│ ◉ (?a1 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^ -//│ ◉ (?e * ?a1 list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a0 * ?a0 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0 list) comes from -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from +//│ ◉ (?f) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?f list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.5 else wrap true @@ -538,7 +604,7 @@ let rec check cond = //│ │ then wrap z ... //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -546,18 +612,10 @@ let rec check cond = //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ │ -//│ ◉ (?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from +//│ ◉ (?e list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ ▲ - l.1 let wrap x = x :: [] //│ │ ^ //│ │ - l.4 then wrap z @@ -565,90 +623,108 @@ let rec check cond = //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ -//│ ◉ (?g) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ //│ ◉ (bool) comes from //│ - l.8 test (if cond then false else check (not cond)) cond //│ ^^^^^ -//│ [ERROR] Type `_ list` does not match `bool` +//│ [ERROR] Type `bool` does not match `_ list` //│ -//│ (?a0 list) ---> (?d) ~~~~ (?b) ---> (?e) ---> (?f) ---> (?c) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?a) ~~~~ (?c) <--- (?f) <--- (?e) <--- (bool) +//│ (bool) ---> (?d) ---> (?a) ---> (?e) ~~~~ (?f) ~~~~ (?e) ~~~~ (?f) ~~~~ (?e) ~~~~ (?f) ~~~~ (?e) <--- (?a) <--- (?d) <--- (?b) ~~~~ (?c) <--- (?f list) //│ -//│ ◉ (?a0 list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.5 else wrap true -//│ │ ^^^^^^^^^ -//│ ▼ -//│ ◉ (?d) is assumed for -//│ - l.3 let test z cond = if cond -//│ ^^^^^^^ -//│ then wrap z ... -//│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from -//│ │ - l.7 let rec check cond = -//│ │ ^^^^^^ -//│ │ test (if cond then false else check (not cond)) cond -//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ │ - l.7 let rec check cond = -//│ │ ^^^^^ -//│ ▼ -//│ ◉ (?check) is assumed for -//│ │ - l.7 let rec check cond = -//│ │ ^^^^^ -//│ ▼ -//│ ◉ (bool -> ?b) comes from -//│ - l.8 test (if cond then false else check (not cond)) cond -//│ ^^^^^ -//│ ◉ (?b) is assumed for +//│ ◉ (bool) comes from //│ │ - l.8 test (if cond then false else check (not cond)) cond -//│ │ ^^^^^^^^^^^^^^^^ +//│ │ ^^^^^ //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.4 then wrap z //│ │ ^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ - l.1 let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ +//│ │ - l.4 then wrap z +//│ │ ^^^^^^ +//│ │ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a * ?a list) comes from +//│ ◉ (?c) is assumed for +//│ ▲ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ │ - l.5 else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?f list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from +//│ ◉ (?f) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?f list) comes from +//│ │ - l.1 let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.5 else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ ▲ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ │ - l.4 then wrap z +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.1 let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ - l.3 let test z cond = if cond //│ ^^^^^^^ //│ then wrap z ... //│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ │ - l.7 let rec check cond = //│ │ ^^^^^^ //│ │ test (if cond then false else check (not cond)) cond @@ -676,12 +752,12 @@ let rec check cond = //│ ▲ - l.7 let rec check cond = //│ │ ^^^^^ //│ │ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ - l.7 let rec check cond = //│ ^^^^^^ //│ test (if cond then false else check (not cond)) cond //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -689,22 +765,26 @@ let rec check cond = //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from +//│ ◉ (?f list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from +//│ ◉ (?f) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?f list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ - l.3 let test z cond = if cond //│ ^^^^^^^ //│ then wrap z ... //│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ │ - l.7 let rec check cond = //│ │ ^^^^^^ //│ │ test (if cond then false else check (not cond)) cond @@ -732,12 +812,12 @@ let rec check cond = //│ ▲ - l.7 let rec check cond = //│ │ ^^^^^ //│ │ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ - l.7 let rec check cond = //│ ^^^^^^ //│ test (if cond then false else check (not cond)) cond //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -745,22 +825,26 @@ let rec check cond = //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ │ -//│ ◉ (?a list) comes from +//│ ◉ (?e list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from +//│ ◉ (?e) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ - l.3 let test z cond = if cond //│ ^^^^^^^ //│ then wrap z ... //│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ │ - l.7 let rec check cond = //│ │ ^^^^^^ //│ │ test (if cond then false else check (not cond)) cond @@ -781,41 +865,33 @@ let rec check cond = //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.4 then wrap z //│ │ ^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ - l.1 let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ - l.3 let test z cond = if cond //│ ^^^^^^^ //│ then wrap z ... //│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ │ - l.7 let rec check cond = //│ │ ^^^^^^ //│ │ test (if cond then false else check (not cond)) cond @@ -843,12 +919,12 @@ let rec check cond = //│ ▲ - l.7 let rec check cond = //│ │ ^^^^^ //│ │ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ - l.7 let rec check cond = //│ ^^^^^^ //│ test (if cond then false else check (not cond)) cond //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -856,21 +932,59 @@ let rec check cond = //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from +//│ ◉ (?f list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from +//│ ◉ (?f) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?f list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ -//│ │ - l.3 let test z cond = if cond -//│ │ ^^^^^^^ -//│ │ then wrap z ... -//│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for +//│ - l.3 let test z cond = if cond +//│ ^^^^^^^ +//│ then wrap z ... +//│ ^^^^^^^^^^^^^^^ +//│ ◉ (_ -> ?c) comes from +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^^ +//│ │ test (if cond then false else check (not cond)) cond +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (?check) is assumed for +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (bool -> ?b) comes from +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^ +//│ ◉ (?b) is assumed for +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^ +//│ ◉ (bool -> ?b) comes from +//│ ▲ - l.8 test (if cond then false else check (not cond)) cond +//│ │ ^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (?check) is assumed for +//│ ▲ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (_ -> ?c) comes from +//│ - l.7 let rec check cond = +//│ ^^^^^^ +//│ test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -878,18 +992,10 @@ let rec check cond = //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ │ -//│ ◉ (?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from +//│ ◉ (?e list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ ▲ - l.1 let wrap x = x :: [] //│ │ ^ //│ │ - l.4 then wrap z @@ -897,13 +1003,13 @@ let rec check cond = //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ @@ -920,34 +1026,72 @@ let rec check cond = //│ ▲ - l.7 let rec check cond = //│ │ ^^^^^ //│ │ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from +//│ - l.7 let rec check cond = +//│ ^^^^^^ +//│ test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ │ - l.5 else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?f list) comes from +//│ - l.1 let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?f) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?f list) comes from +//│ │ - l.1 let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.5 else wrap true +//│ │ ^^^^^^^^^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.3 let test z cond = if cond +//│ ^^^^^^^ +//│ then wrap z ... +//│ ^^^^^^^^^^^^^^^ +//│ ◉ (_ -> ?c) comes from +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^^ +//│ │ test (if cond then false else check (not cond)) cond +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (?check) is assumed for +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (bool -> ?b) comes from +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^ +//│ ◉ (?b) is assumed for +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^ +//│ ◉ (bool -> ?b) comes from +//│ ▲ - l.8 test (if cond then false else check (not cond)) cond +//│ │ ^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (?check) is assumed for +//│ ▲ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (_ -> ?c) comes from //│ - l.7 let rec check cond = //│ ^^^^^^ //│ test (if cond then false else check (not cond)) cond //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?d) is assumed for -//│ ▲ - l.3 let test z cond = if cond -//│ │ ^^^^^^^ -//│ │ then wrap z ... -//│ │ ^^^^^^^^^^^^^^^ -//│ │ - l.5 else wrap true -//│ │ ^^^^^^^^^ -//│ │ -//│ ◉ (?a0 list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ - l.5 else wrap true -//│ │ ^^^^^^^^^ -//│ │ - l.3 let test z cond = if cond -//│ │ ^^^^^^^ -//│ │ then wrap z ... -//│ │ ^^^^^^^^^^^^^^^ -//│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -955,18 +1099,10 @@ let rec check cond = //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ │ -//│ ◉ (?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from +//│ ◉ (?e list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ ▲ - l.1 let wrap x = x :: [] //│ │ ^ //│ │ - l.4 then wrap z @@ -974,35 +1110,61 @@ let rec check cond = //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (bool) comes from +//│ ◉ (?b) is assumed for //│ - l.8 test (if cond then false else check (not cond)) cond -//│ ^^^^^ +//│ ^^^^^^^^^^^^^^^^ +//│ ◉ (bool -> ?b) comes from +//│ ▲ - l.8 test (if cond then false else check (not cond)) cond +//│ │ ^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (?check) is assumed for +//│ ▲ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (_ -> ?c) comes from +//│ - l.7 let rec check cond = +//│ ^^^^^^ +//│ test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ │ - l.5 else wrap true +//│ │ ^^^^^^^^^ +//│ │ +//│ ◉ (?f list) comes from +//│ - l.1 let wrap x = x :: [] +//│ ^^^^^^^ //│ [ERROR] Type `_ list` does not match `bool` //│ -//│ (?a list) ---> (?d) ~~~~ (?b) ---> (?e) ---> (?f) ---> (?c) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?a) ~~~~ (?a0) ~~~~ (?a) ~~~~ (?c) <--- (?f) <--- (?e) <--- (bool) +//│ (?e list) ---> (?c) ~~~~ (?b) ---> (?d) ---> (?a) ---> (?e) ~~~~ (?f) ~~~~ (?e) ~~~~ (?f) ~~~~ (?e) ~~~~ (?f) ~~~~ (?e) <--- (?a) <--- (?d) <--- (bool) //│ -//│ ◉ (?a list) comes from +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ - l.3 let test z cond = if cond //│ ^^^^^^^ //│ then wrap z ... //│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ │ - l.7 let rec check cond = //│ │ ^^^^^^ //│ │ test (if cond then false else check (not cond)) cond @@ -1023,41 +1185,33 @@ let rec check cond = //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.4 then wrap z //│ │ ^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ - l.1 let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ - l.3 let test z cond = if cond //│ ^^^^^^^ //│ then wrap z ... //│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ │ - l.7 let rec check cond = //│ │ ^^^^^^ //│ │ test (if cond then false else check (not cond)) cond @@ -1085,12 +1239,12 @@ let rec check cond = //│ ▲ - l.7 let rec check cond = //│ │ ^^^^^ //│ │ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ - l.7 let rec check cond = //│ ^^^^^^ //│ test (if cond then false else check (not cond)) cond //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -1098,22 +1252,26 @@ let rec check cond = //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from +//│ ◉ (?f list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from +//│ ◉ (?f) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?f list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ - l.3 let test z cond = if cond //│ ^^^^^^^ //│ then wrap z ... //│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ │ - l.7 let rec check cond = //│ │ ^^^^^^ //│ │ test (if cond then false else check (not cond)) cond @@ -1141,12 +1299,12 @@ let rec check cond = //│ ▲ - l.7 let rec check cond = //│ │ ^^^^^ //│ │ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ - l.7 let rec check cond = //│ ^^^^^^ //│ test (if cond then false else check (not cond)) cond //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -1154,22 +1312,26 @@ let rec check cond = //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ │ -//│ ◉ (?a list) comes from +//│ ◉ (?e list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from +//│ ◉ (?e) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ - l.3 let test z cond = if cond //│ ^^^^^^^ //│ then wrap z ... //│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ │ - l.7 let rec check cond = //│ │ ^^^^^^ //│ │ test (if cond then false else check (not cond)) cond @@ -1190,41 +1352,33 @@ let rec check cond = //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ ▼ -//│ ◉ (?f) is assumed for +//│ ◉ (?a) is assumed for //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.4 then wrap z //│ │ ^ //│ ▼ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ - l.1 let wrap x = x :: [] //│ ^ -//│ ◉ (?c * _ list) comes from -//│ │ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ ▼ -//│ ◉ (?a * ?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a list) comes from +//│ ◉ (?e list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ - l.3 let test z cond = if cond //│ ^^^^^^^ //│ then wrap z ... //│ ^^^^^^^^^^^^^^^ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ │ - l.7 let rec check cond = //│ │ ^^^^^^ //│ │ test (if cond then false else check (not cond)) cond @@ -1252,12 +1406,12 @@ let rec check cond = //│ ▲ - l.7 let rec check cond = //│ │ ^^^^^ //│ │ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ - l.7 let rec check cond = //│ ^^^^^^ //│ test (if cond then false else check (not cond)) cond //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -1265,21 +1419,59 @@ let rec check cond = //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from +//│ ◉ (?f list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from +//│ ◉ (?f) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?f list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ -//│ │ - l.3 let test z cond = if cond -//│ │ ^^^^^^^ -//│ │ then wrap z ... -//│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for +//│ - l.3 let test z cond = if cond +//│ ^^^^^^^ +//│ then wrap z ... +//│ ^^^^^^^^^^^^^^^ +//│ ◉ (_ -> ?c) comes from +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^^ +//│ │ test (if cond then false else check (not cond)) cond +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (?check) is assumed for +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (bool -> ?b) comes from +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^ +//│ ◉ (?b) is assumed for +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^ +//│ ◉ (bool -> ?b) comes from +//│ ▲ - l.8 test (if cond then false else check (not cond)) cond +//│ │ ^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (?check) is assumed for +//│ ▲ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (_ -> ?c) comes from +//│ - l.7 let rec check cond = +//│ ^^^^^^ +//│ test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -1287,18 +1479,10 @@ let rec check cond = //│ │ - l.4 then wrap z //│ │ ^^^^^^ //│ │ -//│ ◉ (?a list) comes from -//│ - l.1 let wrap x = x :: [] -//│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.1 let wrap x = x :: [] -//│ │ ^^^^^^^ -//│ │ -//│ ◉ (?c * _ list) comes from +//│ ◉ (?e list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ ▲ - l.1 let wrap x = x :: [] //│ │ ^ //│ │ - l.4 then wrap z @@ -1306,13 +1490,13 @@ let rec check cond = //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ @@ -1329,12 +1513,12 @@ let rec check cond = //│ ▲ - l.7 let rec check cond = //│ │ ^^^^^ //│ │ -//│ ◉ (_ -> ?d) comes from +//│ ◉ (_ -> ?c) comes from //│ - l.7 let rec check cond = //│ ^^^^^^ //│ test (if cond then false else check (not cond)) cond //│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... @@ -1342,40 +1526,122 @@ let rec check cond = //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a0 list) comes from +//│ ◉ (?f list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a0) is assumed for -//│ ◉ (?a0 list) comes from +//│ ◉ (?f) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?f list) comes from //│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ //│ │ - l.5 else wrap true //│ │ ^^^^^^^^^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ - l.3 let test z cond = if cond +//│ ^^^^^^^ +//│ then wrap z ... +//│ ^^^^^^^^^^^^^^^ +//│ ◉ (_ -> ?c) comes from +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^^ +//│ │ test (if cond then false else check (not cond)) cond +//│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (?check) is assumed for +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ ▼ +//│ ◉ (bool -> ?b) comes from +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^ +//│ ◉ (?b) is assumed for +//│ - l.8 test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^ +//│ ◉ (bool -> ?b) comes from +//│ ▲ - l.8 test (if cond then false else check (not cond)) cond +//│ │ ^^^^^ +//│ │ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (?check) is assumed for +//│ ▲ - l.7 let rec check cond = +//│ │ ^^^^^ +//│ │ +//│ ◉ (_ -> ?c) comes from +//│ - l.7 let rec check cond = +//│ ^^^^^^ +//│ test (if cond then false else check (not cond)) cond +//│ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +//│ ◉ (?c) is assumed for +//│ ▲ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ │ - l.4 then wrap z +//│ │ ^^^^^^ +//│ │ +//│ ◉ (?e list) comes from +//│ - l.1 let wrap x = x :: [] +//│ ^^^^^^^ +//│ ◉ (?e) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?e list) comes from +//│ │ - l.1 let wrap x = x :: [] +//│ │ ^^^^^^^ +//│ │ - l.4 then wrap z +//│ │ ^^^^^^ //│ │ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... //│ │ ^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?d) is assumed for +//│ ◉ (?c) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^^^^^^^ //│ │ then wrap z ... //│ │ ^^^^^^^^^^^^^^^ -//│ │ - l.4 then wrap z -//│ │ ^^^^^^ +//│ │ - l.5 else wrap true +//│ │ ^^^^^^^^^ //│ │ -//│ ◉ (?a list) comes from +//│ ◉ (?f list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?a) is assumed for -//│ ◉ (?a * ?a list) comes from -//│ ▲ - l.1 let wrap x = x :: [] +//│ ◉ (?f) is assumed for +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ - l.1 let wrap x = x :: [] +//│ ^ +//│ ◉ (?f list) comes from +//│ │ - l.1 let wrap x = x :: [] //│ │ ^^^^^^^ +//│ │ - l.5 else wrap true +//│ │ ^^^^^^^^^ +//│ │ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ ▼ +//│ ◉ (?c) is assumed for +//│ ▲ - l.3 let test z cond = if cond +//│ │ ^^^^^^^ +//│ │ then wrap z ... +//│ │ ^^^^^^^^^^^^^^^ +//│ │ - l.4 then wrap z +//│ │ ^^^^^^ //│ │ -//│ ◉ (?c * _ list) comes from +//│ ◉ (?e list) comes from //│ - l.1 let wrap x = x :: [] //│ ^^^^^^^ -//│ ◉ (?c) is assumed for +//│ ◉ (?e) is assumed for //│ ▲ - l.1 let wrap x = x :: [] //│ │ ^ //│ │ - l.4 then wrap z @@ -1383,26 +1649,26 @@ let rec check cond = //│ │ - l.3 let test z cond = if cond //│ │ ^ //│ │ -//│ ◉ (?f) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.3 let test z cond = if cond //│ │ ^ //│ │ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (?e) is assumed for +//│ ◉ (?d) is assumed for //│ ▲ - l.8 test (if cond then false else check (not cond)) cond //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ //│ ◉ (bool) comes from //│ - l.8 test (if cond then false else check (not cond)) cond //│ ^^^^^ -//│ U max: 39, total: 167 +//│ U max: 25, total: 112 //│ UERR 6 errors -//│ L: 1 [list['a63'] ~ bool, list['a63'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], α69' <: α68', α68' <: α59', α59' <: α66', [α66' - ([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],) - 'a63', L: 0 [([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],), ([[α66']], [[list['a65']]],) <: ('a63', list['a63'],)]], ['a63' - ('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],) - α66', L: 0 [('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],), ('a63', list['a63'],) :> ([[α66']], [[list['a65']]],)]], α66' :> α59', α59' :> α68', α68' :> bool] -//│ L: 2 [list['a63'] ~ bool, list['a63'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], α69' <: α68', α68' <: α59', α59' <: α66', [α66' - ([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],) - 'a63', L: 0 [([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],), ([[α66']], [[list['a65']]],) <: ('a63', list['a63'],)]], ['a63' - list['a63'] ~ list['a61'] - 'a61', L: 0 [list['a63'] ~ list['a61'], list['a63'] <: α64', α64' :> list['a61']]], ['a61' - list['a61'] ~ list['a62'] - 'a62', L: 1 [list['a61'] ~ list['a62'], [list['a61'] - ('a61', list['a61'],) ~ ([[α60']], [[list['a62']]],) - list['a62'], L: 0 [('a61', list['a61'],) ~ ([[α60']], [[list['a62']]],), ('a61', list['a61'],) :> ([[α60']], [[list['a62']]],)]]]], ['a62' - list['a62'] ~ list['a61'] - 'a61', L: 1 [list['a62'] ~ list['a61'], [list['a62'] - ([[α60']], [[list['a62']]],) ~ ('a61', list['a61'],) - list['a61'], L: 0 [([[α60']], [[list['a62']]],) ~ ('a61', list['a61'],), ([[α60']], [[list['a62']]],) <: ('a61', list['a61'],)]]]], ['a61' - ('a61', list['a61'],) ~ ([[α60']], [[list['a62']]],) - α60', L: 0 [('a61', list['a61'],) ~ ([[α60']], [[list['a62']]],), ('a61', list['a61'],) :> ([[α60']], [[list['a62']]],)]], [α60' - ([[α60']], [[list['a62']]],) ~ ('a61', list['a61'],) - 'a61', L: 0 [([[α60']], [[list['a62']]],) ~ ('a61', list['a61'],), ([[α60']], [[list['a62']]],) <: ('a61', list['a61'],)]], ['a61' - list['a61'] ~ list['a62'] - 'a62', L: 1 [list['a61'] ~ list['a62'], [list['a61'] - ('a61', list['a61'],) ~ ([[α60']], [[list['a62']]],) - list['a62'], L: 0 [('a61', list['a61'],) ~ ([[α60']], [[list['a62']]],), ('a61', list['a61'],) :> ([[α60']], [[list['a62']]],)]]]], ['a62' - list['a62'] ~ list['a61'] - 'a61', L: 1 [list['a62'] ~ list['a61'], [list['a62'] - ([[α60']], [[list['a62']]],) ~ ('a61', list['a61'],) - list['a61'], L: 0 [([[α60']], [[list['a62']]],) ~ ('a61', list['a61'],), ([[α60']], [[list['a62']]],) <: ('a61', list['a61'],)]]]], ['a61' - list['a61'] ~ list['a63'] - 'a63', L: 0 [list['a61'] ~ list['a63'], list['a61'] <: α64', α64' :> list['a63']]], ['a63' - ('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],) - α66', L: 0 [('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],), ('a63', list['a63'],) :> ([[α66']], [[list['a65']]],)]], α66' :> α59', α59' :> α68', α68' :> bool] -//│ L: 2 [list['a61'] ~ bool, list['a61'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], α69' <: α68', α68' <: α59', α59' <: α66', [α66' - ([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],) - 'a63', L: 0 [([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],), ([[α66']], [[list['a65']]],) <: ('a63', list['a63'],)]], ['a63' - list['a63'] ~ list['a61'] - 'a61', L: 0 [list['a63'] ~ list['a61'], list['a63'] <: α64', α64' :> list['a61']]], ['a61' - list['a61'] ~ list['a62'] - 'a62', L: 1 [list['a61'] ~ list['a62'], [list['a61'] - ('a61', list['a61'],) ~ ([[α60']], [[list['a62']]],) - list['a62'], L: 0 [('a61', list['a61'],) ~ ([[α60']], [[list['a62']]],), ('a61', list['a61'],) :> ([[α60']], [[list['a62']]],)]]]], ['a62' - list['a62'] ~ list['a61'] - 'a61', L: 1 [list['a62'] ~ list['a61'], [list['a62'] - ([[α60']], [[list['a62']]],) ~ ('a61', list['a61'],) - list['a61'], L: 0 [([[α60']], [[list['a62']]],) ~ ('a61', list['a61'],), ([[α60']], [[list['a62']]],) <: ('a61', list['a61'],)]]]], ['a61' - ('a61', list['a61'],) ~ ([[α60']], [[list['a62']]],) - α60', L: 0 [('a61', list['a61'],) ~ ([[α60']], [[list['a62']]],), ('a61', list['a61'],) :> ([[α60']], [[list['a62']]],)]], [α60' - ([[α60']], [[list['a62']]],) ~ ('a61', list['a61'],) - 'a61', L: 0 [([[α60']], [[list['a62']]],) ~ ('a61', list['a61'],), ([[α60']], [[list['a62']]],) <: ('a61', list['a61'],)]], ['a61' - list['a61'] ~ list['a62'] - 'a62', L: 1 [list['a61'] ~ list['a62'], [list['a61'] - ('a61', list['a61'],) ~ ([[α60']], [[list['a62']]],) - list['a62'], L: 0 [('a61', list['a61'],) ~ ([[α60']], [[list['a62']]],), ('a61', list['a61'],) :> ([[α60']], [[list['a62']]],)]]]], ['a62' - list['a62'] ~ list['a61'] - 'a61', L: 1 [list['a62'] ~ list['a61'], [list['a62'] - ([[α60']], [[list['a62']]],) ~ ('a61', list['a61'],) - list['a61'], L: 0 [([[α60']], [[list['a62']]],) ~ ('a61', list['a61'],), ([[α60']], [[list['a62']]],) <: ('a61', list['a61'],)]]]], ['a61' - list['a61'] ~ list['a63'] - 'a63', L: 0 [list['a61'] ~ list['a63'], list['a61'] <: α64', α64' :> list['a63']]], ['a63' - ('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],) - α66', L: 0 [('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],), ('a63', list['a63'],) :> ([[α66']], [[list['a65']]],)]], α66' :> α59', α59' :> α68', α68' :> bool] -//│ L: 1 [list['a61'] ~ bool, list['a61'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], α69' <: α68', α68' <: α59', α59' <: α66', [α66' - ([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],) - 'a63', L: 0 [([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],), ([[α66']], [[list['a65']]],) <: ('a63', list['a63'],)]], ['a63' - ('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],) - α66', L: 0 [('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],), ('a63', list['a63'],) :> ([[α66']], [[list['a65']]],)]], α66' :> α59', α59' :> α68', α68' :> bool] -//│ L: 3 [list['a63'] ~ bool, list['a63'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], α69' <: α68', α68' <: α59', α59' <: α66', [α66' - ([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],) - 'a63', L: 0 [([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],), ([[α66']], [[list['a65']]],) <: ('a63', list['a63'],)]], ['a63' - list['a63'] ~ list['a61'] - 'a61', L: 1 [list['a63'] ~ list['a61'], list['a63'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], [α69' - ([bool] -> α69') ~ (α58' -> [α64']) - α64', L: 0 [([bool] -> α69') ~ (α58' -> [α64']), ([bool] -> α69') :> check57', check57' :> (α58' -> [α64'])]], α64' :> list['a61']]], ['a61' - list['a61'] ~ list['a63'] - 'a63', L: 1 [list['a61'] ~ list['a63'], list['a61'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], [α69' - ([bool] -> α69') ~ (α58' -> [α64']) - α64', L: 0 [([bool] -> α69') ~ (α58' -> [α64']), ([bool] -> α69') :> check57', check57' :> (α58' -> [α64'])]], α64' :> list['a63']]], ['a63' - list['a63'] ~ list['a61'] - 'a61', L: 2 [list['a63'] ~ list['a61'], list['a63'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], α69' <: α68', α68' <: α59', α59' <: α66', [α66' - ([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],) - 'a63', L: 0 [([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],), ([[α66']], [[list['a65']]],) <: ('a63', list['a63'],)]], ['a63' - list['a63'] ~ list['a61'] - 'a61', L: 1 [list['a63'] ~ list['a61'], list['a63'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], [α69' - ([bool] -> α69') ~ (α58' -> [α64']) - α64', L: 0 [([bool] -> α69') ~ (α58' -> [α64']), ([bool] -> α69') :> check57', check57' :> (α58' -> [α64'])]], α64' :> list['a61']]], ['a61' - list['a61'] ~ list['a63'] - 'a63', L: 0 [list['a61'] ~ list['a63'], list['a61'] <: α64', α64' :> list['a63']]], ['a63' - ('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],) - α66', L: 0 [('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],), ('a63', list['a63'],) :> ([[α66']], [[list['a65']]],)]], α66' :> α59', α59' :> α68', α68' :> α69', [α69' - ([bool] -> α69') ~ (α58' -> [α64']) - α64', L: 0 [([bool] -> α69') ~ (α58' -> [α64']), ([bool] -> α69') :> check57', check57' :> (α58' -> [α64'])]], α64' :> list['a61']]], ['a61' - list['a61'] ~ list['a63'] - 'a63', L: 0 [list['a61'] ~ list['a63'], list['a61'] <: α64', α64' :> list['a63']]], ['a63' - ('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],) - α66', L: 0 [('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],), ('a63', list['a63'],) :> ([[α66']], [[list['a65']]],)]], α66' :> α59', α59' :> α68', α68' :> bool] -//│ L: 3 [list['a61'] ~ bool, list['a61'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], α69' <: α68', α68' <: α59', α59' <: α66', [α66' - ([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],) - 'a63', L: 0 [([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],), ([[α66']], [[list['a65']]],) <: ('a63', list['a63'],)]], ['a63' - list['a63'] ~ list['a61'] - 'a61', L: 1 [list['a63'] ~ list['a61'], list['a63'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], [α69' - ([bool] -> α69') ~ (α58' -> [α64']) - α64', L: 0 [([bool] -> α69') ~ (α58' -> [α64']), ([bool] -> α69') :> check57', check57' :> (α58' -> [α64'])]], α64' :> list['a61']]], ['a61' - list['a61'] ~ list['a63'] - 'a63', L: 1 [list['a61'] ~ list['a63'], list['a61'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], [α69' - ([bool] -> α69') ~ (α58' -> [α64']) - α64', L: 0 [([bool] -> α69') ~ (α58' -> [α64']), ([bool] -> α69') :> check57', check57' :> (α58' -> [α64'])]], α64' :> list['a63']]], ['a63' - list['a63'] ~ list['a61'] - 'a61', L: 2 [list['a63'] ~ list['a61'], list['a63'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], α69' <: α68', α68' <: α59', α59' <: α66', [α66' - ([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],) - 'a63', L: 0 [([[α66']], [[list['a65']]],) ~ ('a63', list['a63'],), ([[α66']], [[list['a65']]],) <: ('a63', list['a63'],)]], ['a63' - list['a63'] ~ list['a61'] - 'a61', L: 1 [list['a63'] ~ list['a61'], list['a63'] <: α64', [α64' - (α58' -> [α64']) ~ ([bool] -> α69') - α69', L: 0 [(α58' -> [α64']) ~ ([bool] -> α69'), (α58' -> [α64']) <: check57', check57' <: ([bool] -> α69')]], [α69' - ([bool] -> α69') ~ (α58' -> [α64']) - α64', L: 0 [([bool] -> α69') ~ (α58' -> [α64']), ([bool] -> α69') :> check57', check57' :> (α58' -> [α64'])]], α64' :> list['a61']]], ['a61' - list['a61'] ~ list['a63'] - 'a63', L: 0 [list['a61'] ~ list['a63'], list['a61'] <: α64', α64' :> list['a63']]], ['a63' - ('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],) - α66', L: 0 [('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],), ('a63', list['a63'],) :> ([[α66']], [[list['a65']]],)]], α66' :> α59', α59' :> α68', α68' :> α69', [α69' - ([bool] -> α69') ~ (α58' -> [α64']) - α64', L: 0 [([bool] -> α69') ~ (α58' -> [α64']), ([bool] -> α69') :> check57', check57' :> (α58' -> [α64'])]], α64' :> list['a61']]], ['a61' - list['a61'] ~ list['a63'] - 'a63', L: 0 [list['a61'] ~ list['a63'], list['a61'] <: α64', α64' :> list['a63']]], ['a63' - ('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],) - α66', L: 0 [('a63', list['a63'],) ~ ([[α66']], [[list['a65']]],), ('a63', list['a63'],) :> ([[α66']], [[list['a65']]],)]], α66' :> α59', α59' :> α68', α68' :> bool] +//│ L: 3 [list[[α54']] ~ bool, list[[α54']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], α58' <: α57', α57' <: α52', α52' <: α54', [α54' - list[[α54']] ~ list[[α53']] - α53', L: 1 [list[[α54']] ~ list[[α53']], list[[α54']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α53']]]], [α53' - list[[α53']] ~ list[[α54']] - α54', L: 1 [list[[α53']] ~ list[[α54']], list[[α53']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α54']]]], [α54' - list[[α54']] ~ list[[α53']] - α53', L: 2 [list[[α54']] ~ list[[α53']], list[[α54']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], α58' <: α57', α57' <: α52', α52' <: α54', [α54' - list[[α54']] ~ list[[α53']] - α53', L: 1 [list[[α54']] ~ list[[α53']], list[[α54']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α53']]]], [α53' - list[[α53']] ~ list[[α54']] - α54', L: 1 [list[[α53']] ~ list[[α54']], list[[α53']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α54']]]], α54' :> α52', α52' :> α57', α57' :> α58', [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α53']]]], [α53' - list[[α53']] ~ list[[α54']] - α54', L: 1 [list[[α53']] ~ list[[α54']], list[[α53']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α54']]]], [α54' - list[[α54']] ~ list[[α53']] - α53', L: 0 [list[[α54']] ~ list[[α53']], list[[α54']] <: α55', α55' :> list[[α53']]]], [α53' - list[[α53']] ~ list[[α54']] - α54', L: 0 [list[[α53']] ~ list[[α54']], list[[α53']] <: α55', α55' :> list[[α54']]]], α54' :> α52', α52' :> α57', α57' :> bool] +//│ L: 1 [list[[α54']] ~ bool, list[[α54']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], α58' <: α57', α57' <: α52', α52' <: α54', [α54' - list[[α54']] ~ list[[α53']] - α53', L: 0 [list[[α54']] ~ list[[α53']], list[[α54']] <: α55', α55' :> list[[α53']]]], [α53' - list[[α53']] ~ list[[α54']] - α54', L: 0 [list[[α53']] ~ list[[α54']], list[[α53']] <: α55', α55' :> list[[α54']]]], α54' :> α52', α52' :> α57', α57' :> bool] +//│ L: 2 [list[[α53']] ~ bool, list[[α53']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], α58' <: α57', α57' <: α52', α52' <: α54', [α54' - list[[α54']] ~ list[[α53']] - α53', L: 1 [list[[α54']] ~ list[[α53']], list[[α54']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α53']]]], [α53' - list[[α53']] ~ list[[α54']] - α54', L: 0 [list[[α53']] ~ list[[α54']], list[[α53']] <: α55', α55' :> list[[α54']]]], α54' :> α52', α52' :> α57', α57' :> bool] +//│ L: 2 [list[[α54']] ~ bool, list[[α54']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], α58' <: α57', α57' <: α52', α52' <: α54', [α54' - list[[α54']] ~ list[[α53']] - α53', L: 1 [list[[α54']] ~ list[[α53']], list[[α54']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α53']]]], [α53' - list[[α53']] ~ list[[α54']] - α54', L: 1 [list[[α53']] ~ list[[α54']], list[[α53']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α54']]]], [α54' - list[[α54']] ~ list[[α53']] - α53', L: 0 [list[[α54']] ~ list[[α53']], list[[α54']] <: α55', α55' :> list[[α53']]]], [α53' - list[[α53']] ~ list[[α54']] - α54', L: 0 [list[[α53']] ~ list[[α54']], list[[α53']] <: α55', α55' :> list[[α54']]]], α54' :> α52', α52' :> α57', α57' :> bool] +//│ L: 3 [bool ~ list[[α53']], bool <: α57', α57' <: α52', α52' <: α54', [α54' - list[[α54']] ~ list[[α53']] - α53', L: 0 [list[[α54']] ~ list[[α53']], list[[α54']] <: α55', α55' :> list[[α53']]]], [α53' - list[[α53']] ~ list[[α54']] - α54', L: 0 [list[[α53']] ~ list[[α54']], list[[α53']] <: α55', α55' :> list[[α54']]]], [α54' - list[[α54']] ~ list[[α53']] - α53', L: 1 [list[[α54']] ~ list[[α53']], list[[α54']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α53']]]], [α53' - list[[α53']] ~ list[[α54']] - α54', L: 1 [list[[α53']] ~ list[[α54']], list[[α53']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α54']]]], [α54' - list[[α54']] ~ list[[α53']] - α53', L: 2 [list[[α54']] ~ list[[α53']], list[[α54']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], α58' <: α57', α57' <: α52', α52' <: α54', [α54' - list[[α54']] ~ list[[α53']] - α53', L: 1 [list[[α54']] ~ list[[α53']], list[[α54']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α53']]]], [α53' - list[[α53']] ~ list[[α54']] - α54', L: 1 [list[[α53']] ~ list[[α54']], list[[α53']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α54']]]], α54' :> α52', α52' :> α57', α57' :> α58', [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α53']]]], [α53' - list[[α53']] ~ list[[α54']] - α54', L: 1 [list[[α53']] ~ list[[α54']], list[[α53']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α54']]]], α54' :> α52', α52' :> α57', α57' :> α58', [α58' - ([bool] -> α58') ~ (α51' -> [α55']) - α55', L: 0 [([bool] -> α58') ~ (α51' -> [α55']), ([bool] -> α58') :> check50', check50' :> (α51' -> [α55'])]], α55' :> list[[α53']]] +//│ L: 1 [list[[α53']] ~ bool, list[[α53']] <: α55', [α55' - (α51' -> [α55']) ~ ([bool] -> α58') - α58', L: 0 [(α51' -> [α55']) ~ ([bool] -> α58'), (α51' -> [α55']) <: check50', check50' <: ([bool] -> α58')]], α58' <: α57', α57' <: α52', α52' <: α54', [α54' - list[[α54']] ~ list[[α53']] - α53', L: 0 [list[[α54']] ~ list[[α53']], list[[α54']] <: α55', α55' :> list[[α53']]]], [α53' - list[[α53']] ~ list[[α54']] - α54', L: 0 [list[[α53']] ~ list[[α54']], list[[α53']] <: α55', α55' :> list[[α54']]]], α54' :> α52', α52' :> α57', α57' :> bool] diff --git a/shared/src/test/diff/ocaml/SurveyMed2.mls b/shared/src/test/diff/ocaml/SurveyMed2.mls index bcac9b1..3720bd7 100644 --- a/shared/src/test/diff/ocaml/SurveyMed2.mls +++ b/shared/src/test/diff/ocaml/SurveyMed2.mls @@ -29,11 +29,11 @@ let rec mulByDigit i l = //│ ◉ (int) comes from //│ - lib. let ( * ): int -> int -> int //│ ^^^ -//│ [ERROR] Type `_ list` does not match `int` +//│ [ERROR] Type `int list` does not match `int` //│ -//│ (_ list) ---> (?a) ---> (int) +//│ (int list) ---> (?a) ---> (int) //│ -//│ ◉ (_ list) comes from +//│ ◉ (int list) comes from //│ │ - l.5 let y = [1; 2; 3] //│ │ ^^^^^^^^^ //│ │ - l.10 | h::t -> [remainder strings_of y] @ (mulByDigit i t) @@ -50,8 +50,8 @@ let rec mulByDigit i l = //│ ◉ (int) comes from //│ - lib. let ( * ): int -> int -> int //│ ^^^ -//│ U max: 7, total: 100 +//│ U max: 5, total: 58 //│ UERR 2 errors -//│ L: 0 [list['a69'] ~ int, list['a69'] <: α64', α64' <: int] -//│ L: 0 [(α66' -> [(list[α67'] -> list[α68'])]) ~ int, (α66' -> [(list[α67'] -> list[α68'])]) <: α63', α63' <: int] +//│ L: 0 [(α62' -> [(list[α63'] -> list[α64'])]) ~ int, (α62' -> [(list[α63'] -> list[α64'])]) <: α59', α59' <: int] +//│ L: 0 [list[[int]] ~ int, list[[int]] <: α60', α60' <: int] diff --git a/shared/src/test/diff/ocaml/SurveyMed3.mls b/shared/src/test/diff/ocaml/SurveyMed3.mls index dd7a9e3..d2b6b2b 100644 --- a/shared/src/test/diff/ocaml/SurveyMed3.mls +++ b/shared/src/test/diff/ocaml/SurveyMed3.mls @@ -15,7 +15,7 @@ let rec additivePersistence n = (* (@): 'a list -> 'a list -> 'a list is a list concatenation operator *) //│ [ERROR] Type `bool` does not match `int` //│ -//│ (bool) ---> (?a) ---> (?b) <--- (int) +//│ (bool) ---> (?b) ---> (?a) <--- (int) //│ //│ ◉ (bool) comes from //│ │ - l.13 | h::t -> if (addNumbs (h :: t)) >= 10 then false else true @@ -23,7 +23,7 @@ let rec additivePersistence n = //│ │ - l.13 | h::t -> if (addNumbs (h :: t)) >= 10 then false else true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?a) is assumed for +//│ ◉ (?b) is assumed for //│ │ - l.13 | h::t -> if (addNumbs (h :: t)) >= 10 then false else true //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ - l.11 match digits n with @@ -31,7 +31,7 @@ let rec additivePersistence n = //│ │ | [] -> 0 ... //│ │ ^^^^^^^^^^^^^ //│ ▼ -//│ ◉ (?b) is assumed for +//│ ◉ (?a) is assumed for //│ ▲ - l.11 match digits n with //│ │ ^^^^^^^^^^^^^^^^^^^ //│ │ | [] -> 0 ... @@ -40,6 +40,6 @@ let rec additivePersistence n = //│ ◉ (int) comes from //│ - l.12 | [] -> 0 //│ ^ -//│ U max: 6, total: 137 +//│ U max: 5, total: 115 //│ UERR 1 errors -//│ L: 0 [bool ~ int, bool <: α96', α96' <: α86', α86' :> int] +//│ L: 0 [bool ~ int, bool <: α90', α90' <: α80', α80' :> int] diff --git a/shared/src/test/diff/ocaml/TupleLists.mls b/shared/src/test/diff/ocaml/TupleLists.mls index f14e8ef..fedefdf 100644 --- a/shared/src/test/diff/ocaml/TupleLists.mls +++ b/shared/src/test/diff/ocaml/TupleLists.mls @@ -1,11 +1,11 @@ let f = if true then [0, 1] else [0], [1] -//│ [ERROR] Type `_ list * _ list` does not match `_ list` +//│ [ERROR] Type `int list * int list` does not match `(int * int) list` //│ -//│ (_ list * _ list) ---> (?a) <--- (_ list) +//│ (int list * int list) ---> (?a) <--- ((int * int) list) //│ -//│ ◉ (_ list * _ list) comes from +//│ ◉ (int list * int list) comes from //│ │ - l.1 let f = if true then [0, 1] else [0], [1] //│ │ ^^^^^^^^ //│ │ - l.1 let f = if true then [0, 1] else [0], [1] @@ -15,22 +15,22 @@ let f = if true then [0, 1] else [0], [1] //│ ▲ - l.1 let f = if true then [0, 1] else [0], [1] //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (_ list) comes from +//│ ◉ ((int * int) list) comes from //│ - l.1 let f = if true then [0, 1] else [0], [1] //│ ^^^^^^ //│ f: 'a //│ where //│ 'a = (list[int], list[int],), list[(int, int,)] -//│ U max: 2, total: 16 +//│ U max: 1, total: 4 //│ UERR 1 errors -//│ L: 0 [([[list['a45']]], [[list['a47']]],) ~ list['a43'], ([[list['a45']]], [[list['a47']]],) <: α42', α42' :> list['a43']] +//│ L: 0 [([list[[int]]], [list[[int]]],) ~ list[([[int]], [[int]],)], ([list[[int]]], [list[[int]]],) <: α42', α42' :> list[([[int]], [[int]],)]] let f x = if true then [0, 1] else x, [1] -//│ [ERROR] Type `_ * _ list` does not match `_ list` +//│ [ERROR] Type `_ * int list` does not match `(int * int) list` //│ -//│ (_ * _ list) ---> (?a) <--- (_ list) +//│ (_ * int list) ---> (?a) <--- ((int * int) list) //│ -//│ ◉ (_ * _ list) comes from +//│ ◉ (_ * int list) comes from //│ │ - l.1 let f x = if true then [0, 1] else x, [1] //│ │ ^^^^^^ //│ │ - l.1 let f x = if true then [0, 1] else x, [1] @@ -40,25 +40,25 @@ let f x = if true then [0, 1] else x, [1] //│ ▲ - l.1 let f x = if true then [0, 1] else x, [1] //│ │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //│ │ -//│ ◉ (_ list) comes from +//│ ◉ ((int * int) list) comes from //│ - l.1 let f x = if true then [0, 1] else x, [1] //│ ^^^^^^ //│ f: 'a -> 'b //│ where //│ 'b = ('a, list[int],), list[(int, int,)] -//│ U max: 2, total: 12 +//│ U max: 1, total: 4 //│ UERR 1 errors -//│ L: 0 [([[α52']], [[list['a56']]],) ~ list['a54'], ([[α52']], [[list['a56']]],) <: α53', α53' :> list['a54']] +//│ L: 0 [([[α43']], [list[[int]]],) ~ list[([[int]], [[int]],)], ([[α43']], [list[[int]]],) <: α44', α44' :> list[([[int]], [[int]],)]] let test: (int * int) list //│ test: list[(int, int,)] let f x = if true then test else x, [1] -//│ [ERROR] Type `_ * _ list` does not match `(int * int) list` +//│ [ERROR] Type `_ * int list` does not match `(int * int) list` //│ -//│ (_ * _ list) ---> (?a) <--- ((int * int) list) +//│ (_ * int list) ---> (?a) <--- ((int * int) list) //│ -//│ ◉ (_ * _ list) comes from +//│ ◉ (_ * int list) comes from //│ │ - l.1 let f x = if true then test else x, [1] //│ │ ^^^^^^ //│ │ - l.1 let f x = if true then test else x, [1] @@ -76,7 +76,7 @@ let f x = if true then test else x, [1] //│ f: 'a -> 'b //│ where //│ 'b = ('a, list[int],), list[(int, int,)] -//│ U max: 2, total: 8 +//│ U max: 1, total: 4 //│ UERR 1 errors -//│ L: 0 [([[α60']], [[list['a62']]],) ~ list[([int], [int],)], ([[α60']], [[list['a62']]],) <: α61', α61' :> list[([int], [int],)]] +//│ L: 0 [([[α45']], [list[[int]]],) ~ list[([int], [int],)], ([[α45']], [list[[int]]],) <: α46', α46' :> list[([int], [int],)]]