I find that two spaces is a nice lo

I find that two spaces is a nice looking indentation for a subelements , but you have a lot of freedom in formatting for readability ( just don't outdent within the same level ).

Operator and function precedence
Operators in Haskell fall into multiple levels of precedence. Most of these are the same as you would expect from other programming languages. Multiplication takes precedence over addition , and so on ( so "2+3+4" is 10 , not 14 ). Haskell's standard documentation can provide the details.

There is, however, one "gotcha" in Haskell precedence where it is easy to make a mistake. Functions take precedence over operators. The result of this is that the expression "f g 5" means "apply g (and 5) as arguments to f" not "apply the result of (g 5) to f". Most of the time, this sort of error will produce a compiler error message, since, for example, f will require an Int as an argument rather than another function. However, sometimes the situation can be worse than this, and you can write something valid but wrong:

As with other languages, parentheses are extremely useful in disambiguating expressions where you have some doubt about procedure (or just want to document the intention explicitly). Notice, by the way, that parentheses are not used around function arguments in Haskell; but there is no harm in pretending they are, which just creates an extra expression grouping (as in res2 above).

Scope of names
Readers might think there is a conflict between two points in this tutorial. On the other hand, we have said that names are defined as expressions only once in a program; on the other hand, many of the examples use the same variable names repeatedly. Both points are true, but need to be refined.

Every name is defined exactly once within a given scope. Every function definition defines its own scope, and some constructs within definitions define their own narrower scopes. Fortunately, the "offside rule" that defines subelements also precisely defines variable scoping. A variable (a name, really) can only occur once with a given indentation block. Let's see an example, much like previous ones:

Needless to say, the example is unnecessarily confusing. It is worth understanding, however, especially since arguments only have a scope within particular function definition (and the same names can be used in other function definitions).

Breaking down the problem
One thing you will have noticed is that function definitions in Haskell tend to be extremely short compared to those in other languages. This is partly due to the concise syntax of Haskell, but a greater reason is because of the emphasis in functional programming of breaking down problems into their component parts (rather than just sort of "doing what needs to be done" at each point in an imperative program). This encourages reusability of parts, and allows much better verification than each part really does what it is supposed to do.

The small parts of function definitions may be broken out in several ways. One way is to define a multitude of useful support functions within a source file. and use them as needed. The examples in this tutorial have mostly done this. However, there are also two (equivalent) ways of defining support functions within the narrow scope of a single function definition: the let clause and the where clause. A simple example follows.

The three definitions are equivalent, but f2 and f3 chose to define a (trivial) support function sq within the definition scope.

Importing/exporting
Haskell also supports a module system that allows for larger scale modularity of functions (and also for types, which we have not covered in this introductory tutorial). The two basic elements of module control are specification of imports and specification of exports. The former is done with the import declaration; the latter with the module declaration. Some examples include:

You can see that Haskell provides considerable, and fine-grained control of where function definitions are visible to other functions. This module system helps build.

ผลลัพธ์ (ไทย) 1:

ผมพบว่าสองช่องว่างเป็นเยื้องกำลังมองหาที่ดีสำหรับองค์ประกอบย่อยที่หลากหลาย แต่คุณมีจำนวนมากของเสรีภาพในการจัดรูปแบบเพื่อให้สามารถอ่าน (แค่ไม่เยื้องภายในระดับเดียวกัน).

ประกอบและฟังก์ชั่นสำคัญ
ผู้ประกอบการในฤดูใบไม้ร่วง Haskell เป็นหลาย ๆ ระดับของการเป็นผู้นำ ส่วนใหญ่เหล่านี้เป็นเช่นเดียวกับที่คุณคาดหวังจากการเขียนโปรแกรมภาษาอื่น ๆคูณจะเหนือกว่านอกจากนี้และอื่น ๆ (ดังนั้น "2 3 4" คือ 10 ไม่ใช่ 14) เอกสารมาตรฐาน Haskell สามารถให้รายละเอียด.

มี แต่หนึ่ง "gotcha" ใน Haskell สำคัญที่มันเป็นเรื่องง่ายที่จะทำผิดพลาด ฟังก์ชั่นความสำคัญเหนือกว่าผู้ประกอบการผลจากการนี​​้ก็คือว่าสำนวนที่ว่า "FG 5" หมายถึง "ใช้ g (5) อาร์กิวเมนต์ไปที่ F" ไม่ได้ "มีผลมาจาก (g 5) ฉ" เวลาส่วนใหญ่ของการจัดเรียงของข้อผิดพลาดนี้จะผลิตข้อความข้อผิดพลาดเรียบเรียงตั้งแต่เช่น F จะต้องมี int เป็นอาร์กิวเมนต์มากกว่าฟังก์ชั่นอื่น แต่บางครั้งสถานการณ์อาจจะเลวร้ายยิ่งกว่านี้และคุณสามารถเขียนสิ่งที่ถูกต้อง แต่ผิด:

เช่นเดียวกับภาษาอื่น ๆ วงเล็บเป็นอย่างยิ่งที่มีประโยชน์ในการ disambiguating การแสดงออกที่คุณมีข้อสงสัยเกี่ยวกับขั้นตอนบางอย่าง (หรือเพียงแค่ต้องการเอกสารความตั้งใจอย่างชัดเจน) แจ้งให้ทราบโดยวิธีการวงเล็บที่ไม่ได้ใช้รอบอาร์กิวเมนต์ของฟังก์ชันใน Haskell. แต่มีอันตรายในการแกล้งทำเป็นว่าพวกเขาเป็นที่เพิ่งสร้างการจัดกลุ่มการแสดงออกเป็นพิเศษ (ในขณะที่ res2 ด้านบน) ไม่มี

ขอบเขตของชื่อ
อ่านอาจจะคิดว่ามีความขัดแย้งระหว่างจุดสองจุดในการกวดวิชานี้ บนมืออื่น ๆ ที่เราได้กล่าวว่าชื่อที่จะถูกกำหนดเป็นสำนวนเพียงครั้งเดียวในโปรแกรม; ในอีกหลายตัวอย่างที่ใช้ชื่อตัวแปรเดียวกันซ้ำแล้วซ้ำอีก จุดทั้งสองเป็นความจริง แต่จะต้องมีการกลั่น.

ทุกชื่อที่ถูกกำหนดให้ครั้งเดียวภายในขอบเขตที่กำหนดคำนิยามทุกฟังก์ชันกำหนดขอบเขตของตนเองและสร้างบางส่วนภายในกำหนดขอบเขตคำนิยามของตัวเองแคบ โชคดี "กฎล้ำหน้า" ที่กำหนดองค์ประกอบย่อยที่ยังแม่นยำกำหนดตัวแปรกำหนดขอบเขต ตัวแปร (ชื่อจริง) เพียง แต่สามารถเกิดขึ้นได้ครั้งเดียวกับบล็อกเยื้องที่กำหนด เรามาดูตัวอย่างเหมือนคนก่อนหน้านี้:

จำเป็นต้องพูดตัวอย่างเช่นจะทำให้เกิดความสับสนโดยไม่จำเป็น เป็นความเข้าใจของมูลค่า แต่โดยเฉพาะอย่างยิ่งตั้งแต่การขัดแย้งเพียง แต่มีขอบเขตภายในกำหนดหน้าที่เฉพาะ (และชื่อเดียวกันนี้สามารถนำมาใช้ในความหมายของฟังก์ชั่นอื่น ๆ ).

หมดสภาพปัญหา
สิ่งหนึ่งที่คุณจะได้พบคือคำจำกัดความของฟังก์ชั่นใน Haskell มีแนวโน้มที่จะสั้นมากเมื่อเทียบกับในภาษาอื่น ๆนี้เป็นส่วนหนึ่งเนื่องจากไวยากรณ์กระชับของ Haskell แต่เหตุผลมากขึ้นเป็นเพราะความสำคัญในการเขียนโปรแกรมการทำงานของทำลายลงปัญหาลงไปในชิ้นส่วนของพวกเขา (แทนที่จะเรียงลำดับจากเพียงแค่ "ทำในสิ่งที่จำเป็นต้องทำ" ที่จุดในแต่ละ โปรแกรมจำเป็น) นี้ส่งเสริมให้สามารถนำมาใช้ชิ้นส่วน,และการตรวจสอบที่ดีมากช่วยให้กว่าแต่ละส่วนไม่จริงสิ่งที่มันควรจะทำ.

ชิ้นส่วนขนาดเล็กของคำนิยามฟังก์ชันอาจจะแตกออกในหลายวิธี วิธีหนึ่งคือการกำหนดความหลากหลายของฟังก์ชั่นการสนับสนุนที่เป็นประโยชน์ภายในแฟ้มแหล่งที่มา และใช้พวกเขาตามความจำเป็น ตัวอย่างในการกวดวิชานี้ได้ทำส่วนใหญ่นี้ อย่างไรก็ตามนอกจากนี้ยังมีสองวิธี (เทียบเท่า) ของการกำหนดหน้าที่สนับสนุนภายในขอบเขตแคบของความหมายของฟังก์ชั่นเดียว: ประโยคและให้คำสั่ง WHERE ตัวอย่างง่ายๆดังนี้.

สามมีความหมายเทียบเท่า แต่ F2 F3 และเลือกที่จะกำหนดฟังก์ชั่นการสนับสนุน (เล็กน้อย) ตารางภายในขอบเขตคำนิยาม.

นำเข้า / ส่งออก
Haskell ยังสนับสนุนระบบโมดูลที่ช่วยให้การสร้างต้นแบบขนาดใหญ่ของฟังก์ชั่น (และยังเป็นประเภทที่เราไม่ได้ครอบคลุมในการสอนเบื้องต้นนี้) สององค์ประกอบพื้นฐานของชุดควบคุมเป็นคุณสมบัติของการนำเข้าและข้อกำหนดของการส่งออก อดีตจะกระทำด้วยการประกาศนำเข้า; หลังมีการประกาศโมดูล ตัวอย่างบางส่วนรวมถึง:

คุณจะเห็นว่า Haskell ให้การควบคุมที่มากและละเอียดของคำจำกัดความที่ฟังก์ชั่นที่สามารถมองเห็นการทำงานอื่น ๆ ระบบโมดูลนี้จะช่วยสร้าง

ผลลัพธ์ (ไทย) 2:

พบที่สองช่องเป็นย่อหน้าการมองที่ดีสำหรับองค์ประกอบที่ แต่คุณมีเสรีภาพในการจัดรูปแบบสำหรับอ่าน (เพียงไม่จัดในระดับเดียวกัน)

ก่อนดำเนินการและฟังก์ชัน
ผู้ประกอบการใน Haskell ตกหลายระดับความสำคัญ ส่วนใหญ่เหล่านี้จะเหมือนกับภาษาโปรแกรมอื่น ๆ จะ คูณจะสำคัญกว่านี้ และ (จึง "2 3 4" 10 ไม่ 14) เอกสารมาตรฐานของ Haskell สามารถให้รายละเอียดได้

มี แต่ หนึ่ง "gotcha" ใน Haskell สำคัญที่จะทำให้ความผิดพลาดได้ ฟังก์ชันจะมีบทบาทเหนือผู้ประกอบการ ผลลัพธ์นี้คือนิพจน์ " f g 5 " หมายถึง "ใช้ g (และ 5) เป็นอาร์กิวเมนต์ f" ไม่ "กับผล (g 5) f" ส่วนใหญ่ของเวลา การเรียงลำดับของข้อผิดพลาดนี้จะผลิตข้อความข้อผิดพลาดของคอมไพเลอร์ ตั้งแต่ เช่น f จะต้องการ Int เป็นอาร์กิวเมนต์มากกว่าฟังก์ชันอื่น อย่างไรก็ตาม บางครั้งสถานการณ์อาจเลวร้ายยิ่งกว่านี้ และคุณสามารถเขียนสิ่งที่ถูกต้องแต่ไม่ถูกต้อง:

เป็นภาษาอื่น ๆ เล็บได้ประโยชน์อย่างยิ่งในนิพจน์ disambiguating ที่คุณมีข้อสงสัยบางอย่างเกี่ยวกับกระบวนการ (หรือเพียงต้องการเอกสารความตั้งใจอย่างชัดเจน) สังเกต โดยวิธี ที่ วงเล็บจะไม่ใช้สถานอาร์กิวเมนต์ของฟังก์ชันใน Haskell แต่ไม่อันตรายในอ้างเป็น ซึ่งเพียงสร้างนิพจน์เสริมจัดกลุ่ม (ใน res2 ข้างต้น)

ขอบเขตของชื่อ
ผู้อ่านอาจคิดว่า มีความขัดแย้งระหว่างจุดสองจุดในกวดวิชานี้ บนมืออื่น ๆ เราได้กล่าวว่า มีกำหนดชื่อเป็นนิพจน์เพียงครั้งเดียวในโปรแกรม บนมืออื่น ๆ มากมายอย่างการชื่อตัวแปรเดียวกันซ้ำ ๆ จุดทั้งสองเป็นจริง แต่จำเป็นต้องรับ

ทุกชื่อไว้ว่าครั้งเดียวภายในขอบเขตที่กำหนด ทุกนิยามฟังก์ชันกำหนดขอบเขตของตนเอง และบางโครงสร้างภายในข้อกำหนดกำหนดขอบเขตของตัวเองให้แคบลง โชคดี "ล้ำกฎ" ที่กำหนดองค์ประกอบยังแม่นยำกำหนดกำหนดโครงร่างวิจัยตัวแปร ตัวแปร (ชื่อ จริง ๆ) สามารถเกิดครั้งเดียวด้วยการเยื้องให้เท่านั้น ลองดูตัวอย่าง เหมือนก่อนหน้า:

จำเป็นต้องพูด ตัวอย่างอย่างไรโดยไม่จำเป็น คุ้มค่าการทำความเข้าใจ แต่ โดยเฉพาะอย่างยิ่งเนื่องจากอาร์กิวเมนต์มีขอบเขตภายในข้อกำหนดฟังก์ชันเฉพาะ (และสามารถใช้ชื่อเดียวกันในคำนิยามฟังก์ชันอื่น ๆ)

แบ่งปัญหา
สิ่งหนึ่งที่คุณจะได้สังเกตเห็นว่า ฟังก์ชันนิยามใน Haskell มักจะสั้นมากเปรียบเทียบกับภาษาอื่น นี้เป็นบางส่วนเนื่องจากไวยากรณ์กระชับของ Haskell แต่มีเหตุผลมากขึ้นเนื่องจากเน้นเขียนโปรแกรมทำงานของการแบ่งปัญหาออกเป็นส่วนประกอบของพวกเขา (มากกว่าเพียงแค่จัดเรียงของ "ทำอะไรต้องทำ" แต่ละจุดในโปรแกรมมีความจำเป็น) นี้กระตุ้น reusability ชิ้น และให้ตรวจสอบดีกว่าแต่ละส่วนได้ไม่อะไรมันควรจะ do. จริง ๆ

ส่วนเล็กของฟังก์ชันนิยามอาจเสียออกในหลายวิธีการ วิธีหนึ่งคือการ กำหนดความหลากหลายของประโยชน์สนับสนุนฟังก์ชันในแฟ้มต้นฉบับ และใช้ตามความจำเป็น ตัวอย่างในกวดวิชานี้ส่วนใหญ่ได้กระทำนี้ อย่างไรก็ตาม นอกจากนี้ยังมีสองวิธี (เทียบเท่า) ของการกำหนดฟังก์ชันสนับสนุนภายในขอบเขตที่แคบของคำนิยามฟังก์ชันเดียว: อนุประโยคให้ และซึ่งประโยค ดังนี้ตัวอย่างง่าย ๆ เช่นการ

ข้อกำหนดสามคือเทียบเท่า แต่ f2 และ f3 เลือกกำหนดตร.ฟังก์ชันการสนับสนุน (เล็กน้อย) ภายในขอบเขตคำนิยาม

นำเข้า/ส่งออก
Haskell ยังสนับสนุนระบบโมดูลที่ช่วยให้ สำหรับ modularity ขนาดใหญ่ของฟังก์ชัน (และ สำหรับ ชนิด ซึ่งเราไม่ได้ครอบคลุมในกวดวิชานี้เกริ่นนำ) สององค์ประกอบพื้นฐานของโมดูลการควบคุมมีข้อมูลจำเพาะเกี่ยวกับการนำเข้าและข้อมูลจำเพาะของการส่งออก เดิมทำรายงานภาษีการนำเข้า หลัง มีรายงานโมดูล ยกตัวอย่างเช่น:

คุณสามารถดูว่า Haskell ให้มาก และทรายแป้งละเอียดควบคุมที่เห็นกับคำนิยามของฟังก์ชัน นี้โมดูลระบบช่วยสร้าง

ผลลัพธ์ (ไทย) 3:

ผมก็พบว่าทั้งสองเป็นพื้นที่ที่สวยงามที่มองเห็นรอยสำหรับ subelements ,แต่คุณมีอิสระในการจัดรูปแบบการอ่าน(ไม่ได้ outdent ภายใน ที่เหมือนกับระดับ)

ผู้ปฏิบัติงานและการทำงานมีความสำคัญเหนือกว่า
ซึ่งจะช่วยให้ผู้ประกอบธุรกิจใน Eddie Haskell ' s ตกอยู่ในหลายระดับมีความสำคัญมากกว่า. เหล่านี้ส่วนใหญ่จะเหมือนกับที่คาดหวังว่าจะได้รับจาก ภาษา การเขียนโปรแกรมอื่นๆการคูณจะมีความสำคัญมากกว่านอกจากนี้ยังและอื่นๆ(" 234 "มี 10 ไม่ได้ 14 ) เอกสารมาตรฐานของ Eddie Haskell ' s สามารถให้รายละเอียด.

แต่ถึงอย่างไรก็ตามยังมีหนึ่ง" gotcha "ในแบบฉบับ Eddie Haskell ' s ซึ่งเป็นการง่ายที่จะทำให้ผิดที่ ฟังก์ชันการทำงานมีผลบังคับใช้เหนือกว่าผู้ให้บริการผลที่ได้จากนี้คือการแสดงออกที่" F G 5 "หมายถึง"ใช้ G (และ 5 )เป็นอาร์กิวเมนต์ถึง F "ไม่ใช่"ใช้ผลที่ได้จาก( G 5 )ไปยัง F " ส่วนมากของเวลาที่ได้ ประเภท นี้ของข้อผิดพลาดจะทำให้เกิดข้อความแสดงข้อผิดพลาดคอมไพเลอร์ที่มาตั้งแต่ตัวอย่างเช่น F จะต้องมีฟังก์ชัน Int เป็นอาร์กิวเมนต์ที่มากกว่าคนอื่น. แต่ถึงอย่างไรก็ตามในบางครั้งสถานการณ์ที่สามารถจะไม่แย่ไปกว่านี้และคุณสามารถเขียนอะไรบางอย่างที่ถูกต้องแต่ไม่ถูกต้อง:

พร้อมด้วย ภาษา อื่นเป็นเครื่องหมายวงเล็บ:มีประโยชน์เป็นอย่างมากใน Expressions disambiguating สถานที่ซึ่งท่านมีข้อสงสัยบางอย่างเกี่ยวกับขั้นตอน(หรือเพียงต้องการเอกสารความตั้งใจที่อย่างชัดเจน) ต้องแจ้งให้ทราบล่วงหน้าโดยวิธีที่วงเล็บจะถูกใช้งานโดยรอบอาร์กิวเมนต์ไม่ทำงานใน Eddie Haskell ' s แต่ไม่มีอันตรายอยู่ในแสร้งทำเป็นห้องพักมีที่อยู่จะสร้างการจัดกลุ่มการแสดงพิเศษ(ในความละเอียดสูง, 2 ด้านบน)

ขอบเขตของชื่อ
ซึ่งจะช่วยผู้อ่านอาจจะคิดว่ามีความขัดแย้งระหว่างสองจุดในคำแนะนำนี้ ในอีกด้านหนึ่งที่เราได้พูดว่าชื่อเป็นไปตามที่กำหนดไว้เป็นนิพจน์เพียงครั้งเดียวในโปรแกรมบนมือถืออื่นๆจำนวนมากของตัวอย่างที่ใช้ชื่อเดียวกันกับที่ปรับเปลี่ยนซ้ำหลายครั้ง ทั้งคะแนนเป็นความจริงแต่ต้องทำทุก refined.name

มีการกำหนดอย่างแท้จริงเมื่ออยู่ ภายใน ขอบเขตที่ระบุความละเอียดทุกฟังก์ชั่นกำหนดขอบเขตของตัวเองและการประกอบสร้างบางอย่างในคำนิยามของกำหนดขอบเขตแคบลงของตนเอง โชคยังดี"กฎข้อที่ล้ำหน้า"ที่ได้กำหนดไว้อย่างแม่นยำ subelements นอกจากนั้นยังกำหนด scoping ตัวแปร ปรับได้(ชื่อจริงๆ)สามารถเกิดขึ้นเมื่อพร้อมด้วยอาคารก่ออิฐออกใบสั่งให้เท่านั้น ปล่อยให้ดูตัวอย่างมากเหมือนกับก่อนหน้า:

ไม่จำเป็นที่จะต้องพูดว่ายกตัวอย่างเช่นที่จะเกิดความสับสนโดยไม่จำเป็น มันเป็นความเข้าใจมีมูลค่าแต่ถึงอย่างไรก็ตามเนื่องจากอาร์กิวเมนต์เท่านั้นที่จะมีขอบเขตที่ในคำนิยามฟังก์ชันเฉพาะ(และชื่อเดียวกันนี้สามารถใช้ในความหมายของฟังก์ชันอื่นๆ)

ทำลายลงปัญหาที่
สิ่งหนึ่งที่คุณจะสังเกตเห็นว่าคำนิยามของฟังก์ชันใน Eddie Haskell ' s มีแนวโน้มที่จะสั้นมากเมื่อเทียบกับผู้ที่อยู่ใน ภาษา อื่นโรงแรมแห่งนี้คือส่วนหนึ่งเป็นผลจากการที่รัดกุมไวยากรณ์ของ Eddie Haskell ' s ,แต่ที่มากด้วยเหตุผลเนื่องจากการที่เน้นประโยชน์ใช้สอยในการตั้งโปรแกรมของการทำลายลงปัญหาในส่วนประกอบของชิ้นส่วน(มากกว่าแค่"ทำสิ่งที่จำเป็นต้องทำ"ในแต่ละจุดที่เป็นสิ่งจำเป็นในโปรแกรม) โรงแรมแห่งนี้ให้ reusability ของชิ้นส่วนการตรวจสอบความถูกต้องและทำให้ดีขึ้นมากกว่าแต่ละอย่างแท้จริงไม่ว่าอะไรคือสิ่งมีความเชื่อว่าจะทำได้

ชิ้นส่วนขนาดเล็กของคำนิยามของฟังก์ชันอาจจะเสียออกมาในหลายวิธี วิธีการหนึ่งก็คือการกำหนดเป็น"มหาชน"ของการสนับสนุนเป็นประโยชน์ในไฟล์แหล่งที่มาและใช้ตามความจำเป็น ตัวอย่างในการสอนนี้ทำอย่างนี้เป็นส่วนใหญ่ แต่ถึงอย่างไรก็ตามนอกจากนั้นยังมีสอง(เทียบเท่า)วิธีการในการกำหนดการทำงานการสนับสนุนในขอบเขตจำกัดของความละเอียดงานเดียวที่ข้อให้และที่ข้อ ยกตัวอย่างเช่นที่เรียบง่ายโดยมีรายละเอียดดังนี้.

สามความหมายที่มีแต่ F 2 F 3 และเลือกที่จะกำหนด(หยุมหยิม)ฟังก์ชันการสนับสนุนตารางเมตรอยู่ ภายใน ขอบเขตความละเอียดที่.

การนำเข้า/ส่งออก
Eddie Haskell ' s ยังสนับสนุนระบบโมดูลที่ช่วยให้ระบบโมดูลมีขนาดใหญ่ของการใช้งาน(และสำหรับ ประเภท ที่เราไม่ได้อยู่ในการสอนเบื้องต้นนี้) สองปัจจัยพื้นฐานของโมดูลควบคุมการมีข้อมูลจำเพาะของข้อมูลจำเพาะและการนำเข้าการส่งออก ก่อนที่จะทำได้ด้วยการประกาศการนำเข้าที่หลังที่พร้อมด้วยคำประกาศโมดูล ตัวอย่างบางส่วนรวมถึง:

คุณจะเห็นว่า Eddie Haskell ' s จัดให้บริการการควบคุมอย่างละเอียดทั้งและอย่างมากซึ่งคำนิยามของฟังก์ชันจะปรากฏให้เห็นในการจัดงานอื่น ระบบโมดูลนี้จะช่วยสร้าง