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.

Marc Clifton wrote:

basically why I always use addEventListener. Besides the fact that I rather despise the whole "on[event]="someFunctionCall()" in the HTML.