[w() if type(w) is type else w for w in ws]. He appeared very surprised when I swiftly decoded the expression and correctly guessed its alleged function (apparently most people who applied to the same job were unable to understand such simple expression). This is the only time ever I saw a real need to taint my mind with a heterogeneous collection.
f !?.??+1 [ø@X]
module Main
where
import List
import Control.Arrow
type Comparator a = (a -> a -> Ordering)
ascending :: (Ord a) => (b -> a) -> Comparator b
ascending f x y = compare (f x) (f y)
descending :: (Ord a) => (b -> a) -> Comparator b
descending = flip . ascending
secondary :: Comparator a -> Comparator a -> Comparator a
secondary f g x y = case f x y of {
EQ -> g x y;
z -> z; }
-- Returns a list of unique elements together with their frequency. Listed in decreasing order of frequency, followed by
increasing order of the elements.
count :: (Ord a) => [a] -> [(a, Int)]
count = map (head &&& length) . sortBy (descending length `secondary` ascending head) . group . sort
main :: IO ()
main = interact $ unlines . map (\(x, y) -> (take 20 $ x ++ repeat ' ') ++ " : " ++ show y) . count . wordslet f x y = x + y in (* for the sake of example *)
f 1;;
- : int -> int = <fun>(+) 1;; (* treat `+` as a function *)(+)(1,) using "operator base" and "partial application" but there was never a Revised Revised Report so these were just proposed extensions. Algol 68 was an expression-oriented garbage-collected multi-threaded language. Any type can be anonymous including functions, structures, unions, references, and arrays. Some of the other things it almost had were case on ranges and subtypes, modals (type variables/generics), deuniting (implicitly extracting values from unions), record transfer (persistent mass storage), inductive types (e.g. mode list = (mode x)union(void, struct(x car, list(x) cdr))), a composable module system (like ML structures and functors), restartable exceptions, lazy parameters, and collecting loop expressions (like array comprehensions). The Revised Revised Report would have been decades ahead of many languages today.