ศรีลังกา
กระบวนทัศน์	เชิงวัตถุ
ออกแบบโดย	กาวิน คิง
นักพัฒนา	มูลนิธิอีคลิปส์
ปรากฏครั้งแรก	2011 ( 2011 )
เวอร์ชันเสถียร	1.3.3 / 21 สิงหาคม 2560 ( 21 สิงหาคม 2560 )
วินัยในการพิมพ์	มั่นคงแข็งแรงปลอดภัย​​
แพลตฟอร์ม	เครื่องเสมือน Java , JavaScript
ใบอนุญาต	ใบอนุญาต Apache 2.0
นามสกุลไฟล์	.ศรีลังกา[ 1 ]
เว็บไซต์	ceylon-lang .org
ได้รับอิทธิพลจาก
Java , [ 2 ] Scala , Smalltalk , ML , [ 3 ] Lisp , [ 4 ] Whiley [ 5 ]

Ceylonเป็น ภาษาโปรแกรมเชิงวัตถุ ที่มีการกำหนดประเภทแบบคงที่อย่างเข้มงวด โดยเน้นที่ความไม่เปลี่ยนแปลงสร้างโดยRed Hatโปรแกรม Ceylon ทำงานบนเครื่องเสมือน Java (JVM) และสามารถคอมไพล์เป็นJavaScript ได้[ ^{6 ] [ 7 ] การ} ออกแบบภาษาเน้นที่ ความสามารถในการ อ่านซอร์สโค้ด ความสามารถ ในการคาดการณ์ ความสามารถในการใช้เครื่องมือความเป็นโมดูลและความสามารถในการ เขียน โปรแกรมแบบเมตา^{[ 8 ]}

คุณลักษณะที่สำคัญของศรีลังกา ได้แก่: ^{[ 9 ]}

• ระบบประเภทข้อมูลที่บังคับใช้ความปลอดภัยของค่าว่างและการมีอยู่ขององค์ประกอบในรายการ ณ เวลาคอมไพล์
• ใช้ไวยากรณ์และความหมายตามปกติ หลีกเลี่ยงกรณีพิเศษและโครงสร้างที่กำหนดไว้อย่างจำเพาะเจาะจง โดยเน้นการใช้ไวยากรณ์ที่ ช่วยให้เขียนได้ง่ายขึ้น
• รองรับการเขียนโปรแกรมทั่วไปและการเขียนโปรแกรมแบบเมตา พร้อมด้วยเจเนริกที่เป็นรูปธรรม
• ความสามารถในการสร้างโมดูลาร์ในภาษา โดยอิงตามโมดูล JBossสามารถทำงานร่วมกับOSGi ^{[ 10 ]}และMaven ^{[ 11 ] ได้}
• เครื่องมือที่มีประสิทธิภาพ รวมถึง IDE ที่ใช้ Eclipse ^{[ 12 ]}

ชื่อ " ซีลอน" เป็นการอ้างอิงถึงเกาะชวาโดยอ้อม เนื่องจากเกาะชวาและศรีลังกาซึ่งเดิมชื่อซีลอน เป็นเกาะที่ขึ้นชื่อเรื่องการปลูกและส่งออกกาแฟและชา

ในเดือนสิงหาคม พ.ศ. 2560 ซีลอนถูกบริจาคให้กับมูลนิธิ Eclipseการพัฒนาชะลอตัวลงและหยุดลงในที่สุดในปี พ.ศ. 2563 ^{[ 13 ]}ในเดือนเมษายน พ.ศ. 2566 มูลนิธิ Eclipseประกาศยุติการเปลี่ยนผ่าน^{[ 14 ]}

ภาษาซีลอนได้รับอิทธิพลอย่างมากจาก ไวยากรณ์ของ ภาษาจาวาแต่ก็เพิ่มคุณสมบัติใหม่ๆ เข้ามามากมาย

หนึ่งในแง่มุมที่แปลกใหม่ที่สุดของ Ceylon เมื่อเทียบกับ Java คือระบบประเภท Ceylon ละทิ้งประเภทพื้นฐานของ Java ^{[ 15 ]}และการแปลงประเภทเป็นกล่อง (boxing)เพื่อใช้ระบบประเภทที่ประกอบด้วยวัตถุชั้นหนึ่งทั้งหมด แม้ว่าสิ่งนี้อาจทำให้เกิดภาระการแปลงประเภทเป็นกล่องในบางสถานการณ์ แต่ก็ทำให้ระบบประเภทมีความสม่ำเสมอมากขึ้น

Ceylon อนุญาตให้ใช้ประเภทการรวมและการตัดกันในลักษณะเดียวกับTypeScript , WhileyและFLOWซึ่งที่จริงแล้วได้นำแนวคิดมาจาก Ceylon

ประเภท Union ซึ่งเขียนแทนด้วย `unist` A|Bอนุญาตให้ตัวแปรมีประเภทได้มากกว่าหนึ่งประเภท ตัวอย่างต่อไปนี้แสดงฟังก์ชันในภาษา Ceylon ซึ่งอาจรับค่าเป็นจำนวนเต็มหรือสตริง ก็ได้ :

shared void integerOrString ( Integer | String input ) { if ( is Integer input ) { print ( "ได้รับจำนวนเต็ม ``input``" ); } else { print ( "ได้รับสตริง '``input``'" ); } }

ประเภทจุดตัด (Intersection types) ซึ่งเขียนแทนด้วยA&Bเป็นพื้นฐานทางทฤษฎีของการกำหนดประเภทตามการไหลของข้อมูล (flow-sensitive typing) :

shared void integerOrString ( Integer | String input ) { Integer added = input + 6 ; // ไม่ถูกต้อง ตัวดำเนินการ + ไม่ได้ถูกกำหนดไว้ใน Integer|Stringถ้า( input เป็นจำนวนเต็ม) { เพิ่มจำนวนเต็มเท่ากับinput + 6 ; // ถูกต้อง; ตอนนี้ทราบแล้วว่า input เป็นจำนวนเต็มพิมพ์( "ได้รับจำนวนเต็ม ``input``" ); } มิเช่นนั้น{ พิมพ์( "ได้รับสตริง '``input``'" ); } }

เงื่อนไขนี้is Integer inputจำกัดประเภทของinputให้เหลือเพียง<Integer|String> & Integerซึ่งกระจายไปยังInteger&Integer | String&Integerซึ่งเนื่องจากStringและIntegerเป็นประเภทที่ไม่ทับซ้อนกัน จึงเทียบเท่ากับInteger&Integer | Nothing( Nothingคือประเภทด้านล่างที่ว่างเปล่า) ซึ่งลดรูปเหลือIntegerเพียง

ประเภทการรวมและการตัดกันใช้เพื่อให้ความปลอดภัยจากค่าว่างประเภทสูงสุดของลำดับชั้นประเภทของซีลอนคือคลาสAnythingซึ่งมีคลาสย่อยสองคลาส ได้แก่ ซึ่งObjectเป็นคลาสแม่ของคลาสปกติทั้งหมดและอินเทอร์เฟซทั้งหมด และNullซึ่งมีอินสแตนซ์เดียวnullเนื่องจากObjectและNullเป็นประเภทที่ไม่เกี่ยวข้องกัน ประเภทปกติส่วนใหญ่ เช่นIntegerหรือList<String>จึงไม่สามารถเป็นค่าว่างได้ประเภทที่สามารถเป็นค่าว่างได้คือการรวมInteger|Nullซึ่งย่อInteger?ว่า^{[ 16 ]}

ประเภทจุดตัดสามารถใช้เพื่อรับประเภทที่ไม่เป็นตัวเลือกจากประเภทที่อาจเป็นตัวเลือกได้ เช่น พารามิเตอร์ประเภท ตัวอย่างเช่น ลายเซ็นของฟังก์ชันที่ลบnullองค์ประกอบออกจากสตรีมของค่าอาจเป็นดังนี้:

Iterable < Element & Object > removeNulls < Element >( Iterable < Element > stream );

เมื่อremoveNullsเรียกใช้เมธอดด้วยสตรีมของInteger|Nullองค์ประกอบ ผลลัพธ์ที่ได้จะเป็นสตรีมของ<Integer|Null> & Objectองค์ประกอบ ซึ่งสามารถลดรูปได้Integerเป็น

เช่นเดียวกับภาษาสมัยใหม่หลายภาษา Ceylon รองรับฟังก์ชันระดับเฟิร์สคลาสและฟังก์ชันลำดับสูงกว่ารวมถึงประเภทฟังก์ชันและฟังก์ชันนิรนาม^{[ 17 ]}

// ฟังก์ชันระดับสูงที่ใช้ไวยากรณ์แบบบล็อก (ไม่เกี่ยวข้องกับคลาสที่ผู้ใช้สร้างขึ้น) String process ( String text , String transformString ( String toChange )) { return transformString ( text ); }// ฟังก์ชันระดับบนสุดที่เรียกใช้ String.reverse ในรูปแบบนิพจน์String reverse ( String text ) => text . reversed ;// การอ้างอิงฟังก์ชันไปยัง String.reversed แต่โดยส่วนใหญ่เทียบเท่ากับฟังก์ชันด้านบนString ( String ) reverseFunctionReference = String . reversed ;// ตัวอย่างที่ฟังก์ชันระดับบนสุดด้านบนถูกส่งเป็นอาร์กิวเมนต์ให้กับฟังก์ชันลำดับสูงกว่าด้านบนString reversed1 = process ( "one" , reverse );// ตัวอย่างที่ฟังก์ชันนิรนาม - (text) => text+text - ถูกส่งไปยังฟังก์ชันลำดับสูงกว่าด้านบนString reversed2 = process ( "one" , ( text ) => text + text );

เช่นเดียวกับ Java และภาษาอื่นๆ อีกมากมาย และด้วยกลไกที่คล้ายกับประเภทพีชคณิต Ceylon รองรับประเภทแจงนับหรือที่รู้จักกันในชื่อ enum Ceylon ใช้รูปแบบการจำกัดอินสแตนซ์ของคลาสแบบนามธรรมเมื่อประกาศให้เป็นชุดของวัตถุที่จำกัด (ในกรณีนี้คืออินสแตนซ์แบบซิงเกิลตัน) อีกวิธีหนึ่งในการใช้รูปแบบนี้คือด้วยคุณสมบัติคอนสตรัคเตอร์ใหม่ใน Ceylon 1.2 ซึ่งวัตถุจะถูกนำไปใช้เป็นการประกาศคอนสตรัคเตอร์ที่มีชื่อแตกต่างกัน^{[ 18 ]}

// ไวยากรณ์แบบดั้งเดิมสำหรับประเภทแจงนับ ในกรณีนี้ จำกัดอินสแตนซ์ไว้ที่วัตถุสามชิ้น (เพื่อจุดประสงค์นี้: ซิงเกิลตัน) abstract class Vehicle ( shared String name ) of plane | train | automobile {}object plane extends Vehicle ( "plane" ) {} object train extends Vehicle ( "train" ) {} object automobile extends Vehicle ( "automobile" ) {} // ข้อผิดพลาดในการคอมไพล์: ประเภทไม่ใช่ซับไทป์ของซูเปอร์ไทป์แบบแจงนับใดๆ: 'boat' สืบทอดมาจาก 'Vehicle' //object boat extends Vehicle("boat") {}// ไวยากรณ์ใหม่ (ตั้งแต่ Ceylon 1.2.0) ที่ใช้คอนสตรัคเตอร์คลาส ยานพาหนะเครื่องบิน| รถไฟ| รถยนต์{ สตริงชื่อ;สร้างอ็อบเจ็กต์นามธรรมใหม่ชื่อ( String pName ) { name = pName ; }shared new plane extends named ( "plane" ) {} shared new train extends named ( "train" ) {} shared new automobile extends named ( "automobile" ) {} // ข้อผิดพลาดในการคอมไพล์: ตัวสร้างค่าไม่ปรากฏในเงื่อนไข of ของคลาสแจงนับที่ไม่ใช่แบบนามธรรม: 'boat' ไม่ได้อยู่ในเงื่อนไข of ของ 'Vehicle' //shared new boat extends named("boat") {} }

Ceylon เป็นภาษาที่มีการกำหนดประเภทข้อมูลอย่างเข้มงวดและคงที่ แต่ก็รองรับการอนุมานประเภทข้อมูล ด้วย เช่นกัน คำvalueหลัก `type` ใช้เพื่ออนุมานประเภทของตัวแปร และfunctionคำหลัก `type` ใช้เพื่ออนุมานประเภทของฟังก์ชัน คู่คำนิยามสองคู่ต่อไปนี้มีความเทียบเท่ากัน:

จำนวนเต็มi = 3 ; ค่าi = 3 ;ฟังก์ชันadd ( Integer i1 , Integer i2 ) { return i1 + i2 ; }​​​​​​​​​​​​​​​​

อย่างไรก็ตาม เพื่อให้การอนุมานประเภทแบบผ่านครั้งเดียวเป็นไปได้ การอนุมานประเภทจะอนุญาตเฉพาะสำหรับการประกาศที่ไม่ใช่ระดับสูงสุดและไม่ได้ใช้ร่วมกันเท่านั้น^{[ 19 ]}

โดยค่าเริ่มต้น ตัวเริ่มต้น ( ceylon run) จะเรียกใช้ฟังก์ชัน run() ที่ใช้ร่วมกันของโมดูล:

/* โปรแกรม Hello World แบบคลาสสิก */ shared void run () { print ( "Hello, World!" ); }

แต่ฟังก์ชันที่ใช้ร่วมกันอื่นๆ ที่ไม่มีพารามิเตอร์สามารถใช้เป็นฟังก์ชันหลักในการเรียกโปรแกรมด้วย พารามิเตอร์ runได้ดังนี้:

ceylon run --compile=force --run hello default

เวอร์ชันของซีลอนที่เผยแพร่: ^{[ 20 ]}

• M1 0.1 "นิวตัน" (20 ธันวาคม 2011)
• M2 0.2 "Minitel" (2 มีนาคม 2012)
• M3 0.3 "V2000" (21 มิ.ย. 2555)
• M3.1 0.3.1 "V2000" (6 ก.ค. 2555)
• M4 0.4 "เครื่องยนต์วิเคราะห์" (29 ตุลาคม 2555)
• M5 0.5 "เนสาพงษ์" (13 มี.ค. 2556)
• M6 0.6 "Virtual Boy" (23 กันยายน 2013)
• เวอร์ชันเบต้า 1.0 "Virtual Boy" (24 กันยายน 2013)
• 1.0.0 "ไม่มีอีกแล้วมิสเตอร์ไนซ์กาย" (13 พฤศจิกายน 2013)
• 1.1.0 "Ultimate Ship ภาคสอง" (9 ตุลาคม 2014)
• 1.2.0 "ชุดคำอธิบายที่ไม่น่าเป็นไปได้" (28 ตุลาคม 2558)
• 1.2.1 "วันสิ้นโลกที่ไม่ปกติ" (11 กุมภาพันธ์ 2016)
• 1.2.2 "มีเสน่ห์แต่ไร้เหตุผล" (11 มีนาคม 2016)
• 1.3.0 "การทบทวนตนเองอย่างรอบด้าน" (19 กันยายน 2559)
• 1.3.1 "มาลองทำตามวิธีของฉันกันเถอะ" (22 พฤศจิกายน 2016)
• 1.3.2 "ยิ้มอย่างมีน้ำใจ" (2 มีนาคม 2560)
• 1.3.3 "เนื้อหาอาจแตกต่างกันไป" (21 สิงหาคม 2560)

ทุกส่วนของซีลอนมีให้ใช้งานเป็นซอฟต์แวร์ฟรีโดยส่วนใหญ่อยู่ภายใต้ใบอนุญาต Apache ^{[ 21 ]}ส่วนหนึ่งของซอร์สโค้ดได้รับอนุญาตภายใต้ LGPL

• Dart (ภาษาโปรแกรม)มี VM ของตัวเอง คอมไพล์เป็น JavaScript ระบบประเภทข้อมูลไม่เข้มงวดมากนัก และรองรับmixins
• Fantom (ภาษาโปรแกรม)คอมไพล์ไปยัง JVM ระบบประเภทข้อมูลไม่เข้มงวดมากนัก รองรับmixins

• เว็บไซต์อย่างเป็นทางการ