{-

types:

List_FNat_J :: (*, data)

Nat :: (*, data)

values:

a___2_L_E_2 :: (Nat, Nat) -> Bool

insert :: (Nat, List_FNat_J) -> List_FNat_J

insert_1sort :: List_FNat_J -> List_FNat_J

is_1ordered :: List_FNat_J -> Bool

permutation :: (List_FNat_J, List_FNat_J) -> Bool

prec :: Nat -> Nat

sorter :: List_FNat_J -> List_FNat_J

A__0 :: Nat

Cons :: (Nat, List_FNat_J) -> List_FNat_J

Nil :: List_FNat_J

Succ :: Nat -> Nat

scope:

Prelude.A__0 |-> Prelude.A__0, con of Nat

Prelude.Cons |-> Prelude.Cons, con of List_FNat_J

Prelude.List_FNat_J |-> Prelude.List_FNat_J, Type [Cons,

Nil] []

Prelude.Nat |-> Prelude.Nat, Type [A__0, Succ] []

Prelude.Nil |-> Prelude.Nil, con of List_FNat_J

Prelude.Succ |-> Prelude.Succ, con of Nat

Prelude.a___2_L_E_2 |-> Prelude.a___2_L_E_2, Value

Prelude.insert |-> Prelude.insert, Value

Prelude.insert_1sort |-> Prelude.insert_1sort, Value

Prelude.is_1ordered |-> Prelude.is_1ordered, Value

Prelude.permutation |-> Prelude.permutation, Value

Prelude.prec |-> Prelude.prec, Value

Prelude.sorter |-> Prelude.sorter, Value

A__0 |-> Prelude.A__0, con of Nat

Cons |-> Prelude.Cons, con of List_FNat_J

List_FNat_J |-> Prelude.List_FNat_J, Type [Cons,

Nil] []

Nat |-> Prelude.Nat, Type [A__0, Succ] []

Nil |-> Prelude.Nil, con of List_FNat_J

Succ |-> Prelude.Succ, con of Nat

a___2_L_E_2 |-> Prelude.a___2_L_E_2, Value

insert |-> Prelude.insert, Value

insert_1sort |-> Prelude.insert_1sort, Value

is_1ordered |-> Prelude.is_1ordered, Value

permutation |-> Prelude.permutation, Value

prec |-> Prelude.prec, Value

sorter |-> Prelude.sorter, Value

-}

module Dummy where

a___2_L_E_2 :: (Nat, Nat) -> Bool

insert :: (Nat, List_FNat_J) -> List_FNat_J

insert_1sort :: List_FNat_J -> List_FNat_J

is_1ordered :: List_FNat_J -> Bool

permutation :: (List_FNat_J, List_FNat_J) -> Bool

permutation

= error -- ((List_FNat_J, List_FNat_J) -> Bool)

"permutation"

prec :: Nat -> Nat

sorter :: List_FNat_J -> List_FNat_J

sorter

= error {- (List_FNat_J -> List_FNat_J) -} "sorter"

prec (Succ x_11) = x_11

data Nat = A__0 | Succ !Nat

a___2_L_E_2 (A__0, x) = True

a___2_L_E_2 ((Succ x), A__0) = False

a___2_L_E_2 ((Succ x), (Succ y)) = a___2_L_E_2 (x, y)

a___2_L_E_2 (x, y)

= (\ (a, b, c) -> if b then a else c)

(True,

error -- (((,) Nat Nat) -> Bool)

"equality at Sorting.hascasl:14,7"

(x, y),

error {- Bool -} "bottom at __unknown__:0,0")

data List_FNat_J = Cons !(Nat, List_FNat_J) | Nil

is_1ordered Nil = True

is_1ordered (Cons (x, Nil)) = True

is_1ordered (Cons (x, (Cons (y, a__L))))

= uncurry {- Bool Bool Bool -} (&&)

(a___2_L_E_2 (x, y), is_1ordered (Cons (y, a__L)))

insert (x, Nil) = Cons (x, Nil)

insert (x, (Cons (y, a__L)))

= (\ (a, b, c) -> if b then a else c)

(Cons (x, insert (y, a__L)), a___2_L_E_2 (x, y),

Cons (y, insert (x, a__L)))

insert_1sort Nil = Nil

insert_1sort (Cons (x, a__L))

= insert (x, insert_1sort a__L)