Lisp and Haskell (2015)

If the code is sound, it should have the same complexity anyways. I.e. putting a non-empty requirement in the function signature is just as complex as adequately handling an empty array in the code.

My personal struggle is that statically typed languages are annoying to prototype (I don't care if it segfaults on my laptop, I want to validate my idea). My struggle is prototyping in something that I can easily transition to a strictly typed version. I'm curious to try prototyping in Javascript and adding types when I move to production.

    This is SBCL 1.5.6, an implementation of ANSI Common Lisp.
    More information about SBCL is available at .
    
    SBCL is free software, provided as is, with absolutely no warranty.
    It is mostly in the public domain; some portions are provided under
    BSD-style licenses.  See the CREDITS and COPYING files in the
    distribution for more information.
    * (defun add-text-padding (str &key padding newline)
      "Add padding to text STR. Every line except for the first one, will be
    prefixed with PADDING spaces. If NEWLINE is non-NIL, newline character will
    be prepended to the text making it start on the next line with padding
    applied to every single line."
      (let ((str (if newline
                     (concatenate 'string (string #\Newline) str)
                     str)))
        (with-output-to-string (s)
          (map 'string
               (lambda (x)
                 (princ x s)
                 (when (char= x #\Newline)
                   (dotimes (i padding)
                     (princ #\Space s))))
               str))))
    ; in: DEFUN ADD-TEXT-PADDING
    ;     (MAP 'STRING
    ;          (LAMBDA (X)
    ;            (PRINC X S)
    ;            (WHEN (CHAR= X #\Newline) (DOTIMES (I PADDING) (PRINC #\  S))))
    ;          STR)
    ; 
    ; caught WARNING:
    ;   The function (LAMBDA (X) :IN ADD-TEXT-PADDING) called by MAP returns NULL but CHARACTER is expected
    ;   See also:
    ;     The SBCL Manual, Node "Handling of Types"
    ; 
    ; compilation unit finished
    ;   caught 1 WARNING condition
    ADD-TEXT-PADDING

I have looked at both without any prior experience in them and OCAML tooling is horrible. Also, with no support for unicode in Ocaml, F# is just much better in this regard - even if it lacks modules, functors, etc.

Every REPL form sent recompiles the running program, I don't want that fast loop to be force lagged by the program checking types

I'm more than happy for that to happen at edit time, independent of compile time outside of my application process

So I heavily encourage using clj-kondo to check for mistakes doing primitive type checking etc

To reiterate, I love static analysis but I also need control over how and when it runs, I like it in CI and during editing

Otherwise it comprises one of the best things about those old languages, (Smalltalk lisp etc) being able to dev your application by injecting code and recompiling while the app is still running

The feedback loop while coding a live image is hard to explain but anything that makes it slower is disastrous for me, I can lose focus so quick

When deving Clojure idiomatically partial recompile happens at a much greater frequency than most languages, compile time is very important