Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
b0f64c9acThis file is pinned to the selected release. Download the original to open it in your design tool.
{
min m n = case ((<=) m n) of { True -> m ; False -> n ; } ;
max m n = case ((<=) m n) of { True -> n ; False -> m ; } ;
gt m n = case ((<=) m n) of { True -> False ; False -> True ; } ;
head (Cons x xs) = x ;
last (Cons x xs) = case null xs of {
True -> x ;
False -> last xs ;
} ;
null Nil = True ;
null (Cons x xs) = False ;
length xs = lengthAcc 0 xs;
lengthAcc acc Nil = acc;
lengthAcc acc (Cons x xs) = lengthAcc ((+) acc 1) xs;
append Nil ys = ys ;
append (Cons x xs) ys = Cons x (append xs ys) ;
map f Nil = Nil ;
map f (Cons x xs) = Cons (f x) (map f xs) ;
concatMap f Nil = Nil ;
concatMap f (Cons x xs) = append (f x) (concatMap f xs) ;
elem x Nil = False ;
elem x (Cons y ys) =
case (==) x y of { True -> True ; False -> elem x ys ; } ;
foldr f z Nil = z ;
foldr f z (Cons x xs) = f x (foldr f z xs) ;
filter p Nil = Nil ;
filter p (Cons x xs) =
case p x of { True -> Cons x (filter p xs) ; False -> filter p xs ; } ;
enumFromTo m n =
case (<=) m n of { True -> Cons m (enumFromTo ((+) m 1) n) ; False -> Nil ; } ;
assoc x (Cons (Pair y z) yzs) =
case (==) x y of { True -> z ; False -> assoc x yzs ; } ;
assocm x Nil = Nothing ;
assocm x (Cons (Pair y z) yzs) =
case (==) x y of { True -> Just z ; False -> assocm x yzs ; } ;
subset Nil ys = True ;
subset (Cons x xs) ys =
case elem x ys of { True -> subset xs ys ; False -> False ; } ;
union xs ys = foldr ins xs ys ;
ins x ys = case elem x ys of { True -> ys ; False -> Cons x ys ; } ;
histo xs = foldr histins Nil xs ;
histins x Nil = Cons (Pair x 1) Nil ;
histins x (Cons yn yns) =
case yn of {
Pair y n -> case (==) x y of {
True -> Cons (Pair y ((+) n 1)) yns ;
False -> Cons yn (histins x yns) ;
} ;
} ;
sorted lt = foldr (ordins lt) Nil ;
ordins lt x Nil = Cons x Nil ;
ordins lt x (Cons y ys) =
case lt x y of {
True -> Cons x (Cons y ys) ;
False -> Cons y (ordins lt x ys) ;
} ;
ends (K s a z n) = Cons a (Cons z Nil) ;
firstLetter (K s a z n) = a ;
lastLetter (K s a z n) = z ;
freqSorted ks =
let { ft = freqTabOf ks ; } in
Pair (sorted (decreasingFrequencyIn ft) ks) (length ft) ;
decreasingFrequencyIn ft (K s0 a x n0) (K s1 b y n1) =
let { freq = flip assoc ft ; } in
gt ((+) (freq a) (freq x)) ((+) (freq b) (freq y)) ;
flip f x y = f y x ;
freqTabOf ks = histo (concatMap ends ks) ;
blocked = blockedWith Nil ;
blockedWith ds Nil = Nil ;
blockedWith ds (Cons k ks) =
let { dsk = union ds (ends k) ;
eks = endsSubset dsk ;
det = filter eks ks ;
rest = filter (non eks) ks ; } in
Cons k (append det (blockedWith dsk rest)) ;
non f x = case f x of { True -> False ; False -> True ; } ;
endsSubset ds k = subset (ends k) ds ;
enKey k = K k (head k) (last k) (length k) ;
hashAssoc (Hash hs hf) = hf ;
findhash mv ks =
case hashes mv (length ks) ks (Hash (H Nothing Nothing Nil) Nil) of {
Cons (Hash s f) hs -> Just f ;
Nil -> Nothing ;
} ;
hashes maxval nk Nil h = Cons h Nil ;
hashes maxval nk (Cons k ks) h =
concatMap (hashes maxval nk ks) (
concatMap (insertKey nk k) (
concatMap (assignUpto maxval (lastLetter k))
(assignUpto maxval (firstLetter k) h))) ;
assignUpto maxval c h =
case assocm c (hashAssoc h) of {
Nothing -> map (assign c h) (enumFromTo 0 maxval) ;
Just v -> Cons h Nil ;
} ;
insertKey nk k (Hash hs hf) =
case hinsert nk (hash hf k) hs of {
Nothing -> Nil ;
Just hsNew -> Cons (Hash hsNew hf) Nil ;
} ;
assign c (Hash hs hf) v = Hash hs (Cons (Pair c v) hf) ;
hinsert nk h (H lo hi hs) =
let { newlo = case lo of { Nothing -> h ; Just x -> min x h } ;
newhi = case hi of { Nothing -> h ; Just x -> max x h } ;
} in
case elem h hs of {
True -> Nothing ;
False -> case (<=) ((-) ((+) newhi 1) newlo) nk of {
False -> Nothing ;
True -> Just (H (Just newlo) (Just newhi) (Cons h hs)) ;
} ;
} ;
hash hf (K s a z n) = (+) n ((+) (assoc a hf) (assoc z hf)) ;
cichelli ss = case freqSorted (map enKey ss) of {
Pair ks mv -> findhash mv (blocked ks) ;
} ;
main =
let {
keywords =
Cons "as" (
Cons "case" (
Cons "class" (
Cons "data" (
Cons "default" (
Cons "deriving" (
Cons "do" (
Cons "else" (
Cons "hiding" (
Cons "if" (
Cons "import" (
Cons "in" (
Cons "infix" (
Cons "infixl" (
Cons "infixr" (
Cons "instance" (
Cons "let" (
Cons "module" (
Cons "newtype" (
Cons "of" (
Cons "qualified" (
Cons "then" (
Cons "type" (
Cons "where"
Nil ))))))))))))))))))))))) ;
} in
case cichelli keywords of {
Just hf -> emitHashFun hf ;
Nothing -> 0 ;
} ;
emitHashFun Nil = 0 ;
emitHashFun (Cons (Pair c n) hf) = (+) ((+) c n) (emitHashFun hf);
}