www.jammni.de

Logo - Kleiner Drache
Login
Username:

Passwort:

Daten merken
Auto-Login
Registrieren
 
Online
niemand
 
Forumsuche
Suche nach:

Logo - DracheHaskell-Forum

  1 2 nächste Seite

Landei

Gepostet:
02.11.2012 08:58

Nützliche Haskell-Tricks  
Ist mir gerade untergekommen:

Bei...


apply2 :: (a -> a -> b) -> a -> b
apply2 f x = f x x

--z.B.
square = apply2 (*)


... ist apply2 nichts anderes als join von Monad (-> r). Mit anderen Worten


import Control.Monad.Instances

square = join (*)


Was kennt ihr noch so für nette Tricks?
Zum Seitenanfang    
 
Landei

Gepostet:
19.11.2012 16:47

   
Bei Algorithmen wie Mergesort muss man eine Liste in zwei gleichgroße Teile splitten, dazu habe ich heute folgende clevere Implementierung gesehen:


splitInHalves = foldr (\\x (l,r) -> (x:r,l)) ([],[])


Siehe http://stackoverflow.com/questions/13455849/is-this-implementation-of-merge-sort-good
Zum Seitenanfang    
 
IKT

Gepostet:
20.11.2012 21:54

   
Nett :)

Ich kann leider nicht mit solchen Tricks aufwarten.
Zum Seitenanfang    
 
Landei

Gepostet:
29.11.2012 08:57

   
Eine der unterschätztesten Funktionen des Preludes ist fromEnum. Insbesondere angewandt auf Bool ist es oft nützlich:


--xor ohne fromEnum
zipWith (\\x y -> if x/=y then 1 else 0) [1,1,0,0] [0,1,1,0]
--[1,0,1,0]

--xor mit fromEnum
zipWith ((fromEnum.).(/=)) [1,1,0,0] [0,1,1,0]
--[1,0,1,0]



Zum Seitenanfang    
 
Landei

Gepostet:
04.12.2012 23:08

   
Wenn man filter und map nacheinander ausführen muss, und dabei eventuell noch zwei Unterfunktionen z.B. fürs Pattern Matching braucht, ist concatMap oft die bessere Wahl:


foo xs = map f1 $ filter f2 xs where
f1 (x,y,z) = x*y+z
f2 (x,y,z) = x+y*z > 100

foo\' xs = concatMap f xs where
f (x,y,z) = if x+y*z > 100 then [x*y+z] else []
Zum Seitenanfang    
 
Landei

Gepostet:
15.04.2013 09:32

   
Wozu const so alles gut sein kann...

Hier eine Möglichkeit, die Funktion Prelude.last inklusive Fehlerfall als Einzeiler zu schreiben:


import Data.List

last' = foldl' (flip const) $ error "empty list"


Zum Seitenanfang    
 
Landei

Gepostet:
17.04.2013 10:24

   
Umwandlung in Ziffern, z.B. 12345 --> [1,2,3,4,5]


digits = reverse . map (`mod` 10) . takeWhile (> 0) . iterate (`div` 10)
Zum Seitenanfang    
 
Landei

Gepostet:
01.05.2013 14:49

   
Applikative Funktoren sind lustig, man kann sich damit z.B. manchmal replicate sparen.

Angenommen, wir wollen jeden Buchstaben in einem Wort ver-n-fachen, dann geht die Standardlösung in Richtung ...


mult n = concatMap (replicate n)


Wenn man sich aber einmal ansieht, wie der Operator (<*) funktioniert, z.B. ...


import Control.Applicative

"test" <* "abc" --> "ttteeesssttt"


... kommt man schnell auf die recht elegante Lösung:


import Control.Applicative

mult n = (<* [1..n])
Zum Seitenanfang    
 
Landei

Gepostet:
04.05.2013 17:32

   
Letzterer Trick lässt sich in bestimmten Fällen auf 2D erweitern. Hier eine Matrix aus lauer Einsen:


matrix r c = [1] <* [1..c] <$ [1..r]
Zum Seitenanfang    
 
Landei

Gepostet:
05.05.2013 12:56

   
Gerade auf Stackoverflow gesehen ( http://stackoverflow.com/questions/16378773/map-multiple-functions-in-haskell ) :


rotate :: Int -> [a] -> [a]
rotate _ [] = []
rotate n xs = zipWith const (drop n (cycle xs)) xs


Ich denke, ich verstehe wie das funktioniert, aber es dreht mir immer noch ein wenig das Hirn um...

Wobei die pragmatische Variante...


rotate n xs = bs ++ as where (as, bs) = splitAt n xs


...auch nicht schlecht ist.
Zum Seitenanfang    
 

  1 2 nächste Seite