ManySteps:
BEGIN
   Step1();
   IF PreparationWentWrong THEN EXIT ManySteps;
   Step2();
   IF Specialcondition THEN EXIT ManySteps;
   Step3();
END ManySteps;

try {
  SingleStatement();
}
catch ...

Member 7989122 wrote:

This is just a way to make a block that is not a loop, not a conditional statement, not a function body, but just a sequence of smaller blocks put togeteher for some purpose

ManySteps:
BEGIN
   Step1();
   IF PreparationWentWrong THEN EXIT ManySteps;
   Step2();
   IF Specialcondition THEN EXIT ManySteps;
   Step3();
END ManySteps;

{
    Step1();
    if (PreparationWentWrong) goto ExitManySteps;
    Step2();
    if (Specialcondition) goto ExitManySteps;
    Step3();
}
ExitManySteps:

Member 7989122 wrote:

When you say "Here comes a conditional block" by using an IF keyword, you should not need to use an open parenthesis to say that "here comes the condition".

Member 7989122 wrote:

That is a major flaw in the language "design".

Member 7989122 wrote:

At the end of a deep nest, in C languages there may be a lisp-like sequence of closing parentheses, and you may have a hard time seeing which one closes the outermost loop, the while, the function, the class...

Richard Deeming wrote:

And yes, the language was designed.

data Location = Location { city :: String }
let home = Location { city = "Boston" }

type Location = { City : string }
let home = Location { City = "Boston" }

// Or we can use anonymous records....
let other_home = {| City = "Boston" |}

johnywhy wrote:

I mean, easy to understand at a glance.

factorial 1 = 1
factorial n = n * factorial (n-1)

list_length [] = 0
list_length (first_element:rest) = 1 + list_length rest

let rec fac n =
    match n with
    | 1 -> 1
    | n -> n * fac (n-1)

let rec length list =
    match list with
    | [] -> 0
    | first :: rest -> 1 + length rest

johnywhy wrote:

What's "Concise"?

johnywhy wrote:

What's "Practical"

open System.Net
open Microsoft.FSharp.Control.WebExtensions

// Defines a list of pairs of strings
let urlList = [ "Microsoft.com", "http://www.microsoft.com/"
                "MSDN", "http://msdn.microsoft.com/"
                "Bing", "http://www.bing.com"
              ]

let fetchAsync(name, url:string) =
    // The async block means this fucntion defines a task to be run asynchronously
    async {
        try
            let uri = new System.Uri(url)
            let webClient = new WebClient()
            // In async {}, let! operates a bit like Javascript's 'async' keyword
            let! html = webClient.AsyncDownloadString(uri)
            printfn "Read %d characters for %s" html.Length name
        with
            | ex -> printfn "%s" (ex.Message);
    }

let runAll() =
    // F# pipelines process the originating sequence
    // with each function in the pipeline
    urlList
    |> Seq.map fetchAsync     // Generate a task for each name,url pair
    |> Async.Parallel         // Dispatch all tasks in parallel
    |> Async.RunSynchronously // And wait for them all to complete
    |> ignore                 // And ignore any return value, as we only care about side-effects

runAll()

var home =
   {
   cit : "Boston"
   };

home.city = function(aCity)
   {
   if (arguments.length)
         this.cit = aCity;
      else
         return this.cit;
   };

aCity = home.city;
home.city = aCity;

var matching = new List<FileInfo>();

List<FileInfo> matching = new List<FileInfo>();

Member 7989122 wrote:

I think of it more at a concept level rather than saving typing. Avoid reduncancy. Avoid tokens that serve no purpose. Remove clutter.

Kirk 10389821 wrote:

If I gave you your "perfectly" concise language, without a bunch of caveats, like no libraries, no classes, no protocol support. Would you want to use it? If you had to implement AES, SMTP, HTTP, etc

johnywhy wrote:

Here's some COBOL. Very human understandable. But not concise:

ADD YEARS TO AGE.
MULTIPLY PRICE BY QUANTITY GIVING COST.
SUBTRACT DISCOUNT FROM COST GIVING FINAL-COST.

var home = 
{
    get City () 
    {
        return "Boston"
    }
};

James Curran wrote:

I would say you rewrite fails the "Human understandable" test, as because my understanding of your code is quite different than what the original javascript does.