{curl 8.0 applet}
{curl-file-attributes character-encoding = “utf8”}
{import * from CURL.LANGUAGE.MATH}
{let vb:VBox =  {VBox
                    {HBox “max-value is:”,Decimal.max-value},
                    {HBox “min-value is:”,Decimal.min-value}
                } }
{value
    vb
}

{define-proc {my-proc}:void
  {message-box “ABC”}
}

{my-proc}

{value
    let v = 1 || この式は{let v = 1}と記載することも可能です。
    set v = 2 || この式は{set v = 2}と記載することも可能です。
    v
}

{do
    let v = 1 || この式は{let v = 1}と記載することも可能です。
    set v = 2 || この式は{set v = 2}と記載することも可能です。
}

{do
    let v = 1 || 1行のみコメント
    |#
        複数行コメント
    #|
}

let str:String = “あいうえお” || もしくは{let str:String = “あいうえお”}

let (str:String, int:i) = (“あいうえお”, 123) 

set str = “ABCDE” || もしくは{set str = “ABCDE”}

set (str, i) = (“かきくけこ”, 456) 

let str:#String = null

def str = “あいうえお” || let constant str:String = “あいうえお”と同様 

set str = 
    {if a > 1 then
        “あいうえお”
     else
        “かきくけこ”
    }

{inc i} || 増
{dec i} || 減

{value
    let i:int = 2 * 2 
    let str:String = “AB” & “CD”
}

let x:int = 1
let y:int = 2
{output
    {if x > y then
        “xが大きい” || outputは出力コンソールに表示するものです。
     else
        “yが大きい”
    }
}

let x:int = 1
{switch x
 case 0 do
    {output “xは０”}
 case 1, 2 do
    {output “xは１か2です”}
 else
    {output “xは3以上の値”}
}

{type-switch x
 case i:int do
    {output “xはint”}
 case f:float do
    {output “xはfloat”}
 else
    {output “xはintでもfloatでもないです。”}
}

|| 2づつ増やしていく
{for i:int = 0 below 8 step 2 do
    {output i}
}

|| 2づつ減らしていく
{for i:int = 8 above 0 step 2 do
    {output i}
}

{continue}

{break} 

{curl 6.0 applet}

{value
    let p:{proc-type {int, int}:int} =
        {proc {a:int, b:int}:int
            || 足し算の結果を返す
            {return a + b}
        }

    {output {p 10, 20}} || 30
    {output {p 5, 30}}   || 35
}

{curl 6.0 applet}

{define-proc public {add a:int, b:int}:int
    || 足し算の結果を返す
    {return a + b}
}

{value
    {output {add 20, 30}}
}

|| 通常のプロシージャ
def x = {proc {i1:int, i2:int}:int
              {return i1 * i2}
           }

|| ラムダ式（fnというマクロ。C#と同様=>演算子を利用します。
def x = {fn i1, i2 => i1 * i2}

|| プロシージャの作成
{define-proc public {my-proc1 i:int}:void
   || 処理
}

{my-proc1 100} || 実行

{my-proc2 i = 200}
{my-proc2} || {my-proc2 i = 100}と同等

|| プロシージャの作成
{define-proc public {my-proc3 
                                 str:String,
                                 i:int = 100,
                                 f:float = 1.0
                            }:void
    || 処理
}

{my-proc3 “abc”, i = 200}
{my-proc3 “efg”, f = 2.0}
{my-proc3 “xyz”}
{my-proc3 “abc”, i = 200, f = 2.0}

{define-proc public {my-proc5 i:int, …:String}:void
}

{my-proc6 “abc”, “def”, 123, 1.0, true}

let p:Person = {Person}
もしくは
let p:Person = {new Person}

{define-class public Person

    field private _name:String

    {constructor public {default
                                   name:String
                               }
         set self._name = name
    }
}

{define-class public Person

    field private _name:String

    {constructor public {default
                                   name:String
                               }
         set self._name = name
    }

    {constructor public {TestConstructor
                                   first-name:String,
                                   last-name:String
                               }
         set self._name = first-name & ” ” & last-name
    }
}

{let p1:Person = {Person “amori”}} || デフォルトコンストラクタ
{let p2:Person = {Person.TestConstructor “akira”, “mori”}} || コンストラクタTestConstructor

{define-class public Person

    field private _name:String

    {getter public {name}:String
        {return self._name}
    }

    {setter public {name _name:String}:void
        set self._name = _name
    }

    {constructor public {default
                                   name:String
                               }
         set self._name = name
    }
}

{let p:Person = {Person “amori”}}
{output p.name}  || ゲッター
{set p.name = “hokada”} || セッター

{define-class public Person

    field private _name:String

    {constructor public {default
                                   name:String
                               }
         set self._name = name
    }

    || 戻り値 : Stringのメソッド
    {method public {toString}:String
        {return {format “I’m %s.”, self._name}}
    }
}

{define-class public Member
    {inherits Person} || 親クラス

    field _id:int

    {getter public {id}:int
          {return self._id}
    }

    {constructor public {default
                                   id:int,
                                   name:String
                               }
         {construct-super name}
    }
}

{let m:Member = {Member 1, “amori”}}
{output m.id}
{output m.name} || 親クラスのゲッター

{define-class public Child
    {inherits Oya1, Oya2, Oya3} || 親クラス（多重継承）

    || …….
}

{define-class public abstract AbstractPerson

    {method public abstract {toString}:String } 
}

|| TestFactory
{define-class public abstract TestFactory

  {getter public abstract {name}:String }

  {factory public {default
                      switch:int = 1
                  }:TestFactory
    {return
        {if switch == 1 then
            {Class01} || 子クラスのインスタンス生成
         else
            {Class02} || 子クラスのインスタンス生成
        }
    }
  }
}

|| Class01
{define-class public Class01 {inherits TestFactory}
  {getter public {name}:String
    {return “class 01”}
  }
}

|| Class02
{define-class public Class02 {inherits TestFactory}
  {getter public {name}:String
    {return “class 02”}
  }
}

{do
    def fac = {TestFactory switch = 2}
    {output fac.name} || 実行結果はClass02.nameの”class 02”
}

{package COM.CURLAP.ABC,
    author = “amori”,
    copyright = “Copyright ….”,
    version = “1.0”
}

|| ここに、クラスやプロシージャ等を定義していく。

{curl 6.0 package}

{package COM.CURLAP.ABC,
    author = “amori”,
    copyright = “Copyright ….”,
    version = “1.0”
}

|| クラス等を定義した外部ファイルを読み込む
{include “abc1.scurl”}
{include “abc2.scurl”}

|| 直接クラス等を記載できる。
{define-class public A
    || …
}
{define-class public B
    || …
}

{curl 6.0 package}

{package COM.CURLAP.SUPERPACK}

{import public * from COM.CURLAP.A}
{import public * from COM.CURLAP.B}

{try
    || 処理
 catch 例外１ do
    || 例外１発生時の処理
 catch 例外２ do
    || 例外２発生時の処理
 finally
    || finally処理

} 

{define-class public MyException {inherits Exception}
    {constructor public {default message:String}
         {construct-super message}
    }
} 

{throw {MyException “My exception has occurred.”}}