F# To Tcl Converter

let rec fibonacci n =
match n with
| 0 -> 0
| 1 -> 1
| _ -> fibonacci (n – 1) + fibonacci (n – 2)

let generateFibonacciList n =
[ for i in 0 .. n – 1 -> fibonacci i ]

let sumFibonacciNumbers fibList =
List.fold (+) 0 fibList

[]
let main argv =
printfn “Enter the number of Fibonacci numbers to generate:”
let input = Console.ReadLine()
match Int32.TryParse(input) with
| (true, n) when n > 0 ->
let fibList = generateFibonacciList n
let sum = sumFibonacciNumbers fibList
printfn “The first %d Fibonacci numbers are: %A” n fibList
printfn “The sum of these Fibonacci numbers is: %d” sum
| _ ->
printfn “Please enter a valid positive integer.”
0

proc fibonacci {n} {
switch $n {
0 { return 0 }
1 { return 1 }
default {
return [expr {[fibonacci [expr {$n – 1}]] + [fibonacci [expr {$n – 2}]]}]
}
}
}

proc generateFibonacciList {n} {
set fibList {}
for {set i 0} {$i < $n} {incr i} { lappend fibList [fibonacci $i] } return $fibList } proc sumFibonacciNumbers {fibList} { set sum 0 foreach number $fibList { set sum [expr {$sum + $number}] } return $sum } proc main {} { puts "Enter the number of Fibonacci numbers to generate:" flush stdout gets stdin input if {[scan $input "%d" n] == 1 && $n > 0} {
set fibList [generateFibonacciList $n]
set sum [sumFibonacciNumbers $fibList]
puts “The first $n Fibonacci numbers are: $fibList”
puts “The sum of these Fibonacci numbers is: $sum”
} else {
puts “Please enter a valid positive integer.”
}
}

main

type BankingOperations() =
let mutable accounts = []

member this.CreateAccount(name: string) =
let newAccount = { Name = name; Balance = 0.0M }
accounts <- newAccount :: accounts printfn "Account created for %s" name member this.Deposit(name: string, amount: decimal) = match List.tryFind (fun acc -> acc.Name = name) accounts with
| Some(account) ->
account.Balance <- account.Balance + amount printfn "Deposited %M to %s's account. New balance: %M" amount name account.Balance | None -> printfn “Account for %s not found.” name

member this.Withdraw(name: string, amount: decimal) =
match List.tryFind (fun acc -> acc.Name = name) accounts with
| Some(account) when account.Balance >= amount ->
account.Balance <- account.Balance - amount printfn "Withdrew %M from %s's account. New balance: %M" amount name account.Balance | Some(account) ->
printfn “Insufficient funds for %s. Current balance: %M” name account.Balance
| None -> printfn “Account for %s not found.” name

member this.CheckBalance(name: string) =
match List.tryFind (fun acc -> acc.Name = name) accounts with
| Some(account) -> printfn “%s’s account balance: %M” name account.Balance
| None -> printfn “Account for %s not found.” name

[]
let main argv =
let bank = BankingOperations()
bank.CreateAccount(“Alice”)
bank.Deposit(“Alice”, 100.0M)
bank.Withdraw(“Alice”, 50.0M)
bank.CheckBalance(“Alice”)

bank.Withdraw(“Alice”, 100.0M) // Should warn about insufficient funds
bank.CheckBalance(“Alice”)

0 // return an integer exit code

proc createAccount {accounts name} {
set newAccount [dict create “Name” $name “Balance” 0.0]
lappend accounts $newAccount
puts “Account created for $name”
return $accounts
}

proc deposit {accounts name amount} {
set account [lindex [lmap acc $accounts {if {[dict get $acc Name] eq $name} {$acc}}] 0]
if {$account ne “”} {
set currentBalance [dict get $account Balance]
set newBalance [expr {$currentBalance + $amount}]
dict set account Balance $newBalance
puts “Deposited $amount to $name’s account. New balance: $newBalance”
} else {
puts “Account for $name not found.”
}
return $accounts
}

proc withdraw {accounts name amount} {
set account [lindex [lmap acc $accounts {if {[dict get $acc Name] eq $name} {$acc}}] 0]
if {$account ne “”} {
set currentBalance [dict get $account Balance]
if {$currentBalance >= $amount} {
set newBalance [expr {$currentBalance – $amount}]
dict set account Balance $newBalance
puts “Withdrew $amount from $name’s account. New balance: $newBalance”
} else {
puts “Insufficient funds for $name. Current balance: $currentBalance”
}
} else {
puts “Account for $name not found.”
}
return $accounts
}

proc checkBalance {accounts name} {
set account [lindex [lmap acc $accounts {if {[dict get $acc Name] eq $name} {$acc}}] 0]
if {$account ne “”} {
set balance [dict get $account Balance]
puts “$name’s account balance: $balance”
} else {
puts “Account for $name not found.”
}
}

proc main {} {
set accounts {}
set accounts [createAccount $accounts “Alice”]
set accounts [deposit $accounts “Alice” 100.0]
set accounts [withdraw $accounts “Alice” 50.0]
checkBalance $accounts “Alice”

set accounts [withdraw $accounts “Alice” 100.0] ;# Should warn about insufficient funds
checkBalance $accounts “Alice”
}

main
“`