1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
main :: forall a . (Eq a, Num (MatVecScalarElem a), Eq a, Num a) => Bool
main
= \b c d e f -> (b == c) (g (fromInt b f 3) (fromInt b f 1)) (fromInt b f 5)
------------ desugared source code
f
= _lhs
f
\(a :: _) -> case'List
(\(_ :: _) -> _)
(_rhs undefined)
(\(b :: _) (_ :: _) -> _rhs (b : a))
a
g
= _lhs
g
\(a :: _) (b :: _) -> case'Bool
(\(_ :: _) -> _)
(_rhs undefined)
(_rhs (a + b))
(fromInt 3 == b)
main :: Bool
main = _lhs main (_rhs (g (fromInt 3) (fromInt 1) == fromInt 5))
------------ core code
f :: forall a . [a] -> [a]
f
= \a b -> case'List (\_ -> [a]) (_rhs (undefined [a])) (\c _ -> _rhs (c : b)) b
g :: forall a . (Num (MatVecScalarElem a), Eq a, Num a) => a -> a -> a
g
= \a b c d e f -> case'Bool
(\_ -> a)
(_rhs (undefined a))
(_rhs (PrimAdd a b e f))
((a == c) (fromInt a d 3) f)
main :: forall a . (Eq a, Num (MatVecScalarElem a), Eq a, Num a) => Bool
main
= \a b c d e -> _rhs
((a == b) (g (fromInt a e 3) (fromInt a e 1)) (fromInt a e 5))
------------ tooltips
1:1-1:2
forall a . [a] -> [a]
1:14-1:15
_e
1:14-1:16
[_d] -> [_d]
1:14-1:17
[_c]
1:15-1:16
forall a . a -> [a] -> [a]
1:16-1:17
_e
3:1-3:2
forall a . (Num (MatVecScalarElem a), Eq a, Num a) => a -> a -> a
3:11-3:12
_g
3:11-3:14
_f -> _f
3:11-3:16
_d
3:13-3:14
forall a . Num (MatVecScalarElem a) => a -> a -> a
3:15-3:16
_c
7:9-7:13
Type
8:1-8:5
forall a . (Eq a, Num (MatVecScalarElem a), Eq a, Num a) => Bool
8:8-8:9
forall a . (Num (MatVecScalarElem a), Eq a, Num a) => a -> a -> a
8:8-8:11
_e -> _e
8:8-8:13
_f
8:8-8:16
_e -> Bool
8:8-8:18
Bool
8:10-8:11
_b
8:12-8:13
_b
8:14-8:16
forall a . Eq a => a -> a -> Bool
8:17-8:18
_b
------------ warnings
Uncovered pattern(s) at testdata/language-features/as-pattern/as-pattern01.lc:1:1:
f y@(x:xs) = x:y
^
Missing case(s):
f _ | [] <- _a
Uncovered pattern(s) at testdata/language-features/as-pattern/as-pattern01.lc:3:1:
g x@3 y = x + y
^
Missing case(s):
g _ _ | False <- fromInt 3 == _a
|
