Member 14564709 wrote:

Unfortunately BASIC has been all but killed off because it scared the crap out of the C guys.

Fred2834 wrote:

I would not want a very long hash table to be described without any special character. In the real world, large XML or JSON files are a reality.

<mt-records hidden id="tattooists">
    NAME
    LINK
    DESCRIPTION

    Genevieve Dupre
    https://www.genevievetattoos.com
    This isn't what you expected.

    Joey Armstrong
    https://thunderhandtattoo.com
    The most amazing.
</mt-records>

"how do I make it go"
"press the 'Play' button."
"you mean this one '|> Play', with a triangle on it."
"yes."
"what does the triangle mean?"

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

it's all wrong, you've mixed up terms, "'cost' is purchasing, 'price' is selling."  "price times quantity is selling price, not even 'nett cost' let alone 'cost'"

Quote:

The major problem with your idea is "Human understandable"
you didn't define the audience

Quote:

By "human-understandable", i DON'T mean "natural language" or "sounds like spoken English". I mean, provided you have learned the special programming syntax, and that learning that syntax is no more challenging or time-consuming than learning, say, Python.

abstract class Item {
  use();
}

class Chest<T> implements Item {
  List<T> contents;

  Chest(this.contents);

  use() => print("$this has ${contents.length} items.");
}

class Sword implements Item {
  int damage = 5;

  use() => print("$this dealt $damage damage.");
}

main(){
  var chest = Chest([Sword()]);

  chest.use();

  for (var item in chest.contents) {
    item.use();
  }
}

Lorenzo Bertolino wrote:

(how do you quote text? )

<blockquote class="quote"><div class="op">Quote:</div> Quoted text goes here...</blockquote>

Quote:

Quoted text goes here...

Member 7989122 wrote:

Why do we have to announce in advance with a "try" that the block has an exception handler? The handler is there, that should be enough!

CallSomeMethod();

try
{
    CallSomeOtherMethod();
}
catch (SomeFunkyException)
{
}

CallSomeMethod();

CallSomeOtherMethod()     -- note: no semicolon - block not yet complete
ON (SomeFunkyException): 
  LogThisException(); 
END;                      -- here is the semicolon terminating the block

DO
   CallSomeMethod();
   CallSomeOtherMethod();
OD                        -- note: no semicolon; loop still incomplete
ON (SomeFunkyException):  -- handler for exception in the loop statement
  LogThisException(); 
END; 

DO WHILE ExceptionCount < 10;
   SomeCallNotHanldedByTheOnClause();
   BEGIN
      CallSomeMethod();
      CallSomeOtherMethod();
   END                       -- no semicolon - handler follows
   ON (SomeFunkyException):  -- handler for exception in the loop statement
      LogThisException();
      Exceptioncount +:= 1;
   END;
   AnotherCallWithNoHandler();
OD;

BEGIN
   CallSomeMethod();
   CallSomeOtherMethod();
END 
ON (SomeFunkyException):   LogFunkyException(); Funkiness +:= 1;
   (SomeStrangeException): LogStrangeException(); Strangeness +:= 1;
   ELSE:                   LogOtherException(); EXIT SurroundingStatementLabel;
END;

BEGIN
   ...
END
ON (SomeFunkyException): ...
END;

try
{
   ...
}
catch (SomeFunkyException)
{
    ...
}

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()