Haskellの機能

階乗::整数->整数の階乗0 = 1階乗n = n *階乗( n - 1 )    
   
      

n の階乗= n > 1の場合n *階乗( n - 1 ) 、それ以外の場合は1             

階乗n =積[ 1 .. n ]    

階乗n =積( enumFromTo 1 n )      

階乗=積. enumFromTo 1     

階乗5で階乗n | n > 0 = n *階乗( n - 1 )とします。​​​                    

階乗5階乗=積. enumFromTo 1​        

calc :: String -> [ Float ] calc = foldl f [] . words where f ( x : y : zs ) "+" = ( y + x ) : zs f ( x : y : zs ) "-" = ( y - x ) : zs f ( x : y : zs ) "*" = ( y * x ) : zs f ( x : y : zs ) "/" = ( y / x ) : zs f ( x : y : zs ) "FLIP" = y : x : zs f zs w = read w : zs    
      
   
          
          
          
          
         
           

fibs = 0 : 1 : zipWith ( + ) fibs (末尾のfibs )          

fibs = 0 : 1 : [ a + b | a <- fibs | b <-末尾のfibs ]                 

fibs = 0 : 1 : [ a + b | ( a , b ) <- zip fibs (末尾のfibs ) ]               

fibs = 0 : 1 : next fibs where next ( a : t @ ( b : _ )) = ( a + b ) : next t                 

fibs = next ( 0 , 1 )ただしnext ( a , b ) = a : next ( b , a + b )            

fibs = unfoldr ( \ ( a , b ) ->ただ( a , ( b , a + b ))) ( 0 , 1 )          

fibs = 0 : scanl ( + ) 1 fibs       

fibs = fix ( \ xs -> 0 : 1 : zipWith ( + ) xs ( tailxs ) ) -- zipWith バージョン= fix (( 0 : ) . ( 1 : ) . ( zipWith ( + ) < *> tail )) -- 上記と同じ、pointfree = fix (( 0 :) . scanl ( + ) 1 ) -- scanl バージョン                
                    
                                   

階乗n = foldr (( . ) . ( * )) id [ 1 .. n ] $ 1 -- 階乗 5 == ((1*) .) ( ((2*) .) ( ((3*) .) ( ((4*) .) ( ((5*) .) id )))) 1 -- == (1*) . (2*) . (3*) . (4*) . (5*) . id $ 1 -- == 1* ( 2* ( 3* ( 4* ( 5* ( id 1 )))))          




階乗n = foldr (( . ) . ( * )) ( const 1 ) [ 1 .. n ] $ () -- 階乗 5 == ((1*) .) ( ((2*) .) ( ((3*) .) ( ((4*) .) ( ((5*) .) (const 1) )))) () -- == (1*) . (2*) . (3*) . (4*) . (5*) . const 1 $ () -- == 1* ( 2* ( 3* ( 4* ( 5* ( const 1 () )))))           




階乗n = foldr (( $ ) . ( * )) 1 [ 1 .. n ] = foldr ( $ ) 1 $ map ( * ) [ 1 .. n ] -- 階乗 5 == ((1*) $) ( ((2*) $) ( ((3*) $) ( ((4*) $) ( ((5*) $) 1 )))) -- == (1*) $ (2*) $ (3*) $ (4*) $ (5*) $ 1 -- == 1* ( 2* ( 3* ( 4* ( 5* 1 ))))                

ハミング= 1 :マップ( 2 * )ハミング`ユニオン`マップ( 3 * )ハミング`ユニオン`マップ( 5 * )ハミング           
                                    

Smooth235 = 1 : foldr ( \ p s -> fix $ mergeBy ( < ) s . map ( p * ) . ( 1 : )) [] [ 2 , 3 , 5 ] where fix f = x where x = f x -- 固定点コンビネータ、共有あり                   
  
                      

mergeBy less xs ys = merge xs ys where merge xs [] = xs merge [] ys = ys merge ( x : xs ) ( y : ys ) | less y x = y : merge ( x : xs ) ys | else = x : merge xs ( y : ys )         
             
            
               
                             

mergesortBy less [] = [] mergesortBy less xs = head $ until ( null . tail ) ( pairwise $ mergeBy less ) [[ x ] | x <- xs ]    
     
                  

ペアワイズf ( a : b : t ) = f a b :ペアワイズf tペアワイズf t = t          
          

-- 「1 より大きい整数で、それより小さい整数で割り切れない整数」
-- 素数 = { n ∈ [2..] | ~ ∃ d ∈ [2..n-1] ⇒ rem nd = 0 } 
-- = { n ∈ [2..] | ∀ d ∈ [2..n-1] ⇒ rem nd ≠ 0 }

素数= [ n | n <- [ 2 .. ]、すべて( \ d -> rem n d /= 0 ) [ 2 .. ( n - 1 )] ]                 

primes = sieve [ 2 .. ]ただしsieve ( p : xs ) = p : sieve [ x | x <- xs , rem x p /= 0 ]      
                        

素数= 2 : [ n | n <- [ 3 .. ],すべて(( > 0 ) . rem n ) $ takeWhile (( <= n ) . ( ^ 2 ))素数]                 
                          

primes = 2 : sieve primes [ 3 .. ]ただしsieve ( p : ps ) ( span ( < p * p ) -> ( h 、t )) = h ++ sieve ps ( minus t [ p * p 、p * p + p .. ])        
                      
                          

-- 「各素数の倍数を列挙することによって得られる
合成数を含まない 1 より大きい整数」 primes = 2 : minus [ 3 .. ] ( foldr ( \ ( m : ms ) r -> m : union ms r ) [] [[ p * p , p * p + p .. ] | p <- primes ])     
                         
                            

primes = 2 : _Y (( 3 : ) . minus [ 5 , 7 .. ] . _U . map ( \ p -> [ p * p , p * p + 2 * p .. ]))ここで-- 非共有 Y コンビネータ: _Y g = g ( _Y g ) -- (g (g (g (g (...))))) -- big union ~= nub.sort.concat _U (( x : xs ) : t ) = x : ( union xs . _U . pairwise union ) t            
                            
  
    
              
    
                

Data.Arrayをインポートします。Data.Listをインポートします( tails 、inits ) 
   

primes = 2 : [ n | ( r : q : _ , px ) <- zip ( tails ( 2 : [ p * p | p <- primes ])) ( inits primes ), ( n , True ) <- assocs ( accumArray ( \ _ _ -> False ) True ( r + 1 , q - 1 ) [ ( m , () ) | p <- px , s <- [ div ( r + p ) p * p ] , m <- [ s , s + p .. q - 1 ] ] ) ]      
              
                       
               
                     
                          
                                      
                                    

product xs = prod xs 1ただし、prod [] a = a prod ( x : xs ) a = prod xs ( a * x )     
  
            
          

product xs = prod xs 1ここで{ prod [] a = a ; prod ( x : xs ) a = prod xs ( a * x ) }     
                

a b を加える= a + b      

ten1 = 5 + 5 ten2 = ( + ) 5 5 ten3 = 5を足す5 ten4 = 5 ` 5を足す`    
    
    
    

ten5 = ( + 5 ) 5 ten6 = ( 5 + ) 5 addfive = ( 5 + ) ten7 = addfive 5    
    
  
   
   

-- この型シグネチャは、empty が任意の型を含むリストを受け取り、Bool 
empty :: [ a ] -> Bool empty ( x : xs ) = False empty [] = Trueを返すことを示しています。    
   
   

-- Maybe a から値を返します。Nothing に遭遇した場合はデフォルト値が与えられます。
fromMaybe :: a -> Maybe a -> a fromMaybe x ( Just y ) = y fromMaybe x Nothing = x       
     
     

isRight :: Either a b -> Bool isRight ( Right _ ) = True isRight ( Left _ ) = False      
    
     

getName :: Person -> String getName ( Person name _ _ ) = name    
      

getSex :: Person -> Sex getSex ( Person _ sex _ ) = sex    
      

getAge :: Person -> Int getAge ( Person _ _ age ) = age    
      

map empty [[ 1 , 2 , 3 ], [] ,[ 2 ],[ 1 .. ]] -- [False,True,False,False] を返します  


map ( fromMaybe 0 ) [ Just 2 , Nothing , Just 109238 , Nothing ] -- [2,0,109238,0] を返します      


map isRight [ Left "hello" , Right 6 , Right 23 , Left "world" ] -- [False, True, True, False] を返します         


map getName [ Person "Sarah"女性20 , Person "Alex"男性20 , tom ] -- 上記の tom の定義を使用して、["Sarah", "Alex", "Tom"] を返します。          

account :: ( String , Integer , Double ) --名前、残高、利率を表す 3 つのタプルの型account = ( "John Smith" , 102894 , 5.25 )     
                                     
  

-- zip 関数の定義。他の zip* 関数も同様に定義されます
zip :: [ x ] -> [ y ] -> [( x , y )] zip ( x : xs ) ( y : ys ) = ( x , y ) : zip xs ys zip _ _ = []      
        
              

zip [ 1 .. 5 ] "hello" -- [(1,'h'),(2,'e'),(3,'l'),(4,'l'),(5,'o')] を返します -- 型は [(Integer, Char)] です  



zip3 [ 1 .. 5 ] "hello" [ False , True , False , False , True ] -- [(1,'h',False),(2,'e',True),(3,'l',False),(4,'l',False),(5,'o',True)] を返します -- 型は [(Integer,Char,Bool)] です       

-- a のリスト ([a]) は、別の a のリストに cons (:) された a か、空のリスト ([]) のいずれかです。
データ[ a ] = a : [ a ] | [] -- Maybe a 型の Something は、Just something または Nothing のいずれかです。データMaybe a = Just a | Nothing -- Either atype btype 型の Something は、Left atype または Right btype のいずれかです。データEither a b = Left a | Right b       

       

         

データSex = Male | FemaleデータPerson = Person String Sex Int -- Personはコンストラクタと型の両方であることに注意してください     
       


-- Person tom型を作成する例:: Person tom = Person "Tom" Male 27  
     

import Control.Monad.ST import Data.STRef import Control.Monad 
 
 

sumST :: Num a => [ a ] -> a sumST xs = runST $ do -- runST は状態のある ST コードを受け取り、それを純粋なものにします。summed <- newSTRef 0 -- STRef (可変変数) を作成します       
                 
                

    forM_ xs $ \ x -> do -- 引数リスト xs の各要素に対して、 .. modifySTRef summed ( + x ) -- それを n にあるものに追加します。               
            

    readSTRef summed -- 上記の runST によって返される n の値を読み取ります。