in-other-words VS ghc

I would argue that the fact that not all monads compose is a feature, not a bug, in that not all effects are compatible. Citing from in-other-words:

$ ghci GHCi, version 9.6.2: https://www.haskell.org/ghc/ :? for help ghci> 1 + 1;; :1:1: error: Parse error: module header, import declaration or top-level declaration expected.

I'm confused about something. According to https://www.haskell.org/ghc/ version 9.10.3 was released on 2025-09-10. How is there a version 9.12.1 listed for the or-patterns feature? Are these versions for different things?

For those not well versed in Haskell, GHC is apparently this:

https://www.haskell.org/ghc/

What is GHC?

GHC is a state-of-the-art, open source compiler and interactive environment for the functional language Haskell.

Website: GHC Haskell

% bin/ghcid --test main Loading cabal repl --repl-options=-fno-break-on-exception --repl-options=-fno-break-on-error --repl-options=-v1 --repl-options=-ferror-spans --repl-options=-j ... Build profile: -w ghc-9.4.8 -O1 In order, the following will be built (use -v for more details): - nombreproyecto-0.1.0.0 (interactive) (exe:nombreproyecto) (first run) Preprocessing executable 'nombreproyecto' for nombreproyecto-0.1.0.0... GHCi, version 9.4.8: https://www.haskell.org/ghc/ :? for help [1 of 4] Compiling Foo ( app/Foo.hs, interpreted ) app/Foo.hs:3:1-3: warning: [-Wmissing-signatures] Top-level binding with no type signature: foo :: Integer | 3 | foo = 2 | ^^^ ...

GHCi, version 9.4.8: https://www.haskell.org/ghc/ :? for help

of course it does! what else would you call something like chicken scheme [https://call-cc.org/], ats [https://ats-lang.sourceforge.net/], or ghc [https://www.haskell.org/ghc/]? they are not "scripts", they are full-blown compilers that happen to use C as their compilation target, and then leverage C compilers to generate code for a variety of architecures. it's a very sensible way to do things.

Agree about Haskell... as far as I'm aware there is actually no declarative/easily-readable definition of the Haskell syntax that is also complete, especially when it comes to the indentation rules, and the syntax is basically defined by the very (ironically) imperatively-defined GHC parser[0].

I prefer a syntax like in Pure[1], where the ambiguous, hard to parse indentation-based syntax is replaced by explicit semicolons (Yeah, you can use braces/semicolons in Haskell as well, but most code doesn't).

[0] https://github.com/ghc/ghc/blob/master/compiler/GHC/Parser/L...

[1] https://agraef.github.io/pure-lang/

GHC, the main Haskell compiler

GHCi, version 9.6.3: https://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /Users/daniel/.ghci ghci> :{ | split :: Float -> [Int] | split value = map(read . (:[])) . show | :} :3:15: error: [GHC-83865] • Couldn't match expected type: [Int] with actual type: a0 -> [b0] • Probable cause: ‘(.)’ is applied to too few arguments In the expression: map (read . (: [])) . show In an equation for ‘split’: split value = map (read . (: [])) . show