Programming-Idioms.org

putStrLn "Hello world!"

replicateM_ 10 $ putStrLn "Hello"

f = print "whatever"

square x = x^2

square x = x * x

square x = x**2

data Point = Point 
  { x :: Double
  , y :: Double 
  }

data Point = Point
  { x :: Double
  , y :: Double
  } deriving (Eq, Ord, Show, Read)

forM_ items doSomething

mapM_ print (zip [0..] items)

x = Data.Map.Strict.fromList [ ("red", "FF0000"), ("blue", "0000FF") ]

data BT x = BEnd | BNode (BT x) x (BT x)

shuffle x = if length x < 2 then return x else do
	i <- System.Random.randomRIO (0, length(x)-1)
	r <- shuffle (take i x ++ drop (i+1) x)
	return (x!!i : r)

(\l g -> l !! fst (randomR (0, length l) g))

(l !!) <$> randomRIO (0, length l - 1)

x `elem` list

find _ [] = False
find n (x:xs)
  | x == n = True
  | otherwise = find n xs

let f k v = [show k, " = ", show v]
    mapped = Map.mapWithKeys f mymap
in putStrLn $ intercalate "," $ mapped

pick(a,b)=
  return.(+a).(*(b-a))=<<System.Random.randomIO::IO(Double)

pick a b = do
  r <- System.Random.randomIO :: IO Double
  return a + (r * (b - a))

let pick (a, b) = randomRIO (a, b) :: IO Integer
 in pick (1, 6) >>= print

inorder Ø = []
inorder (BT left pivot right) =
  inorder left ++ pivot : inorder right
f <$> inorder bt

instance Functor BT where
  fmap f (BT l x r) = BT (fmap f l) (f x) (fmap f r)

fmap f bt

import Data.List

data Matrix a = Matrix [[a]]
              deriving (Eq)

-- переопрееляем вывод для матриц
instance Show a => Show (Matrix a)
  where
    show (Matrix a) = intercalate "\n" (map (intercalate " " . map show) a)

-- сложение
plus :: Num a => [[a]] -> [[a]] -> [[a]]
plus a b = zipWith (zipWith (+)) a b

-- instance (+) a => (+) (Matrix a) (Matrix a)
--   where 
--     (+) (Matrix a) (Matrix b) = plus_mat (Matrix a) (Matrix b)

-- | Identity matr

preordered (Node pivot left right) = 
   pivot : preordered left ++ preordered right
preordered Ø = []
f <$> (preordered tree)

reverse x

search x m = head [ (i, j) | (i, r) <- zip [0..] m,
                             (j, c) <- zip [0..] r, c == x]

swap (a,b) = (b,a)

let i = read s :: Integer

s <- showFFloat (Just 2) x ""

s = "ネコ"

peopleToGreet <- newChan
writeChan peopleToGreet "Alan"

x = [ [ j**(1/i) | j <- [1..n] ] | i <- [1..m] ]

x = [ [ [ k**(i/j) | k<-[1..p] ] | j<-[1..n] ] | i<-[1..m] ]

sortBy (comparing p) items

List.sortOn p items

take i items ++ drop (1 + i) items

mapM_ (forkIO . f) [1..1000]

f i = if i > 1 then f (i-1) * i else 1

exp = (^)

putMVar x . f =<< takeMVar x

x = empty :: Set T

compose :: (A -> B) -> (B -> C) -> A -> C
compose = flip (.)

compose :: (A -> B) -> (B -> C) -> A -> C
compose f g x = g (f x)

compose f g = g . f

curry range

addThem :: Num a => a -> a -> a
addThem = (+)

add5 :: Num a => a -> a
add5 = addThem 5

t = drop i (take j s)

ok = word `isInfixOf` s

datatype Node = Int
datatype Adjacencies = [ Node ]
datatype Graph = [ Adjacencies ]

t = reverse s :: String

sequence_ [ print v | v <- a, [ u | u <- b, u == v] == [] ]

(print . head . filter (<0) . concat) m

take i s ++ x : drop i s

Control.Concurrent.threadDelay 5000000

t :: String
t = take 5 s

t :: T.Text
t = T.take 5 s

t = drop (length s - 5) s

s = unlines [
     "several"
    ,"lines"
    ,"of"
    ,"text"]

s :: String
s = "We will put a backslash to take a break\
     \and then a backslash to resume"

chunks = words s

forever (getLine >>= putStrLn)

let x = x in x

forever $ pure ()

(/=Nothing) (lookup k m)

Map.member k m

elem v (elems m)

y = intercalate ", " x

{-# LANGUAGE OverloadedStrings #-}
y :: T.Text
y = T.intercalate ", " x

s = sum x

let s = show i

mapConcurrently f [1..1000]
print "Finished"

y = filter p x

do lines <- readFile f; putStr lines

hPutStrLn stderr (show (x) ++ " is negative")

x <- return.head =<< System.Environment.getArgs

d <- System.Posix.Time.epochTime

Just i <- (y `isPrefixOf`) `findIndex` (tails x)

allchanged [] _ _ = []
allchanged input from to = if isPrefixOf from input
  then to ++ allchanged (drop (length from) input) from to
  else head input : allchanged (tail input) from to

x2 = allchanged x y z

x :: Integer
x = 3^247

s = Numeric.showFFloat (Just 1) (100*x) "%"

z = x ^ n

binom n k = product [1+n-k..n] `div` product [1..k]

x :: Integer
x = sum [bit i | i <- [1..n], wannaset i]

System.Random.mkStdGen s

getStdGen

putStrLn . unwords =<< System.Environment.getArgs

x = gcd a b

gcd a b
    |   a==b =a
    |   a>b = gcd(a-b) b
    |   otherwise = gcd a (b-a)

gcd x y =  gcd' (abs x) (abs y)
	where
	gcd' a 0  =  a
	gcd' a b  =  gcd' b (a `rem` b)

x = lcm a b

s x = showIntAtBase 2 intToDigit x ""

foldl (\acc -> (++ acc) . show) "" . unfoldr (\n -> if x == 0 then Nothing else Just (x `mod` 2, x `div` 2))

let i = ( 0 :+ 1 ) ; x = 3 * i - 2 in x * i

x = (0 :+ 1) * ((0 - 2) :+ 3)

doowhile c b = do a <- b; if c a
                          then doowhile c b
                          else return a

doowhile (=="") getLine
gg

y = fromInteger x :: Double

y = truncate x

y = floor (x + 1/2)

sum [ 1 | r <- tails s, isPrefixOf t r ]

length . filter (isPrefixOf t) . tails $ s

r :: String -> Bool
r = (=~ "htt+p")

c = Data.Bits.popCount i

addingWillOverflow x y = y > maxBound - x

exitSuccess

createBuf :: Int -> IO (V.IOVector Word8)
createBuf n = V.new n

main :: IO ()
main = do
  buf <- createBuf 1000000
  return ()

sqrt' :: Int -> Either String Int
sqrt' x | x < 0 = Left "Invalid argument"
sqrt' x         = Right (sqrt x)

module Foo (Foo, getX) where

import Data.IORef

data Foo = Foo { xRef :: IORef Integer }

getX = readIORef . xRef

control f = f

print (dynTypeRep (toDyn x))

filesize = withFile path ReadMode hFileSize

b = prefix `isPrefixOf` s

b = isSuffixOf suffix s

d = posixSecondsToUTCTime . secondsToNominalDiffTime . MkFixed $ toInteger ts

x = showGregorian d

result = sortBy c items

s <- getProgName

dir <- getCurrentDirectory

dir <- takeDirectory `fmap` getExecutablePath

dir = unsafePerformIO (takeDirectory `fmap` getExecutablePath)

b = null (dropWhile isSpace s)

blank :: Bool
blank = all isSpace s

spawnProcess x ["a","b"]

mapM_ print (Map.toList mymap)

mapM_ print $ sortBy (comparing snd) $ Map.toList mymap

mapM_ print . sortOn snd $ Map.toList mymap

b = x == y

b = d1 < d2

remove :: String -> String -> String
remove w "" = ""
remove w s@(c:cs) 
  | w `isPrefixOf` s = remove w (drop (length w) s)
  | otherwise = c : remove w cs

s2 = remove w s1

let n = length x

y = Set.fromList x

nub x

n <- (read :: String -> Int) <$> getContents

data Suit = SPADES | HEARTS | DIAMONDS | CLUBS deriving (Enum)

let x' = assert isConsistent x

binSearch :: Ord a => a -> [a] -> Maybe Int
binSearch _ [] = Nothing
binSearch t l = let n = div (length l) 2
                    (a, m:b) = splitAt n l in
                if t < m then binSearch t a
                else if t > m then aux (binSearch t b)
                else Just n where
    aux :: Maybe Int -> Maybe Int
    aux (Just x) = Just (x+n+1)
    aux _ = Nothing

foo :: (String, Bool)   -- optional signature
foo = ("String", True)

if c1 then f1
else if c2 then f2
else f3

let x | c1 = f1
      | c2 = f2
      | c3 = f3

containsIgnoreCase :: String -> String -> Bool
containsIgnoreCase s word = isInfixOf (map toLower word) (map toLower s)

items = [a, b, c]

delete x items

filter (/= x) items

b = all isDigit s

withTempFile $ \f -> do
  -- do something with f

withTempDirectory $ \d -> do
  -- do something with d

delete k m

mapM_ print $ items1 ++ items2

s :: String
s = printf "%x" 999

interweave :: [a] -> [a] -> [a]   -- optional signature
interweave [] ys = ys
interweave xs [] = xs
interweave (x:xs) (y:ys) = x : y : interweave xs ys

main = mapM_ print $ interweave items1 items2

mapM_ print . concat 
	$ zipWith (\a b -> [a,b]) items1 items2

b = doesFileExist fp

read s :: Double

f = filter isAscii
t = f s

t = filter isAscii s

read <$> getLine :: IO [Integer]

-- reading space separated list of ints
map read . words <$> getLine :: IO [Int]

slashscrape p = if last p == '/' then init p else p

p' = dropWhileEnd (== pathSeparator) p

s = [c]

t = s ++ show i

removeFile filePath

planet = "Earth"

randomSample :: Int -> [a] -> IO [a]
randomSample 0 x = pure []
randomSample k x = do
   i <- randomRIO (0, length x - 1)
   let (a, e:b) = splitAt i x
   l <- randomSample (k-1) (a ++ b)
   pure (e : l)

data Trie v 
  = Branch Char (Map Char (Trie v))
  | Leaf Char v

detectArch :: IO ()
detectArch = do
    case arch == "x86_64" of
        True -> do f64
        False -> case arch == "x86" of
                    True -> do f32

map (*c) elements

do
  args <- getArgs
  when ("b" `elem` args) bat
  when ("f" `elem` args) fox

everySecond :: [a] -> [a]
everySecond [] = []
everySecond (_:[]) = []
everySecond (_:x:xs) = x : everySecond xs
everySecond' :: [a] -> [a]
everySecond' = everySecond . (undefined :)

mapM_ print (zip (everySecond list) (everySecond' list))

pair :: [a] -> [(a, a)]
pair [] = []
pair (x:[]) = error "List had odd length"
pair (x:y:xs) = (x, y) : pair xs

mapM_ print (pair list)

foo :: [a] -> Maybe a
foo [] = Nothing
foo xs = Just $ last xs

x = foo items

x = last items

ab = a ++ b

t = Maybe.fromMaybe s $ List.stripPrefix p s

t :: String
t = if w `isSuffixOf` s then take (length s - length w) else s

n = length s

getMapSize :: Map.Map k v -> Int
getMapSize m = Map.size m

xs = s ++ [x]

newM = Map.insert k v m

s :: Int -> String
s = intersperseN ',' 3 . show

intersperseN :: a -> Int -> [a] -> [a]
intersperseN x n = uncurry (<>) . foldr alg ([], [])
  where
    alg a (buf', acc)
      | length buf >= n = ([], (x:buf) <> acc)
      | otherwise = (buf, acc)
      where buf = a:buf'

b = x >= x1 && x <= x2 && y >= y1 && y <= y2

rectCenter :: Num a => (a, a) -> (a, a) -> (a,a)
rectCenter (x1,y1) (x2,y2) = ((x1+x2)/2,(y1+y2)/2)

do
  x <- listDirectory d
  -- do something with x

main = putStr s >> print s where s = "main = putStr s >> print s where s = "

exitSuccess

y = (map t . filter p) x

when (foldl1 (||) $ map (a > x)) f

exitWith (ExitFailure 4)

hypo x y = sqrt $ x**2 + y**2

sumOfSquares = sum . map (^2)

mean dat = sum dat / (fromIntegral $ length dat)

stddev dat = sqrt . mean $ map ((**2) . (m -)) dat
  where
    m = mean dat

do
  foo <- catch (getEnv "FOO") (const $ pure "none" :: IOException -> IO String)
  -- do something with foo

case str of
  "foo" -> foo
  "bar" -> bar
  "baz" -> baz
  "barfl" -> barfl

--              BaseString      PadChar      MinOutputLength     PaddedString/Output
padLeft ::       String ->     Char ->          Int ->                String
padLeft s c m = let 
   isBaseLarger =  length s > m
   padder s c m False = [ c | _ <- [1..(m-length s)]] ++ s
   padder s _ _ True = s
      in 
         padder s c m isBaseLarger

a `intersect` b

t= unwords $ words s

t = (a, b, c)

t = filter (`elem` ['0'..'9']) s

findIndex x items = fst <$> (find ((==x) . snd) . zip [0..]) items

i = fromMaybe -1 (findIndex x items)

items2 = x : items

f(x:xs)= x:xs

pop :: [a] -> [a]
pop [] = []
pop xs = init xs

let items2 = pop items

let items2 = init items

c = xor a b

let (outA,outB) = unzip $ sort $ zip a b

print a

print x

c = count . nub $ items

(a, b, c) = (42, "hello", 5.0)

x = if condition then 'a' else 'b'

let x | condition = "a"
      | otherwise = "b"

msgStacktraced :: HasCallStack => String -> IO ()
msgStacktraced msg = putStrLn (msg ++ "\n" ++ prettyCallStack callStack)

replaced = map (\e -> if e == "foo" then "bar" else e) x

print x

forM_ (reverse [0..5]) print

foldl  (\res x-> x:res) [] [0..5]

var :: [String]
var = []

log2d :: Double -> Integer
log2d = floor . logBase 2

log2u :: Double -> Integer
log2u = ceiling . logBase 2

main :: IO ()
main = print $ [log2d, log2u] <*> [1..12]

foo :: [[a]] -> IO ()
foo a = print (length a, length $ head a)

main :: IO ()
main = foo [[1, 2, 3], [4, 5, 6]]

s = concat $ replicate n v

data Vector a = Vector a a a

infixl 7 ×
(×) :: Num a => Vector a -> Vector a -> Vector a
Vector x1 y1 z1 × Vector x2 y2 z2 = Vector (y1 * z2 - z1 * y2) (z1 * x2 - x1 * z2) (x1 * y2 - y1 * x2)

data Vector a = Vector a a a

infixl 7 `x`
x :: Num a => Vector a -> Vector a -> Vector a
Vector x1 y1 z1 `x` Vector x2 y2 z2 = Vector (y1 * z2 - z1 * y2) (z1 * x2 - x1 * z2) (x1 * y2 - y1 * x2)

t = filter (not . isSpace) s

type Point = (Integer, Integer)
m :: Map.Map Point String
m = Map.empty
m' = Map.insert (42, 5) "Hello" m

a = replicate n 0

forM_ (zip [0 ..] s) (\(i, c) -> putStrLn $ "Char " ++ show i ++ " is " ++ [c])

b = e `member` x

s = a ++ b

s = a <> b

-- This is a comment

fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib n-1 + fib n-2

lastChar :: String -> Char
lastChar s
    | s=="" = ""
    | otherwise = s !! (length s - 1)