การแปลซอร์สโค้ดจาก Haskell โดยใช้ AI เกี่ยวข้องกับการใช้เทคนิคการประมวลผลภาษาธรรมชาติ (NLP) และอัลกอริธึมการเรียนรู้ของเครื่องเพื่อวิเคราะห์และทำความเข้าใจซอร์สโค้ด
| ปัญหาการแปล | ตัวอย่างไวยากรณ์ Haskell | ตัวอย่างไวยากรณ์ TypeScript | คะแนน (1-10) |
|---|---|---|---|
| การอนุมานประเภท | let x = 5 |
let x: number = 5; |
6 |
| ฟังก์ชันระดับสูง | map (+1) [1, 2, 3] |
[1, 2, 3].map(x => x + 1); |
5 |
| การประเมินแบบขี้เกียจ | take 5 (repeat 1) |
const takeFive = () => Array(5).fill(1); |
7 |
| ประเภทข้อมูลเชิงพีชคณิต | data Maybe a = Nothing | Just a |
type Maybe<T> = T | null; |
4 |
| การจับคู่รูปแบบ | case x of Just v -> v; Nothing -> 0 |
if (x !== null) { return x; } else { return 0; } |
5 |
| มอนาดและผลกระทบ | do { x <- action; return (x + 1) } |
async function example() { const x = await action(); return x + 1; } |
8 |
| คลาสประเภท | class Eq a where (==) :: a -> a -> Bool |
interface Eq<T> { equals(other: T): boolean; } |
6 |
| พารามิเตอร์ที่ไม่ชัดเจน | foo x = bar x |
function foo(x: Type) { return bar(x); } |
5 |
| ประเภทระดับหนึ่ง | let f = \x -> x |
let f = (x: Type) => x; |
6 |
| GADTs | data Expr a where |
type Expr<T> = { ... }; |
7 |
Haskell มีระบบการอนุมานประเภทที่ทรงพลังซึ่งช่วยให้เขียนโค้ดได้กระชับโดยไม่ต้องมีการระบุประเภทอย่างชัดเจน ใน TypeScript แม้ว่าจะมีการอนุมานประเภท แต่บ่อยครั้งจะต้องมีการระบุประเภทอย่างชัดเจนเพื่อความชัดเจน
ตัวอย่าง Haskell:
let x = 5
ตัวอย่าง TypeScript:
let x: number = 5;
ทั้งสองภาษาให้การสนับสนุนฟังก์ชันระดับสูง แต่ไวยากรณ์แตกต่างกันอย่างมาก ไวยากรณ์ของ Haskell จะกระชับกว่า
ตัวอย่าง Haskell:
map (+1) [1, 2, 3]
ตัวอย่าง TypeScript:
[1, 2, 3].map(x => x + 1);
เอกสารฟังก์ชันระดับสูง Haskell
การประเมินแบบขี้เกียจของ Haskell ช่วยให้สามารถสร้างโครงสร้างข้อมูลที่ไม่มีที่สิ้นสุด ซึ่งไม่สามารถทำได้โดยตรงใน TypeScript
ตัวอย่าง Haskell:
take 5 (repeat 1)
ตัวอย่าง TypeScript:
const takeFive = () => Array(5).fill(1);
เอกสารการประเมินแบบขี้เกียจ Haskell
ประเภทข้อมูลเชิงพีชคณิตของ Haskell ให้วิธีการกำหนดประเภทที่ซับซ้อนได้อย่างกระชับ ในขณะที่ TypeScript ใช้ประเภทรวม
ตัวอย่าง Haskell:
data Maybe a = Nothing | Just a
ตัวอย่าง TypeScript:
type Maybe<T> = T | null;
เอกสารประเภทข้อมูลเชิงพีชคณิต Haskell
การจับคู่รูปแบบใน Haskell มีความสามารถในการแสดงออกและกระชับมากกว่าคำสั่งเงื่อนไขใน TypeScript
ตัวอย่าง Haskell:
case x of Just v -> v; Nothing -> 0
ตัวอย่าง TypeScript:
if (x !== null) { return x; } else { return 0; }
มอนาดใน Haskell ให้วิธีการจัดการผลกระทบข้างเคียง ในขณะที่ TypeScript ใช้ async/await เพื่อวัตถุประสงค์ที่คล้ายกัน
ตัวอย่าง Haskell:
do { x <- action; return (x + 1) }
ตัวอย่าง TypeScript:
async function example() {
const x = await action();
return x + 1;
}
คลาสประเภทใน Haskell อนุญาตให้มีพหุนิยม ในขณะที่ TypeScript ใช้ส่วนติดต่อ
ตัวอย่าง Haskell:
class Eq a where (==) :: a -> a -> Bool
ตัวอย่าง TypeScript:
interface Eq<T> { equals(other: T): boolean; }
Haskell อนุญาตให้มีพารามิเตอร์ที่ไม่ชัดเจน ซึ่งไม่ได้รับการสนับสนุนโดยตรงใน TypeScript
ตัวอย่าง Haskell:
foo x = bar x
ตัวอย่าง TypeScript:
function foo(x: Type) { return bar(x); }
เอกสารพารามิเตอร์ที่ไม่ชัดเจน Haskell
Haskell ถือว่าฟังก์ชันเป็นพลเมืองระดับหนึ่ง ในขณะที่ TypeScript ใช้ฟังก์ชันลูกศร
ตัวอย่าง Haskell:
let f = \x -> x
ตัวอย่าง TypeScript:
let f = (x: Type) => x;
เอกสารฟังก์ชันระดับหนึ่ง Haskell
ประเภทข้อมูลเชิงพีชคณิตทั่วไป (GADTs) ใน Haskell อนุญาตให้มีการกำหนดประเภทที่แสดงออกได้มากขึ้นเมื่อเปรียบเทียบกับอัลลายประเภทใน TypeScript
ตัวอย่าง Haskell:
data Expr a where
ตัวอย่าง TypeScript:
type Expr<T> = { ... };