Sugar – a typed lispy language targeting webasm/wat (opens in new tab)

Sugar is just a toy. Don't learn it. Maybe you can learn something about common lisp from reading the sugar compiler source code.

I agree with TurboHaskal. I too, learned Scheme first and liked it cos it was simpler/purer etc. than Common Lisp.

When I finally learned Common Lisp, my only regret was that I hadn't learned it earlier.

Common Lisp is not perfect, but it has a single standard. Very important. It's very mature and battle tested.

The people who you'll meet in the Common Lisp community are very smart and capable and you will learn a lot from them. I did.

Learning Scheme won't hurt but I recommend Common Lisp. Great, free compilers, lots of libraries for everything and a great community.

But please, do not learn sugar :)

"Between Land of Lisp, David Touretzky's Common Lisp: A Gentle Introduction to Symbolic Computation (really great book for people new to programming, available for free) and The Little LISPer (3rd edition, editions four and up use Scheme) you have three really great resources to get started."

https://carcaddar.blogspot.com/2011/10/common-lisp-is-best-l...

And here's a link to Shapiro's COMMON LISP: An Interactive Approach:

https://cse.buffalo.edu/~shapiro/Commonlisp/

Forget about the perfect editor setup, idiomatic code and all that fuzz about becoming enlightened. (Common) Lisp is first and foremost a productive, pragmatic language to get things done, so just start hacking.

I'd probably suggest SICP: https://mitpress.mit.edu/sites/default/files/sicp/index.html if you want a "lisp intro"

Do you mean literally the syntax

    foo :: Type0 -> Type1 -> Type2

In the case of the former you have Hackett (https://lexi-lambda.github.io/hackett/reference-syntactic-fo...) which unfortunately I think isn't seeing too much work on it anymore.

In the latter case something like Typed Clojure may work (https://github.com/clojure/core.typed).

In the Coursera course Programming Languages, I ported some of the first assignments from SML to F# and Typed Racket, and you can see the similarities of type annotations in the very simple examples below.

SML:

    (* Helper function. Takes a generic list and an integer n and returns the nth element of the list. *)
    fun get_nth_element (xs : 'a list, n : int) =
        if n = 1
        then hd xs
        else get_nth_element(tl xs, n-1)

    (* Takes a list of strings and an integer n and returns the nth element of the list. *)
    fun get_nth (strings : string list, n : int) =  get_nth_element(strings,n)

    /// Helper function. Takes a generic list and an integer n and returns the nth element of the list.
    let rec getNthElement (xs : 'a list, n : int) =
        if n = 1
        then List.head xs
        else getNthElement(List.tail xs, n-1)

    /// Takes a list of strings and an integer n and returns the nth element of the list.
    let getNth (strings : string list, n : int) =  getNthElement(strings,n)

    #lang typed/racket

    ;; Helper function. Takes a generic list and an integer n and returns the nth element of the list.
    (: get-nth-element (All (T) (Listof T) Integer -> T))
    (define (get-nth-element xs n)
      (if (equal? n 1)
          (first xs)
          (get-nth-element (rest xs) (- n 1))))

    ;; Takes a list of strings and an integer n and returns the nth element of the list.
    (: get-nth ((Listof String) Integer -> String))
    (define (get-nth strings n) (get-nth-element strings n))

You may be interested to read this, which talks about a proposal to add additional stack instructions: https://github.com/WebAssembly/design/issues/1381

Thanks for reading the post :)

Update 2020-12-07: There was a bug in the macro expansion logic. I've backported the fix to the linked source and explained the bug in the 'mistakes' section.

[1] https://github.com/carp-lang/Carp

I am currently working on some of the "future directions" ideas and will post again soon about that.