kimchilang 1.0.1

package/examples/myapp/lib/http.js

@@ -0,0 +1,14 @@
+export default function(_overrides = {}) {
+  function get(url) {
+    console.log(("HTTP GET: " + url));
+    return { status: 200, data: ("response from " + url) };
+  }
+  
+  function post(url, body) {
+    console.log(("HTTP POST: " + url));
+    return { status: 201, data: "created" };
+  }
+  
+  
+  return { get, post };
+}

package/examples/myapp/lib/http.km

@@ -0,0 +1,16 @@
+// HTTP client library - a low-level dependency with configurable timeout
+
+arg timeout = 30000
+arg baseUrl = ""
+
+expose fn get(url) {
+  dec fullUrl = baseUrl + url
+  print "HTTP GET: " + fullUrl + " (timeout: " + timeout + "ms)"
+  return { status: 200, data: "response from " + fullUrl }
+}
+
+expose fn post(url, body) {
+  dec fullUrl = baseUrl + url
+  print "HTTP POST: " + fullUrl + " (timeout: " + timeout + "ms)"
+  return { status: 201, data: "created" }
+}

package/examples/myapp/main.km

@@ -0,0 +1,16 @@
+// Main application - depends on the API service
+// Must provide the required apiKey arg
+
+as api dep myapp.services.api({ apiKey: "prod-key-abc123" })
+
+fn main() {
+  print "=== Fetching users ==="
+  dec users = api.fetchUsers()
+  print users
+  
+  print "=== Creating user ==="
+  dec result = api.createUser("Alice")
+  print result
+}
+
+main()

package/examples/myapp/main_with_mock.km

@@ -0,0 +1,42 @@
+// Main application with dependency injection - injects a mock HTTP client
+// Also demonstrates passing both deps and args together
+
+// Define a mock HTTP client for testing
+fn mockGet(url) {
+  print "MOCK GET: " + url
+  return { status: 200, data: "mock data" }
+}
+
+fn mockPost(url, body) {
+  print "MOCK POST: " + url
+  return { status: 201, data: "mock created" }
+}
+
+dec mockHttp = {
+  get: mockGet,
+  post: mockPost
+}
+
+// Import API service with:
+// - Mock HTTP client injected (dep override)
+// - Required apiKey arg provided
+// - Custom version arg provided
+as api dep myapp.services.api({
+  "myapp.lib.http": mockHttp,
+  apiKey: "test-key-xyz789",
+  version: "v2"
+})
+
+fn main() {
+  print "=== Testing with Mock HTTP ==="
+  
+  print "Fetching users (mocked):"
+  dec users = api.fetchUsers()
+  print users
+  
+  print "Creating user (mocked):"
+  dec result = api.createUser("Bob")
+  print result
+}
+
+main()

package/examples/myapp/services/api.js

@@ -0,0 +1,18 @@
+import _dep_http from './myapp/lib/http.km';
+
+export default function(_overrides = {}) {
+  const http = _overrides["myapp.lib.http"] || _dep_http();
+  
+  function fetchUsers() {
+    let response = http.get("https://api.example.com/users");
+    return response.data;
+  }
+  
+  function createUser(name) {
+    let response = http.post("https://api.example.com/users", { name });
+    return response.data;
+  }
+  
+  
+  return { fetchUsers, createUser };
+}

package/examples/myapp/services/api.km

@@ -0,0 +1,18 @@
+// API service - depends on the HTTP library with required API key
+
+as http dep myapp.lib.http({ baseUrl: "https://api.example.com" })
+
+!arg apiKey
+arg version = "v1"
+
+expose fn fetchUsers() {
+  print "Using API key: " + apiKey + " (version: " + version + ")"
+  dec response = http.get("/" + version + "/users")
+  return response.data
+}
+
+expose fn createUser(name) {
+  print "Using API key: " + apiKey
+  dec response = http.post("/" + version + "/users", { name: name })
+  return response.data
+}

package/examples/new_features.kimchi

@@ -0,0 +1,52 @@
+// Test file for new features: String Interpolation and Pipe Operator
+
+// ===== String Interpolation =====
+dec name = "Alice"
+dec age = 30
+
+print "Hello, ${name}!"
+print "${name} is ${age} years old"
+
+// Expressions in interpolation
+dec items = [1, 2, 3, 4, 5]
+print "Count: ${items.length}"
+print "Sum: ${items.sum()}"
+
+// Nested object access
+dec user = { name: "Bob", score: 95 }
+print "${user.name} scored ${user.score}%"
+
+// ===== Pipe Operator (~>) =====
+fn double(x) { return x * 2 }
+fn addOne(x) { return x + 1 }
+fn square(x) { return x * x }
+
+// Basic pipe chain - passes value through functions left to right
+dec result = 5 ~> double ~> addOne ~> square
+print "5 ~> double ~> addOne ~> square = ${result}"
+
+// Pipe with array operations
+fn sumArray(arr) { return arr.sum() }
+fn doubleAll(arr) { return arr.map(x => x * 2) }
+fn filterBig(arr) { return arr.filter(x => x > 5) }
+
+dec numbers = [1, 2, 3, 4, 5]
+dec processed = numbers ~> doubleAll ~> filterBig ~> sumArray
+print "Processed array result: ${processed}"
+
+// Combining both features
+dec message = "The answer is ${5 ~> double ~> addOne}"
+print message
+
+// ===== Flow Operator (>>) =====
+// Creates a composed function that can be called later
+dec transform >> double addOne square
+
+// Now call the composed function
+dec flowResult = transform(5)
+print "transform(5) = ${flowResult}"
+
+// Another example with array functions
+processArray >> doubleAll filterBig sumArray
+dec flowArrayResult = processArray(numbers)
+print "processArray([1,2,3,4,5]) = ${flowArrayResult}"

package/examples/project_example.static

@@ -0,0 +1,20 @@
+// Example project.static file
+// Declares external dependencies for a KimchiLang project
+
+// Project metadata
+name "my-awesome-app"
+version "1.0.0"
+description "An example KimchiLang application"
+
+// External dependencies from GitHub
+// Each dependency is a GitHub URL
+depend [
+  "github.com/kimchilang/stdlib",
+  "github.com/kimchilang/http-client@v1.0.0"
+]
+
+// Project configuration
+config {
+  debug = false
+  logLevel = "info"
+}

package/examples/readme_examples.km

@@ -0,0 +1,240 @@
+// README Examples Validation File
+// This file tests all KimchiLang code examples from the README
+
+// === Quick Start ===
+print "Hello, KimchiLang!"
+
+fn greet(name) {
+  return "Welcome, " + name + "!"
+}
+
+print greet("Developer")
+
+// === Variables ===
+dec name = "Alice"
+dec PI = 3.14159
+dec config = {
+  api: {
+    url: "https://api.example.com",
+    timeout: 5000
+  }
+}
+
+// Destructuring
+dec person = { name: "Alice", age: 30, city: "NYC" }
+dec { name: personName, age } = person
+
+// Array destructuring
+dec numbers = [1, 2, 3, 4, 5]
+dec [first, second, third] = numbers
+
+// === Module Visibility ===
+dec internalConfig = { secret: "hidden" }
+fn helperFn() { return "internal" }
+
+expose dec API_VERSION = "1.0"
+expose fn greetExposed(n) { return "Hello, " + n }
+
+// === Functions ===
+expose fn add(a, b) {
+  return a + b
+}
+
+// Default parameters
+fn greetDefault(n = "World") {
+  return "Hello, " + n
+}
+
+print greetDefault()
+print greetDefault("Alice")
+
+// Rest parameters
+fn sum(...nums) {
+  return nums.reduce((acc, n) => acc + n, 0)
+}
+
+print sum(1, 2, 3, 4, 5)
+
+// Combined
+fn log(prefix, separator = ": ", ...messages) {
+  return prefix + separator + messages.join(", ")
+}
+
+// === Enums ===
+enum Color {
+  Red,
+  Green,
+  Blue
+}
+
+print Color.Red
+print Color.Green
+
+enum HttpStatus {
+  OK = 200,
+  NotFound = 404,
+  ServerError = 500
+}
+
+enum Priority {
+  Low,
+  Medium,
+  High = 10,
+  Critical
+}
+
+fn getStatusMessage(status) {
+  |status == HttpStatus.OK| => { return "Success" }
+  |status == HttpStatus.NotFound| => { return "Not Found" }
+  |true| => { return "Unknown" }
+}
+
+print getStatusMessage(200)
+
+// === Arrow Functions ===
+dec double = x => x * 2
+dec addArrow = (a, b) => a + b
+
+dec process = (x) => {
+  dec result = x * 2
+  return result + 1
+}
+
+dec numbersArr = [1, 2, 3, 4, 5]
+dec doubled = numbersArr.map(x => x * 2)
+dec sumArr = numbersArr.reduce((acc, n) => acc + n, 0)
+
+// === Control Flow ===
+dec score = 85
+if score >= 90 {
+  print "A"
+} elif score >= 80 {
+  print "B"
+} else {
+  print "C"
+}
+
+// For loop
+dec items = ["a", "b", "c"]
+for item in items {
+  print item
+}
+
+// Range expressions
+for i in 0..5 {
+  print i
+}
+
+// === Flow Operator ===
+fn addOne(x) { return x + 1 }
+fn doubleNum(x) { return x * 2 }
+fn square(x) { return x * x }
+
+transform >> addOne doubleNum square
+dec flowResult = transform(5)
+print "Flow result: ${flowResult}"
+
+// === Pattern Matching ===
+fn handleStatus(status) {
+  |status == 200| => { print "OK" }
+  |status == 404| => { print "Not Found" }
+  |status == 500| => { print "Server Error" }
+  |true| => { print "Unknown" }
+}
+
+handleStatus(200)
+
+// === Arrays & Objects ===
+dec nums = [1, 2, 3, 4, 5]
+dec personObj = {
+  name: "Bob",
+  age: 30
+}
+
+dec more = [...nums, 6, 7, 8]
+dec updated = { ...personObj, age: 31 }
+
+// === Safe Member Access ===
+dec obj = { a: { b: { c: 1 } } }
+print obj.a.b.c
+
+// === String Interpolation ===
+dec userName = "Alice"
+dec userAge = 30
+
+print "Hello, ${userName}!"
+print "${userName} is ${userAge} years old"
+
+dec itemsCount = [1, 2, 3]
+print "Count: ${itemsCount.length}"
+
+// === Pipe Operator ===
+dec pipeResult1 = square(addOne(doubleNum(5)))
+dec pipeResult2 = 5 ~> doubleNum ~> addOne ~> square
+print "Pipe result: ${pipeResult2}"
+
+// === Memoized Functions ===
+memo fib(n) {
+  |n <= 1| => { return n }
+  |true| => { return fib(n - 1) + fib(n - 2) }
+}
+
+print "fib(10) = ${fib(10)}"
+
+// === Error Handling ===
+dec NotFoundError = error.create("NotFoundError")
+dec ValidationError = error.create("ValidationError")
+
+fn fetchUser(id) {
+  if id == 0 {
+    throw NotFoundError("User ${id} not found")
+  }
+  return { id: id, name: "Alice" }
+}
+
+fn handleRequest(id) {
+  try {
+    return fetchUser(id)
+  } catch(e) {
+    |e is NotFoundError| => {
+      print "Not found: ${e.message}"
+      return null
+    }
+    |e is ValidationError| => {
+      print "Invalid: ${e.message}"
+      return null
+    }
+    |true| => {
+      throw e
+    }
+  }
+}
+
+dec user = handleRequest(1)
+print "User: ${user.name}"
+
+// === JavaScript Interop ===
+js {
+  console.log("Hello from raw JavaScript!");
+}
+
+dec jsName = "Alice"
+dec jsCount = 5
+
+js(jsName, jsCount) {
+  const greeting = `Hello, ${jsName}! Count: ${jsCount}`;
+  console.log(greeting);
+}
+
+dec jsNumbers = [1, 2, 3, 4, 5]
+dec jsSum = js(jsNumbers) {
+  return jsNumbers.reduce((a, b) => a + b, 0);
+}
+print "JS Sum: ${jsSum}"
+
+dec timestamp = js {
+  return Date.now();
+}
+print "Timestamp: ${timestamp}"
+
+print "All README examples validated successfully!"

package/examples/reduce_pattern_match.km

@@ -0,0 +1,85 @@
+// Pattern matching in Array.reduce callback
+// Demonstrates using pattern matching to categorize and accumulate values
+
+dec transactions = [
+  { type: "credit", amount: 100 },
+  { type: "debit", amount: 50 },
+  { type: "credit", amount: 200 },
+  { type: "debit", amount: 75 },
+  { type: "refund", amount: 25 }
+]
+
+// Define reducer function with pattern matching
+fn transactionReducer(acc, tx) {
+  |tx.type == "credit"| => {
+    return acc + tx.amount
+  }
+  |tx.type == "debit"| => {
+    return acc - tx.amount
+  }
+  |tx.type == "refund"| => {
+    return acc + tx.amount
+  }
+  |true| => {
+    return acc
+  }
+}
+
+dec balance = transactions.reduce(transactionReducer, 0)
+print "Final balance: $${balance}"
+
+// Another example: grouping items by category
+dec items = [
+  { name: "apple", category: "fruit" },
+  { name: "carrot", category: "vegetable" },
+  { name: "banana", category: "fruit" },
+  { name: "broccoli", category: "vegetable" },
+  { name: "orange", category: "fruit" }
+]
+
+fn groupReducer(acc, item) {
+  |item.category == "fruit"| => {
+    return {
+      fruits: [...acc.fruits, item.name],
+      vegetables: acc.vegetables
+    }
+  }
+  |item.category == "vegetable"| => {
+    return {
+      fruits: acc.fruits,
+      vegetables: [...acc.vegetables, item.name]
+    }
+  }
+  |true| => {
+    return acc
+  }
+}
+
+dec grouped = items.reduce(groupReducer, { fruits: [], vegetables: [] })
+
+print "\nGrouped items:"
+print "Fruits: ${grouped.fruits.join(", ")}"
+print "Vegetables: ${grouped.vegetables.join(", ")}"
+
+// Example: state machine with pattern matching in arrow function
+dec events = ["start", "pause", "resume", "stop", "start"]
+
+dec finalState = events.reduce((state, event) => {
+  |event == "start"| => {
+    return "running"
+  }
+  |event == "pause" and state == "running"| => {
+    return "paused"
+  }
+  |event == "resume" and state == "paused"| => {
+    return "running"
+  }
+  |event == "stop"| => {
+    return "stopped"
+  }
+  |true| => {
+    return state
+  }
+}, "idle")
+
+print "\nFinal state: ${finalState}"

package/examples/regex_match.km

@@ -0,0 +1,46 @@
+// Regex Pattern Matching Example
+// Demonstrates two syntaxes:
+// 1. Simple match: expr ~ /regex/ - returns the matched string or undefined
+// 2. Match with body: expr ~ /regex/ => { return value } - returns the body result
+
+// Simple match - returns the matched portion
+dec input = "hello world 123"
+dec matched = input ~ /hello/
+print "Simple match result: ${matched}"
+
+// Match with transformation - returns body result
+dec transformed = input ~ /(\w+) (\w+)/ => { return $match[2] }
+print "Transformed (second word): ${transformed}"
+
+// Extract numbers from string
+dec numbers = "Price: $42.99" ~ /\d+\.\d+/
+print "Extracted number: ${numbers}"
+
+// Match with body for complex transformation
+dec greeting = "Hello, John!" ~ /Hello, (\w+)!/ => {
+  return "Welcome, ${$match[1]}!"
+}
+print greeting
+
+// Regex literals can also be used directly in expressions
+dec emailPattern = /^[\w.-]+@[\w.-]+\.\w+$/
+dec phonePattern = /^\d{3}-\d{3}-\d{4}$/
+
+fn validateEmail(email) {
+  return emailPattern.test(email)
+}
+
+fn validatePhone(phone) {
+  return phonePattern.test(phone)
+}
+
+print ""
+print "=== Validation Examples ==="
+print "Is 'test@example.com' a valid email? ${validateEmail('test@example.com')}"
+print "Is '555-123-4567' a valid phone? ${validatePhone('555-123-4567')}"
+
+// Conditional based on match result
+dec logLine = "ERROR: Connection failed"
+dec level = logLine ~ /^(ERROR|WARN|INFO|DEBUG)/
+print ""
+print "Log level: ${level}"

package/examples/sample.js

@@ -0,0 +1,45 @@
+// Sample JavaScript file to test JS to KimchiLang conversion
+
+const API_URL = "https://api.example.com";
+
+function add(a, b) {
+  return a + b;
+}
+
+function greet(name) {
+  console.log("Hello, " + name);
+}
+
+class UserService {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  
+  getUser(id) {
+    return this.apiKey + "/users/" + id;
+  }
+  
+  createUser(name, email) {
+    console.log("Creating user: " + name);
+    return { name, email };
+  }
+}
+
+const numbers = [1, 2, 3, 4, 5];
+const doubled = numbers.map(x => x * 2);
+
+function processStatus(status) {
+  if (status === 200) {
+    console.log("OK");
+  } else if (status === 404) {
+    console.log("Not Found");
+  } else {
+    console.log("Unknown");
+  }
+}
+
+for (const num of numbers) {
+  console.log(num);
+}
+
+export { add, greet, UserService };

package/examples/sample.km

@@ -0,0 +1,39 @@
+dec API_URL = "https://api.example.com"
+fn add(a, b) {
+  return a + b
+}
+
+fn greet(name) {
+  print "Hello, " + name
+}
+
+// Converted from class UserService
+fn createUserService(apiKey) {
+  return {
+    getUser: (id) => {
+      return "${apiKey}/users/${id}"
+    },
+    createUser: (name, email) => {
+      print "Creating user: ${name}"
+      return { name, email }
+    }
+  }
+}
+
+dec numbers = [1, 2, 3, 4, 5]
+dec doubled = numbers.map(x => x * 2)
+fn processStatus(status) {
+  |status == 200| => {
+    print "OK"
+  }
+  |status == 404| => {
+    print "Not Found"
+  }
+  |true| => {
+    print "Unknown"
+  }
+}
+
+for num in numbers {
+  print num
+}

package/examples/secrets.static

@@ -0,0 +1,35 @@
+// Example static file with primitives and secrets
+
+// String primitives
+AppName "MySecureApp"
+Version "1.0.0"
+
+// Number primitives
+MaxConnections 100
+Timeout 5000
+
+// Boolean primitive
+DebugMode false
+
+// Secret string primitive
+secret ApiKey "sk-1234567890abcdef"
+
+// Secret number (e.g., a port that should be hidden)
+secret InternalPort 8443
+
+// Object with secret properties
+DatabaseConfig {
+  host = "localhost"
+  port = 5432
+  database = "myapp"
+  secret username = "admin"
+  secret password = "super-secret-password"
+}
+
+// Mixed object with some secrets
+ServiceConfig {
+  name = "api-service"
+  url = "https://api.example.com"
+  secret token = "bearer-token-12345"
+  retries = 3
+}