我希望这是一个haskell大纲和重点，目的是如果我很长时间没使用过HASKELL，那么跟随这个我能够很快找回陌生的概念（我过去学习过haskell的体会)，随着学习进程，这篇内容可以继续下去，丰富，变成一个对所有人都有用的教程。

------------------------------------

(http://cheatsheet.codeslower.com/CheatSheet.pdf)//

------------------------------------

--save as first.hs

{-

compile as: ghc --make first.hs -O2 -o first

run as: first

-}

module Main where

main = putStrLn "my first"  

模块：
------------------------------------

--use keyword

--import, module, qualified, as, hiding

import Data.List

import Data.List (sort)

import Data.List hiding (nub)

import qualified Data.Map --这样引用模块名，并带入名称限定，比如说可使用Data.Map.filter

import qualified Data.Map as M

module Geometry.Sphere  

( volume  

, area  

) where

语法：
--------------------------------------

缩进:

(http://en.wikibooks.org/wiki/Haskell/Indentation)

原则一点就是如果是语法结构的一部分进行缩进，同级的语法结构对齐

缩进可用 {} 替代，同级的结构可用 ;分开，这样可将语法写进一行

tips.1: 

把中缀变成前缀 (==) 3 3

把前缀变成中缀 3 `mod` 2

tips.2:

可以这样使用匹配 --arr@(x:xs) --p@(a, b)

---------------------------------------

Bool, Int, String

复合类型:

data MyBool = MFalse | MTrue

--:t MTrue

--MyBool::MyBool

data MyMayBe a = MJust a | MNothing

--:t MJust

--MJust::a->MyMayBe

(注， 这里myMayBe 叫做type constructor, 它的kind叫做*->*)

data M1 a b = M1{f1::a, f2::b}

--:t f1

--f1 :: M1 a b -> a

newtype(http://www.haskell.org/haskellwiki/Newtype)

newtype 声明只有一个域(constructor or field)的data

newtype M1 a b = M1{f1::a, f2::b}

newtype State s a = State { runState :: s -> (s, a) }

type 和 newtype区别 (http://www.haskell.org/haskellwiki/Type#Type_and_newtype)

newtype apply a b = a->b

定义MyPair:

data MyPair a b = MyPair {first::a, second::b}

可以定义MList:

data Mlist a = Mconst a (Mlist a) | Mnil

or)

data Mlist a = Mcons (MyPair a (Mlist a) ) | Mnil

可以定义MTuple

data MT a b c = MT {fa::a, fb::b, fc::c}

typeclass:

常用的typeclass 有 Read, Show, Eq, Ord, Fuctor, Monad...

instance Show (MyBool) where

show MTrue = "MTrue"

show MFalse = "MFalse"

instance Eq (MyBool) where

(==) MTrue MTrue = True

(==) MFalse MFalse = True

(==) _ _ = False

一些重要的typeclass
-----------------------------------

class  (Eq a) => Ord a  where

  (<), (<=), (>=), (>)  :: a -> a -> Bool

  max, min              :: a -> a -> a

不是所有接口都需要实现   

"Each type class defines a certain set of methods which need to be implemented; Eq requires == or /=, and Ord requires <= or compare."

(http://stackoverflow.com/questions/3065954/defining-your-own-ord-for-a-data-type-haskell)

理解 Ord

class (Eq a)=>(Ord a) where

(<=)::a->a->Bool

instance Ord (MyBool) where

(<=) MTrue MFalse = False

(<=) _ _ = True

理解functor:

class Functor functor where

fmap::(a->b)->(functor a)->(functor b)

理解applicative:

class (Functor app)=>Applicative app where:

pure::a->(app a)

<*> :: (app (a->b))->(app a)->(app b)

($) ::(a->b)->(app a)->(app b)

IO
-----------------------------------
http://book.realworldhaskell.org/read/io.html

ghci 的一些使用小技巧
-----------------------------------

        :t :q :m :load
        ghci xxx.hs

可以换行:

:{--后起一行

xxxxx

:}

因为每个 action 都是一个IO a 所以，可以使用do notation

例：

let f=xxx; let b=xxx; return f b

a<-getLine 

lichking 2013-07-23 11:25 发表评论

 //java:

 2 public class main {
 3     public static class PGen{
 4         List<Integer> mList = new ArrayList<Integer>();
 5         Integer mTestInt;
 6         {
 7             mList.add(2);mList.add(3);
 8             mTestInt = 5;
 9         }
10         
11         public Boolean iter(){
12             Integer lim = (int)Math.floor(Math.sqrt(mTestInt) );
13             for(Integer p:mList){
14                 if(mTestInt%p == 0)return false;
15                 if(p>lim)break;
16             }
17             return true;
18         }
19         
20         public Integer next(){
21             for(;!iter();mTestInt=mTestInt+2 ){}
22             mList.add(mTestInt);mTestInt+=2;
23             return mTestInt;
24         }
25         
26         int idx(int i){
27             while(mList.size()<=i){
28                 next();
29             }
30             return mTestInt;
31         }
32         
33         void Show(int i){
34             idx(i);
35             for(Integer p:mList){
36                 System.out.println(p);
37             }
38         }
39     }
40     public static void main(String[] args) {
41         PGen pl = new PGen();
42         pl.Show(100);
43     }
44 }

 //C++:

 2 
 3 struct st_p{
 4     std::vector<int> m_p;
 5     st_p& init(){m_p.push_back(2);m_p.push_back(3); return *this;}
 6     st_p& gen_n(int n){
 7         for(int i = 5; m_p.size()!=n; i=i+2){
 8             if(is_p(i) )
 9                 m_p.push_back(i);
10         }
11         return *this;
12     }
13     bool is_p(int n){
14         int l = sqrt(n)+1;
15         for(int i = 0; i<m_p.size(); ++i){
16             int p = m_p[i];
17             if(p>l) break;
18             if(n%p == 0) return false;
19         }
20         return true;
21     }
22     st_p& show(){
23         for(auto v:m_p){
24             printf("%d, ", v);
25         }
26         return *this;
27     }
28 };
29 int _tmain(int argc, _TCHAR* argv[]){
30     st_p().init().gen_n(20).show();return 0;
32 }

 -- lua:

 2 
 3 plist = {2}
 4 
 5 isP = function(n)
 6     lim = math.floor(math.sqrt(n) )
 7     for _, p in ipairs(plist) do
 8         if n%p == 0 then return false end
 9         if p>lim then return true end
10     end
11     return true;
12 end
13 
14 function pgen()
15   return coroutine.wrap(function ()
16     n = 3
17     while true do
18       if isP(n) then table.insert(plist, n);coroutine.yield(n); end
19       n = n+2
20     end
21   end)
22 end
23 k = pgen()
24 for i = 0, 100 do print (k() ) end

 //scala:
 2 
 2 import scala.collection.immutable.Stream
 3 
 4 object Sieve extends Application {
 5     val prims = Stream.cons(2, checkfrom(3));
 6     
 7     def checkfrom(n: Int):Stream[Int] ={
 8             val testps = prims.takeWhile(_ <= math.floor(math.sqrt(n)).toInt);
 9             val res = testps.foldLeft(true){(acc, e)=>(n%e != 0)&&acc}
10             if(res) Stream.cons(n, checkfrom(n+2) )
11             else checkfrom(n+2);
12         }
13 
14     System.out.println(prims.take(100).toList)
15 };

可以看到：
1. java和c++表达是相似的，你可以精确地表达算法
2. lua和python 是相似的，用到了内置数据结构和生成器
3. scala和 haskell是相似的，lambda, lazy list
4. 表达能力强的语言可以实现较弱语言的表达(废话)，反之不然

lichking 2013-07-08 00:50 发表评论

lichking 2012-02-20 20:00 发表评论