# Five Language Syntax Reference

Five = Harbour 100% 호환 + Go 확장 문법.
기존 PRG 코드 수정 없이 실행되고, Go의 강력한 기능을 PRG 문법으로 사용.

## Harbour 호환 문법 (98% 파싱)

기존 Harbour/Clipper/xBase 문법 전체 지원:

```prg
FUNCTION, PROCEDURE, RETURN, LOCAL, STATIC, PRIVATE, PUBLIC
IF/ELSEIF/ELSE/ENDIF, DO CASE/CASE/OTHERWISE/ENDCASE
FOR/NEXT, FOR EACH/NEXT, DO WHILE/ENDDO
BEGIN SEQUENCE/RECOVER/END, SWITCH/CASE/ENDSWITCH
CLASS/DATA/METHOD/ACCESS/ASSIGN/ENDCLASS
USE, SELECT, SEEK, SKIP, GO, APPEND, REPLACE, DELETE, PACK
@ SAY/GET/READ, MENU TO, SET, INDEX ON
```

## Five Go 확장 문법

### 1. IMPORT — Go 패키지 직접 사용

```prg
IMPORT "strings"                    // Go 표준 라이브러리
IMPORT "database/sql"               // SQL 데이터베이스
IMPORT _ "modernc.org/sqlite"       // blank import (드라이버)
IMPORT myhttp "net/http"            // 별칭 import
```

IMPORT하면 PRG에서 바로 사용:

```prg
IMPORT "strings"

PROCEDURE Main()
   LOCAL cResult
   cResult := strings.ToUpper("hello five")     // Go 함수 직접 호출
   ? strings.Contains(cResult, "FIVE")           // .T.
   ? strings.Split("a,b,c", ",")                 // {"a","b","c"}
   RETURN
```

**#pragma BEGINDUMP 불필요. IMPORT만으로 Go 전체 생태계 접근.**

### 2. Multi-Return — 다중 반환값

```prg
// 함수에서 여러 값 반환
FUNCTION GetUserInfo()
   RETURN "Charles", 30, "Seoul"

// 받는 쪽
cName, nAge, cCity := GetUserInfo()

// 불필요한 값 무시
_, nAge, _ := GetUserInfo()
```

Go의 `(val, error)` 패턴 자연스럽게 지원:

```prg
IMPORT "database/sql"
db, err := sql.Open("sqlite", ":memory:")
IF err != NIL
   ? "Error:", err
ENDIF
```

### 3. DEFER — 자동 정리

함수가 끝날 때 자동 실행. 에러가 나도 보장.

```prg
PROCEDURE ProcessFile(cPath)
   LOCAL db
   db := sql.Open("sqlite", cPath)
   DEFER db:Close()                  // 함수 끝나면 자동 Close

   db:Exec("INSERT ...")             // 여기서 에러 나도
   db:Exec("UPDATE ...")             // db:Close()는 반드시 실행
   RETURN                            // ← 여기서 DEFER 실행
```

Harbour의 `BEGIN SEQUENCE/RECOVER`보다 간결:

```
Before (Harbour):                    After (Five):
───────────────────────────────      ─────────────────────
BEGIN SEQUENCE                       db := SqlOpen(...)
   db := SqlOpen(...)                DEFER db:Close()
   db:Exec(...)                      db:Exec(...)
RECOVER                              RETURN
   db:Close()
END SEQUENCE
db:Close()
```

### 4. Slice — 부분 배열/문자열

```prg
LOCAL aData := {"a", "b", "c", "d", "e"}

aSub := aData[2:4]          // {"b", "c", "d"}
aSub := aData[3:]           // {"c", "d", "e"}  (3번부터 끝까지)
aSub := aData[:2]           // {"a", "b"}        (처음부터 2번까지)
```

Harbour의 반복 루프 대체:

```
Before:                              After:
───────────────────────────────      ─────────────────────
LOCAL aSub := {}                     aSub := aData[3:7]
FOR i := 3 TO 7
   AAdd(aSub, aData[i])
NEXT
```

### 5. Parallel Assignment — 동시 할당

```prg
// 값 교환 (swap)
a, b := b, a                // temp 변수 불필요!

// 동시 초기화
x, y, z := 1, 2, 3
```

### 6. Nil-Safe Operator — `?:`

```prg
// 기존: NIL 체크 반복
IF oCustomer != NIL
   IF oCustomer:Address != NIL
      ? oCustomer:Address:City
   ENDIF
ENDIF

// Five: 한 줄로
? oCustomer?:Address?:City           // NIL이면 NIL 반환, 에러 없음
```

### 7. String Interpolation — `f"..."`

```prg
LOCAL cName := "Charles", nAge := 30

// 기존
? "Name: " + cName + " Age: " + Str(nAge)

// Five
? f"Name: {cName}, Age: {nAge}"

// 포맷 지정
? f"Price: {nPrice:.2f}, Count: {nCount:05d}"
```

### 8. CONST Block — 상수/열거형

```prg
CONST
   STATUS_ACTIVE  := 1
   STATUS_CLOSED  := 2
   STATUS_PENDING := 3
END CONST
```

### 9. SWITCH (Harbour 호환 + 확장)

```prg
// 기존 Harbour 문법 그대로 동작
SWITCH nStatus
CASE 1
   ? "Active"
CASE 2
   ? "Closed"
OTHERWISE
   ? "Unknown"
ENDSWITCH
```

## Five 동시성 문법

### 10. 채널 연산자 — `<-`

```prg
ch := Channel()

ch <- "hello"                // 채널로 전송 (send)
msg := <- ch                 // 채널에서 수신 (receive)
```

Harbour 함수 vs Five 연산자:

```
Harbour 함수:                        Five 연산자:
───────────────────────────────      ─────────────────────
ChSend(ch, "hello")                  ch <- "hello"
msg := ChReceive(ch)                 msg := <- ch
ChSend(chOut, nResult)               chOut <- nResult
```

### 11. SPAWN / LAUNCH / GOROUTINE — 인라인 goroutine

```prg
// 3가지 키워드, 같은 동작
SPAWN     {|| DoHeavyWork() }
LAUNCH    {|| ProcessData() }
GOROUTINE {|| SendNotification() }
```

### 12. WATCH — 채널 멀티플렉싱 (Go select)

여러 채널을 동시 감시, 먼저 준비된 채널 처리:

```prg
WATCH
CASE msg := <- chMessages            // 메시지 도착
   ? "Message:", msg
CASE result := <- chResults          // 결과 도착
   ? "Result:", result
CASE <- chTimeout                    // 타임아웃
   ? "Timeout!"
OTHERWISE                            // 아무 채널도 준비 안 됨
   ? "No channel ready"
END WATCH
```

**실전 패턴: 가장 빠른 서버 응답 선택**

```prg
SPAWN {|| DelayAndSend(0.1, chFast, "Fast Server") }
SPAWN {|| DelayAndSend(2.0, chSlow, "Slow Server") }
SPAWN {|| DelayAndSend(3.0, chTimeout, "TIMEOUT") }

WATCH
CASE cResult := <- chFast
   ? "Winner:", cResult              // ← 100ms로 가장 빨라서 선택됨
CASE cResult := <- chSlow
   ? "Winner:", cResult
CASE <- chTimeout
   ? "Timeout!"
END WATCH
```

### 13. PARALLEL FOR — 병렬 루프

```prg
// 10만 건을 CPU 코어 수만큼 병렬 처리
PARALLEL FOR i := 1 TO 100000
   aResult[i] := ProcessItem(aData[i])
NEXT
// 자동으로 모든 goroutine 완료 대기
```

### 14. ASYNC / AWAIT — 비동기 실행

```prg
// 무거운 작업을 백그라운드에서 시작
future := ASYNC HeavyQuery("SELECT * FROM big_table")

// 다른 작업 수행 (비동기)
? "Loading..."
PrepareUI()

// 결과 대기
aRows := AWAIT future
? "Got", Len(aRows), "rows"
```

### 15. WITH TIMEOUT — 타임아웃 컨텍스트

```prg
// 3초 안에 완료되지 않으면 자동 취소
WITH TIMEOUT 3
   result := SlowNetworkCall()
END

IF result == NIL
   ? "Timeout!"
ENDIF
```

## Go 객체 직접 조작

### `pkg.Func()` — 패키지 함수 호출

```prg
IMPORT "strings"
IMPORT "math"
IMPORT "fmt"

? strings.ToUpper("hello")          // "HELLO"
? math.Sqrt(144)                     // 12
? fmt.Sprintf("%.2f", 3.14159)       // "3.14"
```

### `obj:Method()` — Go 객체 메서드 호출

```prg
IMPORT "database/sql"

db := sql.Open("sqlite", ":memory:")
db:Exec("CREATE TABLE test (id INTEGER)")
rows := db:Query("SELECT * FROM test")
DO WHILE rows:Next()
   ? rows:Column(1)
END
rows:Close()
db:Close()
```

### 여러 Go 객체 동시 사용

```prg
dbSource := sql.Open("sqlite", "source.db")
dbTarget := sql.Open("sqlite", "target.db")

aRows := SqlScan(dbSource, "SELECT * FROM products")
FOR i := 1 TO Len(aRows)
   dbTarget:Exec("INSERT INTO inventory VALUES (...)")
NEXT

dbSource:Close()
dbTarget:Close()
```

## Five vs 경쟁 언어

### xBase 계열 비교

| 기능 | Harbour | xHarbour | FiveWin | **Five** |
|------|---------|----------|---------|----------|
| DBF/NTX/CDX | ✅ | ✅ | ✅ | ✅ |
| SQL Database | ❌ | 제한적 | ODBC | ✅ **모든 Go DB** |
| HTTP Server | ❌ | ❌ | ❌ | ✅ **net/http** |
| WebSocket | ❌ | ❌ | ❌ | ✅ |
| Goroutine | ❌ | ❌ | ❌ | ✅ **네이티브** |
| Channel | ❌ | ❌ | ❌ | ✅ `<-` 연산자 |
| JSON | 제한적 | 제한적 | 제한적 | ✅ **Go encoding/json** |
| 크로스플랫폼 | △ | △ | Windows | ✅ **Linux/Mac/Windows** |
| 패키지 생태계 | C lib | C lib | C lib | ✅ **Go 전체** |

### 다른 트랜스파일러 비교

| 기능 | TypeScript→JS | Kotlin→JVM | **Five (PRG→Go)** |
|------|---------------|------------|---------------------|
| 타입 시스템 | 정적→동적 | 정적→정적 | 동적→정적 |
| 동시성 | async/await | coroutine | **goroutine+channel** |
| 외부 패키지 | npm | Maven | **Go modules** |
| 컴파일 결과 | JS 코드 | bytecode | **네이티브 바이너리** |
| 인터롭 | JS 직접 | Java 직접 | **Go 직접 (IMPORT)** |
| 성능 | V8 런타임 | JVM 런타임 | **네이티브 속도** |

### Five만의 차별점

1. **IMPORT만으로 Go 생태계 전체 접근** — #pragma BEGINDUMP 불필요
2. **네이티브 바이너리** — JVM, V8 없이 단일 실행 파일
3. **goroutine + channel + WATCH** — PRG 문법으로 Go 동시성 100%
4. **xBase 100% 호환** — 기존 DBF/NTX/CDX 코드 그대로 실행
5. **FastPath 최적화** — Go 함수 호출이 native의 2x 이내 성능
6. **DEFER** — 리소스 안전 관리, BEGIN SEQUENCE보다 간결
7. **Multi-Return** — `a, b := Func()`, Go의 (val, error) 패턴
8. **f-string** — 문자열 보간, `f"Hello {name}"`
9. **PARALLEL FOR** — 대량 데이터 자동 병렬 처리
10. **Nil-safe `?:`** — 안전한 체이닝, 런타임 에러 방지

## 예제 파일

| 파일 | 설명 |
|------|------|
| `examples/go_native.prg` | IMPORT만으로 Go 패키지 직접 사용 |
| `examples/go_strings.prg` | strings 패키지 전체 활용 |
| `examples/go_typetest.prg` | 18가지 타입 변환 테스트 |
| `examples/go_dual_db.prg` | 두 SQLite DB 동시 사용 |
| `examples/go_channel.prg` | 채널 연산자 + WATCH + Pipeline |
| `examples/go_httpserver.prg` | REST API 서버 |
| `examples/go_concurrent.prg` | 병렬 데이터 파이프라인 |
| `examples/go_websocket.prg` | WebSocket 채팅 서버 |
| `examples/go_extensions.prg` | 9가지 확장 문법 데모 |
| `examples/godump_demo.prg` | HB_FUNC Go API |