primes.out

main :: Int
main = 17393
------------ desugared source code
infixr 0 $

($) = _lhs ($) \(a :: _) (b :: _) -> _rhs (a b)

id = _lhs id \(a :: _) -> _rhs a

foldr
  = primFix
    \(a :: _) -> _lhs
      foldr
      \(b :: _) (c :: _) (d :: _) -> case'List
        (\(_ :: _) -> _)
        (_rhs c)
        (\(e :: _) (f :: _) -> _rhs (b e $ a b c f))
        d

filter
  = _lhs
    filter
    \(a :: _) -> _rhs
      (foldr (\(b :: _) (c :: _) -> primIfThenElse (a b) (b : c) c) [])

(&&)
  = _lhs
    (&&)
    \(a :: _) (b :: _) -> case'Bool (\(_ :: _) -> _) (_rhs False) (_rhs b) a

and = _lhs and (_rhs (foldr (&&) True))

map = _lhs map \(a :: _) -> _rhs (foldr (\(b :: _) (c :: _) -> a b : c) [])

mod = _lhs mod (_rhs primModInt)

iSqrt
  = _lhs iSqrt \(a :: _) -> _rhs (primRound (primSqrtFloat (primIntToFloat a)))

(+) = _lhs (+) (_rhs primAddInt)

(-) = _lhs (-) (_rhs primSubInt)

(<=)
  = _lhs
    (<=)
    \(a :: _) (b :: _) -> _rhs
      ((\(c :: _) -> case'Ordering (\(_ :: _) -> _) True True False c)
        (primCompareInt a b))

not
  = _lhs not \(a :: _) -> case'Bool (\(_ :: _) -> _) (_rhs True) (_rhs False) a

(/=) = _lhs (/=) \(a :: _) (b :: _) -> _rhs (not $ a == b)

takeWhile
  = primFix
    \(a :: _) -> _lhs
      takeWhile
      \(b :: _) (c :: _) -> case'List
        (\(_ :: _) -> _)
        (_rhs [])
        (\(d :: _) (e :: _) -> case'Bool
          (\(_ :: _) -> _)
          (_rhs [])
          (_rhs (d : a b e))
          (b d))
        c

from = primFix \(a :: _) -> _lhs from \(b :: _) -> _rhs (b : a (b + fromInt 1))

primes :: [Int]
primes
  = primFix
    \(a :: _) -> _lhs
      primes
      (_rhs
        (fromInt 2
          : fromInt 3
            : filter
              (\(b :: _) -> and
                $ map
                  (\(c :: _) -> b `mod` c /= fromInt 0)
                  (takeWhile (\(d :: _) -> d <= iSqrt b) a))
              (from (fromInt 5))))

(!!)
  = primFix
    \(a :: _) -> _lhs
      (!!)
      \(b :: _) (c :: _) -> case'List
        (\(_ :: _) -> _)
        (_rhs undefined)
        (\(d :: _) (e :: _) -> case'Bool
          (\(_ :: _) -> _)
          (_rhs (a e (c - fromInt 1)))
          (_rhs d)
          (fromInt 0 == c))
        b

main = _lhs main (_rhs (primes !! fromInt 2000))
------------ core code
!! :: forall a . [a] -> Int -> a
!!
  = \a -> primFix
    _
    \b c d -> case'List
      (\_ -> a)
      (_rhs (undefined a))
      (\e f -> case'Bool
        (\_ -> a)
        (_rhs (b f (primSubInt d 1)))
        (_rhs e)
        (isEQ (primCompareInt 0 d)))
      c

$ :: forall a b . (a -> b) -> a -> b
$ = \a b c d -> _rhs (c d)

&& :: Bool -> Bool -> Bool
&& = \a b -> case'Bool (\_ -> 'Bool) (_rhs False) (_rhs b) a

+ :: Int -> Int -> Int
+ = _rhs \a b -> primAddInt a b

- :: Int -> Int -> Int
- = _rhs \a b -> primSubInt a b

/= :: forall a . Eq a => a -> a -> Bool
/= = \a b c d -> _rhs (not ((a == b) c d))

<= :: Int -> Int -> Bool
<=
  = \a b -> _rhs
    (case'Ordering (\_ -> 'Bool) True True False (primCompareInt a b))

and :: [Bool] -> Bool
and = _rhs (foldr (&&) True)

filter :: forall a . (a -> Bool) -> [a] -> [a]
filter = \a b -> _rhs (foldr (\c d -> primIfThenElse [a] (b c) (c : d) d) [])

foldr :: forall a b . (b -> a -> a) -> a -> [b] -> a
foldr
  = \a b -> primFix
    _
    \c d e f -> case'List (\_ -> a) (_rhs e) (\g h -> _rhs (d g (c d e h))) f

from :: Int -> [Int]
from = primFix _ \a b -> _rhs (b : a (primAddInt b 1))

iSqrt :: Int -> Int
iSqrt = \a -> _rhs (primRound (primSqrtFloat (primIntToFloat a)))

id :: forall a . a -> a
id = \a b -> _rhs b

main :: Int
main = _rhs 17393

map :: forall a b . (a -> b) -> [a] -> [b]
map = \a b c -> _rhs (foldr (\d e -> c d : e) [])

mod :: Int -> Int -> Int
mod = _rhs \a b -> primModInt a b

not :: Bool -> Bool
not = \a -> case'Bool (\_ -> 'Bool) (_rhs True) (_rhs False) a

primes :: [Int]
primes
  = primFix
    _
    \a -> _rhs
      (2
        : 3
          : foldr
            (\b c -> primIfThenElse
              ['Int]
              (and
                $ foldr (\d e -> primModInt b d /= 0 : e) [] (takeWhile (\f -> f <= iSqrt b) a))
              (b : c)
              c)
            []
            (from 5))

takeWhile :: forall a . (a -> Bool) -> [a] -> [a]
takeWhile
  = \a -> primFix
    _
    \b c d -> case'List
      (\_ -> [a])
      (_rhs [])
      (\e f -> case'Bool (\_ -> [a]) (_rhs []) (_rhs (e : b c f)) (c e))
      d
------------ tooltips
7:3-7:4
    forall a b . (a -> b) -> a -> b
7:9-7:10
    _d
7:11-7:12
    _e
9:1-9:3
    forall a . a -> a
9:8-9:9
    _b
11:1-11:6
    forall a b . (b -> a -> a) -> a -> [b] -> a
11:16-11:17
    _f
11:16-12:39
    [_b] -> _f
12:21-12:22
    _k
12:21-12:26
    _b -> _a
12:21-12:39
    _h
12:23-12:24
    _h
12:25-12:26
    forall a b . (a -> b) -> a -> b
12:27-12:32
    _k
12:33-12:34
    _g -> _d -> _k
12:35-12:36
    _l
12:37-12:39
    [_h]
19:1-19:7
    forall a . (a -> Bool) -> [a] -> [a]
19:12-19:17
    forall a b . (b -> a -> a) -> a -> [b] -> a
19:12-19:54
    [_a] -> [_a] -> [_a]
19:12-19:57
    [_a] -> [_a]
19:28-19:53
    [_c]
19:31-19:32
    _g
19:31-19:45
    [_c] -> [_c]
19:33-19:34
    _g
19:40-19:41
    _e
19:40-19:42
    [_d] -> [_d]
19:40-19:45
    [_c]
19:41-19:42
    forall a . a -> [a] -> [a]
19:43-19:45
    _d
19:51-19:53
    [_c]
19:55-19:57
    forall a . [a]
21:6-21:8
    Bool -> Bool -> Bool
21:13-21:14
    _b
21:13-22:19
    Bool -> Bool
22:14-22:19
    Bool
24:1-24:4
    [Bool] -> Bool
24:7-24:12
    forall a b . (b -> a -> a) -> a -> [b] -> a
24:7-24:17
    Bool -> [Bool] -> Bool
24:7-24:22
    [Bool] -> Bool
24:13-24:17
    Bool -> Bool -> Bool
24:18-24:22
    Bool
26:1-26:4
    forall a b . (a -> b) -> [a] -> [b]
26:9-26:14
    forall a b . (b -> a -> a) -> a -> [b] -> a
26:9-26:33
    [_a] -> [_b] -> [_a]
26:9-26:36
    [_b] -> [_a]
26:25-26:26
    _g
26:25-26:29
    [_a] -> [_a]
26:25-26:32
    [_a]
26:27-26:28
    _g
26:28-26:29
    forall a . a -> [a] -> [a]
26:30-26:32
    [_a]
26:34-26:36
    forall a . [a]
28:1-28:4
    Int -> Int -> Int
28:7-28:17
    Int -> Int -> Int
29:1-29:6
    Int -> Int
29:11-29:20
    Float -> Int
29:11-29:55
    Int
29:22-29:35
    Float -> Float
29:22-29:54
    Float
29:37-29:51
    Int -> Float
29:37-29:53
    Float
29:52-29:53
    _b
30:2-30:3
    Int -> Int -> Int
30:7-30:17
    Int -> Int -> Int
31:2-31:3
    Int -> Int -> Int
31:7-31:17
    Int -> Int -> Int
33:3-33:5
    Int -> Int -> Bool
33:10-35:14
    Bool
33:15-33:29
    Int -> Int -> Ordering
33:15-33:31
    Int -> Ordering
33:15-33:33
    Ordering
33:30-33:31
    _d
33:32-33:33
    _b
34:11-34:16
    Bool
34:11-35:14
    Ordering -> Bool
35:10-35:14
    Bool | Bool
37:1-37:4
    Bool -> Bool
37:13-37:17
    Bool
37:13-38:17
    Bool -> Bool
38:12-38:17
    Bool
40:3-40:5
    forall a . Eq a => a -> a -> Bool
40:10-40:13
    Bool -> Bool
40:10-40:15
    Bool -> Bool
40:10-40:22
    Bool
40:14-40:15
    forall a b . (a -> b) -> a -> b
40:16-40:17
    _f
40:16-40:20
    _e -> Bool
40:16-40:22
    Bool
40:18-40:20
    forall a . Eq a => a -> a -> Bool
40:21-40:22
    _c
42:1-42:10
    forall a . (a -> Bool) -> [a] -> [a]
42:23-42:24
    _g
42:23-43:19
    [_c]
42:25-42:26
    _f
42:29-42:30
    _f
42:29-42:31
    [_e] -> [_e]
42:29-42:46
    [_d]
42:29-43:19
    Bool -> [_d]
42:30-42:31
    forall a . a -> [a] -> [a]
42:32-42:41
    _j
42:42-42:43
    _k
42:44-42:46
    [_h]
43:17-43:19
    forall a . [a] | forall a . [a]
45:1-45:5
    Int -> [Int]
45:10-45:11
    _c
45:10-45:12
    [_b] -> [_b]
45:10-45:25
    [Int]
45:11-45:12
    forall a . a -> [a] -> [a]
45:13-45:17
    _d
45:19-45:20
    _e
45:19-45:22
    Int -> Int
45:19-45:24
    Int
45:21-45:22
    Int -> Int -> Int
45:23-45:24
    _b
47:11-47:16
    Type
47:12-47:15
    Type
48:1-48:7
    [Int]
48:10-48:11
    _b
48:10-48:12
    [_b] -> [_b]
48:10-48:111
    [Int]
48:11-48:12
    forall a . a -> [a] -> [a]
48:12-48:13
    _b
48:12-48:14
    [_b] -> [_b]
48:12-48:111
    [Int]
48:13-48:14
    forall a . a -> [a] -> [a]
48:15-48:21
    forall a . (a -> Bool) -> [a] -> [a]
48:15-48:102
    [Int] -> [Int]
48:15-48:111
    [Int]
48:29-48:32
    [Bool] -> Bool
48:29-48:34
    [Bool] -> Bool
48:29-48:101
    Bool
48:33-48:34
    forall a b . (a -> b) -> a -> b
48:35-48:38
    forall a b . (a -> b) -> [a] -> [b]
48:35-48:61
    [Int] -> [Bool]
48:35-48:101
    [Bool]
48:46-48:47
    _g
48:46-48:53
    Int -> Int
48:46-48:55
    Int
48:46-48:58
    Int -> Bool
48:46-48:60
    Bool
48:48-48:53
    Int -> Int -> Int
48:54-48:55
    _d
48:56-48:58
    forall a . Eq a => a -> a -> Bool
48:59-48:60
    _b
48:63-48:72
    forall a . (a -> Bool) -> [a] -> [a]
48:63-48:93
    [Int] -> [Int]
48:63-48:100
    [Int]
48:80-48:81
    _b
48:80-48:84
    Int -> Bool
48:80-48:92
    Bool
48:82-48:84
    Int -> Int -> Bool
48:85-48:90
    Int -> Int
48:85-48:92
    Int
48:91-48:92
    Int
48:94-48:100
    [Int]
48:104-48:108
    Int -> [Int]
48:104-48:110
    [Int]
48:109-48:110
    _b
50:8-50:10
    forall a . [a] -> Int -> a
50:15-50:16
    _e
50:15-51:28
    Bool -> _d | _c
51:17-51:19
    [_h]
51:20-51:22
    _k
51:24-51:25
    _k
51:24-51:26
    Int -> Int
51:24-51:27
    Int
51:25-51:26
    Int -> Int -> Int
51:26-51:27
    _b
53:1-53:5
    Int
53:8-53:14
    [Int]
53:8-53:17
    Int -> Int
53:8-53:22
    Int
53:15-53:17
    forall a . [a] -> Int -> a
53:18-53:22
    _b
------------ warnings
Uncovered pattern(s) at testdata/primes.lc:50:8:
(x: _) !! 0 = x
(_ : xs) !! n = xs !! (n-1)
Missing case(s):
    [] !! _