อักษรลิ่ม
กระบวนทัศน์	ขั้นตอนการทำงาน เชิงวิทยาศาสตร์และ ใช้งานได้จริง
ออกแบบโดย	เยอร์เกน บรันด์ท
ปรากฏครั้งแรก	2013
เวอร์ชันเสถียร	3.0.4 / 19 พฤศจิกายน 2018 ( 19 พฤศจิกายน 2018 )
วินัยในการพิมพ์	ประเภทคงที่ และเรียบง่าย
ภาษาการใช้งาน	เออร์ลัง
โอเอส	ลินุกซ์ , แมคโอเอส
ใบอนุญาต	ใบอนุญาต Apache 2.0
นามสกุลไฟล์	.cfl
เว็บไซต์	cuniiform-lang .org
ได้รับอิทธิพลจาก
สวิฟต์ (ภาษาสคริปต์แบบขนาน)

Cuneiformเป็นภาษาเวิร์กโฟลว์แบบโอเพนซอร์ส สำหรับการวิเคราะห์ข้อมูลทางวิทยาศาสตร์ขนาดใหญ่^{[ 1 ] [ 2 ]} เป็นภาษาการเขียนโปรแกรมเชิงฟังก์ชันแบบกำหนดประเภทคงที่ที่ส่งเสริมการประมวลผลแบบขนาน มี อินเทอร์เฟซฟังก์ชันภายนอกที่หลากหลายทำให้ผู้ใช้สามารถผสานรวมซอฟต์แวร์จากภาษาการเขียนโปรแกรมภายนอกได้หลายภาษา ในระดับองค์กร Cuneiform มีสิ่งอำนวยความสะดวกต่างๆ เช่นการแตกสาขาแบบมีเงื่อนไขและการเรียกซ้ำทั่วไปทำให้เป็นภาษาที่สมบูรณ์แบบตามทฤษฎีของ Turingในแง่นี้ Cuneiform เป็นความพยายามที่จะปิดช่องว่างระหว่างระบบเวิร์กโฟลว์ทางวิทยาศาสตร์ เช่นTaverna , KNIMEหรือGalaxyและแบบจำลองการเขียนโปรแกรมการวิเคราะห์ข้อมูลขนาดใหญ่ เช่นMapReduceหรือPig Latinในขณะที่ยังคงรักษาความเป็นทั่วไปของภาษาการเขียนโปรแกรมเชิงฟังก์ชันไว้

Cuneiform ถูกนำไปใช้ในErlang แบบกระจาย หากทำงานในโหมดกระจาย จะขับเคลื่อน ระบบไฟล์แบบกระจายที่สอดคล้องกับ POSIXเช่นGlusterหรือCeph (หรือ การรวม FUSEของระบบไฟล์อื่นๆ เช่นHDFS ) หรืออีกทางหนึ่ง สคริปต์ Cuneiform สามารถทำงานบนHTCondorหรือHadoopได้^{[ 3 ] [ 4 ] [ 5 ] [ 6 ]}

อักษรคูนิฟอร์มได้รับอิทธิพลจากงานของปีเตอร์ เคลลี่ ผู้เสนอการเขียนโปรแกรมเชิงฟังก์ชันเป็นแบบจำลองสำหรับการดำเนินการเวิร์กโฟลว์ทางวิทยาศาสตร์^{[ 7 ] [ 8 ]} ในเรื่องนี้ อักษรคูนิฟอร์มมีความแตกต่างจากภาษาเวิร์กโฟลว์ที่เกี่ยวข้องซึ่งใช้การเขียนโปรแกรมแบบดาต้าโฟลว์เช่นสวิฟต์^{[ 9 ]}

เครื่องมือและไลบรารีภายนอก (เช่นไลบรารีRหรือPython ) จะถูกรวมเข้าด้วยกันผ่าน อินเทอร์เฟซฟังก์ชันภายนอกในลักษณะนี้จะคล้ายกับKNIMEซึ่งอนุญาตให้ใช้ซอฟต์แวร์ภายนอกผ่านโหนด snippet หรือTavernaซึ่งให้ บริการ BeanShellสำหรับการรวม ซอฟต์แวร์ Javaการกำหนดงานในภาษาต่างประเทศทำให้สามารถใช้ API ของเครื่องมือหรือไลบรารีภายนอกได้ ด้วยวิธีนี้ เครื่องมือต่างๆ สามารถรวมเข้าด้วยกันได้โดยตรงโดยไม่จำเป็นต้องเขียน wrapper หรือเขียนเครื่องมือขึ้นมาใหม่^{[ 10 ]}

ปัจจุบันภาษาโปรแกรมต่างประเทศที่รองรับมีดังนี้:

การรองรับภาษาต่างประเทศสำหรับAWKและgnuplotเป็นแผนที่จะเพิ่มเข้ามาในอนาคต

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

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

อักษรลิ่ม (Cuneiform) กำหนดให้เรคอร์ด (struct) เป็นชนิดข้อมูลแบบผสม ตัวอย่างด้านล่างแสดงการกำหนดตัวแปรให้rเป็นเรคอร์ดที่มีสองฟิลด์a1โดย ฟิลด์ a2แรกเป็นสตริงและฟิลด์ที่สองเป็นค่าบูลีน

let r : < a1 : Str , a2 : Bool > = < a1 = "my string" , a2 = true >;

สามารถเข้าถึงข้อมูลได้ทั้งผ่านการฉายภาพหรือผ่านการจับคู่รูปแบบ ตัวอย่างด้านล่างดึง ข้อมูล สองฟิลด์a1จากa2ข้อมูลr

let a1 : Str = ( r | a1 );let < a2 = a2 : Bool > = r ;

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

let xs : [ File ] = [ 'a.txt' , 'b.txt' , 'c.txt' : File ];

สามารถประมวลผลลิสต์ ได้ด้วยตัวดำเนินการ for และ fold โดยที่ตัวดำเนินการ for สามารถรับลิสต์หลายรายการเพื่อประมวลผลทีละองค์ประกอบได้ (คล้ายกับfor/listในRacket , mapcarCommon LispหรือzipwithErlang )

ตัวอย่างด้านล่างแสดงวิธีการแมปข้อมูลกับรายการเดียว โดยผลลัพธ์ที่ได้จะเป็นรายการไฟล์

สำหรับx <- xs ให้ประมวลผลทีละรายการ( arg1 = x ) : สิ้นสุดไฟล์;

ตัวอย่างด้านล่างแสดงวิธีการรวมลิสต์สองรายการเข้าด้วยกัน โดยผลลัพธ์ที่ได้จะเป็นลิสต์ไฟล์เช่นกัน

สำหรับx <- xs , y <- ys ให้ดำเนินการกับข้อมูลสองรายการ( arg1 = x , arg2 = y ) : สิ้นสุดไฟล์;

สุดท้ายนี้ เราสามารถรวมลิสต์ต่างๆ เข้าด้วยกันได้โดยใช้ตัวดำเนินการพับ (fold operator) ตัวอย่างต่อไปนี้เป็นการรวมค่าขององค์ประกอบในลิสต์

 พับ acc = 0, x <- xs ทำ add( a = acc, b = x ) จบ; 

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

ตัวอย่างเช่น โปรแกรมอักษรลิ่มต่อไปนี้อนุญาตให้แอปพลิเคชันfและgทำงานพร้อมกันได้ ในขณะที่hขึ้นอยู่กับและสามารถเริ่มต้นได้ก็ต่อเมื่อทั้งสองfเสร็จgสิ้นแล้ว เท่านั้น

let output-of-f : File = f(); let output-of-g : File = g(); h( f = ผลลัพธ์ของ f, g = ผลลัพธ์ของ g );

โปรแกรมอักษรลิ่มต่อไปนี้สร้างการประยุกต์ใช้ฟังก์ชันแบบขนานสามครั้งfโดยการแมปfกับรายการที่มีสามองค์ประกอบ:

ให้ xs : [ไฟล์] = ['a.txt', 'b.txt', 'c.txt' : ไฟล์]; สำหรับ x <- xs ทำ f( x = x )  : ไฟล์ จบ;

ในทำนองเดียวกัน แอปพลิเคชันของfและgเป็นอิสระต่อกันในการสร้างบันทึกrและสามารถดำเนินการพร้อมกันได้:

let r : < a : ไฟล์, b : ไฟล์> = & lt ; a = f (), b = g () & gt ;;

สคริปต์ "สวัสดีโลก":

def greet ( person : Str ) -> < out : Str > ในBash * { out = "Hello $person" } *( ทักทาย( บุคคล= "โลก" ) | ออก);

สคริปต์นี้กำหนดงานgreetในBashซึ่งจะเพิ่มสตริงนำหน้า"Hello "ให้กับอาร์กิวเมนต์ที่เป็นสตริง ฟังก์ชันpersonนี้สร้างเรคอร์ดที่มีฟิลด์สตริงเดียวoutการใช้greetฟังก์ชันนี้โดยการผูกอาร์กิวเมนต์personเข้ากับสตริง"world"จะสร้างเรคอร์ดขึ้น<out = "Hello world">มา การฉายเรคอร์ดนี้ไปยังฟิลด์ของมันoutจะประเมินค่าสตริง"Hello world"นั้น

สามารถผสานรวมเครื่องมือบรรทัดคำสั่งได้โดยการกำหนดงานในBash :

def samtoolsSort ( bam : File ) -> < sorted : File > in Bash * { sorted = sorted . bam samtools sort - m 2 G $bam - o $sorted } *

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

ในเดือนเมษายน 2559 ภาษาที่ใช้ในการพัฒนา Cuneiform เปลี่ยนจากJavaเป็นErlangและในเดือนกุมภาพันธ์ 2561 แพลตฟอร์มการประมวลผลแบบกระจายหลักได้เปลี่ยนจาก Hadoop เป็น Erlang แบบกระจาย นอกจากนี้ ตั้งแต่ปี 2558 ถึง 2561 HTCondorยังคงได้รับการดูแลรักษาในฐานะแพลตฟอร์มการประมวลผลทางเลือก อีกด้วย

โครงสร้างไวยากรณ์ของอักษรลิ่มได้รับการแก้ไขสองครั้ง ดังที่สะท้อนให้เห็นในหมายเลขเวอร์ชันหลัก

ในฉบับร่างแรกที่เผยแพร่ในเดือนพฤษภาคม 2014 อักษรลิ่ม (Cuneiform) มีความเกี่ยวข้องอย่างใกล้ชิดกับMakeตรงที่มันสร้าง กราฟ การพึ่งพาข้อมูล แบบคงที่ ซึ่งตัวแปลภาษาจะสำรวจระหว่างการทำงาน ความแตกต่างที่สำคัญจากเวอร์ชันต่อมาคือการไม่มีเงื่อนไข การเรียกซ้ำ หรือการตรวจสอบประเภทแบบคงที่ ไฟล์จะแตกต่างจากสตริงโดยการวางค่าสตริงที่อยู่ในเครื่องหมายคำพูดเดี่ยวไว้ข้างๆ เครื่องหมายทิลเด (~) ~นิพจน์คำสั่งค้นหาของสคริปต์เริ่มต้นด้วยtargetคำหลัก Bash เป็นภาษาต่างประเทศเริ่มต้นการเรียกใช้ฟังก์ชันต้องทำโดยใช้applyรูปแบบที่รับtaskเป็นอาร์กิวเมนต์คำหลักตัวแรก หนึ่งปีต่อมา ไวยากรณ์พื้นผิวนี้ถูกแทนที่ด้วยเวอร์ชันที่กระชับขึ้นแต่คล้ายคลึงกัน

สคริปต์ตัวอย่างต่อไปนี้จะดาวน์โหลดจีโนมอ้างอิงจากเซิร์ฟเวอร์ FTP

ประกาศดาวน์โหลดข้อมูลอ้างอิงจีโนม; deftask download-fa( fa : ~path ~id ) *{ wget $path/$id.fa.gz gunzip $id.fa.gz mv $id.fa $fa }* ref-genome-path = ~'ftp://hgdownload.cse.ucsc.edu/goldenPath/hg19/chromosomes'; ref-genome-id = ~'chr22'; ref-genome = apply( งาน: ดาวน์โหลด-fa เส้นทาง : เส้นทางอ้างอิงจีโนม รหัส : รหัสอ้างอิงจีโนม ); เป้าหมายอ้างอิงจีโนม; 

ร่างฉบับที่สองของไวยากรณ์พื้นผิวของอักษรลิ่ม ซึ่งเผยแพร่ครั้งแรกในเดือนมีนาคม 2015 ยังคงใช้งานอยู่เป็นเวลาสามปี โดยใช้งานได้นานกว่าการเปลี่ยนผ่านจาก Java ไปเป็น Erlang ในฐานะภาษาที่ใช้ในการเขียนโปรแกรมอักษรลิ่ม การประเมินผลแตกต่างจากวิธีการก่อนหน้านี้ตรงที่ตัวแปลภาษาจะลดรูปนิพจน์คำถามแทนที่จะสำรวจกราฟแบบคงที่ ในช่วงเวลาที่ไวยากรณ์พื้นผิวนี้ยังคงใช้งานอยู่ ตัวแปลภาษาได้รับการกำหนดรูปแบบและทำให้ง่ายขึ้น ซึ่งส่งผลให้เกิดข้อกำหนดแรกของความหมายของอักษรลิ่ม ไวยากรณ์นี้มีเงื่อนไข อย่างไรก็ตาม ค่าบูลีนถูกเข้ารหัสเป็นรายการ โดยใช้รายการว่างเป็นค่าบูลีนเท็จ และรายการที่ไม่ว่างเป็นค่าบูลีนจริง การเรียกซ้ำถูกเพิ่มเข้ามาในภายหลังเป็นผลพลอยได้จากการกำหนดรูปแบบ อย่างไรก็ตาม การตรวจสอบประเภทแบบคงที่ถูกนำมาใช้ในเวอร์ชัน 3 เท่านั้น

สคริปต์ต่อไปนี้จะคลายไฟล์ที่ถูกบีบอัดด้วยซิปและแบ่งไฟล์นั้นออกเป็นส่วนๆ ที่มีขนาดเท่ากัน

deftask unzip( <out( File )> : zip( File ) ) in bash *{ unzip -d dir $zip out=`ls dir | awk '{print "dir/" $0}'` }* deftask split( <out( File )> : file( File ) ) in bash *{ split -l 1024 $file txt เอาต์พุต=txt* }* sotu = "sotu/stateoftheunion1790-2014.txt.zip"; fileLst = split( file: unzip( zip: sotu ) ); ไฟล์Lst; 

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

สคริปต์ต่อไปนี้จะแตกไฟล์และแสดงรายการไฟล์

def untar( tar : File ) -> <fileLst : [File]> ใน Bash *{ tar xf $tar fileLst=`tar tf $tar` }* let hg38Tar : File = 'hg38/hg38.tar'; ให้ <fileLst = faLst : [ไฟล์]> = untar( tar = hg38Tar ); ฟาลสต์;