ghc
seed7
Our great sponsors
 InfluxDB  Collect and Analyze Billions of Data Points in Real Time
 Onboard AI  Learn any GitHub repo in 59 seconds
 SaaSHub  Software Alternatives and Reviews
ghc  seed7  

91  41  
2,926  148  
0.5%    
9.2  8.1  
5 months ago  5 days ago  
Haskell  C  
GNU General Public License v3.0 or later  GNU General Public License v3.0 only 
Stars  the number of stars that a project has on GitHub. Growth  month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
ghc

Introducing NeoHaskell: A beacon of joy in a greyed tech world
Depending on who you ask, a programming language can be different things. If you ask the Haskell community, many will tell you that the language is the Haskell specification, and that what currently is being used is not Haskell itself, but an extension of Haskell that is supported by the GHC compiler. Similar to the C language, a programming language would be a specification.
 Exploring the Internals of Linux v0.01
 Why did GHC go from "occurs check failed" to talking about rigid type variables?

How to get Bounded or Enum functionality for arbitrary Ints?
bss@monster % cat > File.hs pred 1 = 4 succ 4 = 1 succ 1 = 2 bss@monster % ghci XNoImplicitPrelude File.hs GHCi, version 9.0.2: https://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/bss/.ghc/ghci.conf [1 of 1] Compiling Main ( File.hs, interpreted ) Ok, one module loaded. (0.04 secs,) GHCi> pred 1 4 it :: GHC.Num.Num p => p (0.01 secs, 79,688 bytes) GHCi> succ 1 2 it :: GHC.Num.Num p => p (0.01 secs, 78,088 bytes)
GHCi, version 9.0.2: https://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/bss/.ghc/ghci.conf GHCi> :{ GHCi pred 1 = 4 GHCi succ 4 = 1 GHCi succ 1 = 2 GHCi :} pred :: (Eq a, Num a, Num p) => a > p succ :: (Eq a, Num a, Num p) => a > p (0.04 secs, 0 bytes) GHCi> pred 1 4 it :: Num p => p (0.01 secs, 62,784 bytes) GHCi> succ 4 1 it :: Num p => p (0.01 secs, 61,864 bytes) GHCi> succ 1 2 it :: Num p => p (0.01 secs, 61,928 bytes)

Monad Transformer Compatibility
[jumper derivingtrans @master]$ nix develop [jumper derivingtrans @master]$ cabal repl Build profile: w ghc9.2.4 O1 In order, the following will be built (use v for more details):  derivingtrans0.8.0.0 (lib) (first run) Preprocessing library for derivingtrans0.8.0.0.. GHCi, version 9.2.4: https://www.haskell.org/ghc/ :? for help :1:1: warning: [Wmissinglocalsignatures] Polymorphic local binding with no type signature: _compileParsedExpr :: forall {a}. ghcprim:GHC.Types.IO a > ghcprim:GHC.Types.IO a macro 'doc' overwrites builtin command. Use ':def!' to overwrite. Loaded GHCi configuration from /home/jumper/.ghc/ghci.conf : warning: [Wunusedpackages] The following packages were specified via package or packageid flags, but were not needed for compilation:  unliftiocore0.2.0.14aEaNp8xHRK6Ey6KEoq0BU  transformersbase0.4.6BO3yqj8kK7N1FV1bV9s5yP  transformers0.6.0.4F8uVRiS1g8K3h8Rsxr0UMd  resourcet1.2.6GkviYKmTWlu24k3qS4ih9J  random1.2.1.1DsRhotp5Bx34wv1CRGomTB  primitive0.7.3.01lmZ3PZm6JAE7HP2AgnD1I  mtl2.3.1A9dQ96c1wA8f1tgidK0Kj  monadcontrolidentity0.2.0.0C96eAiqAq5HPusYxrNzzr  monadcontrol1.0.3.19k4XD0NyvERHbSFKJZxIuC  logict0.8.0.05sZNS401Hrq2OkYkpVhzEI  exceptions0.10.7LidfE6miSbs6Y1NYj1lBV5  base4.16.3.0 [1 of 7] Compiling Control.Monad.Accum.OrphanInstances ( src/Control/Monad/Accum/OrphanInstances.hs, interpreted ) [2 of 7] Compiling Control.Monad.Select.OrphanInstances ( src/Control/Monad/Select/OrphanInstances.hs, interpreted ) [3 of 7] Compiling Control.Monad.Trans.Elevator ( src/Control/Monad/Trans/Elevator.hs, interpreted ) [4 of 7] Compiling Control.Monad.Trans.Compose.Transparent ( src/Control/Monad/Trans/Compose/Transparent.hs, interpreted ) [5 of 7] Compiling Control.Monad.Trans.Compose ( src/Control/Monad/Trans/Compose.hs, interpreted ) [6 of 7] Compiling Control.Monad.Trans.Compose.Stack ( src/Control/Monad/Trans/Compose/Stack.hs, interpreted ) [7 of 7] Compiling Control.Monad.Trans.Compose.Infix ( src/Control/Monad/Trans/Compose/Infix.hs, interpreted ) Ok, 7 modules loaded. λ *Control.Monad.Trans.Compose > :set XPartialTypeSignatures λ *Control.Monad.Trans.Compose > import Control.Monad.Trans.Compose.Infix λ *Control.Monad.Trans.Compose Control.Monad.Trans.Compose.Infix > import Control.Monad.Trans.Compose.Transparent λ *Control.Monad.Trans.Compose Control.Monad.Trans.Compose.Infix Control.Monad.Trans.Compose.Transparent > runTransparentT ./> (`Mtl.T.runReaderT` 'a') ./> (`Mtl.T.runReaderT` True) $ (,) <$> (Mtl.ask :: _ Char) <*> (Mtl.ask :: _ Bool) :4:98: warning: [Wpartialtypesignatures] • Found type wildcard ‘_’ standing for ‘ComposeT (Mtl.T.ReaderT Bool) (ComposeT (Mtl.T.ReaderT Char) (Elevator NoT)) IO :: * > *’ • In the type ‘_ Char’ In an expression type signature: _ Char In the second argument of ‘(<$>)’, namely ‘(Mtl.ask :: _ Char)’ :4:98: warning: [Wmonomorphismrestriction] • The Monomorphism Restriction applies to the binding for ‘’ Consider giving it a type signature • In the second argument of ‘(<$>)’, namely ‘(Mtl.ask :: _ Char)’ In the first argument of ‘(<*>)’, namely ‘(,) <$> (Mtl.ask :: _ Char)’ In the second argument of ‘($)’, namely ‘(,) <$> (Mtl.ask :: _ Char) <*> (Mtl.ask :: _ Bool)’ :4:122: warning: [Wpartialtypesignatures] • Found type wildcard ‘_’ standing for ‘ComposeT (Mtl.T.ReaderT Bool) (ComposeT (Mtl.T.ReaderT Char) (Elevator NoT)) IO :: * > *’ • In the type ‘_ Bool’ In an expression type signature: _ Bool In the second argument of ‘(<*>)’, namely ‘(Mtl.ask :: _ Bool)’ :4:122: warning: [Wmonomorphismrestriction] • The Monomorphism Restriction applies to the binding for ‘’ Consider giving it a type signature • In the second argument of ‘(<*>)’, namely ‘(Mtl.ask :: _ Bool)’ In the second argument of ‘($)’, namely ‘(,) <$> (Mtl.ask :: _ Char) <*> (Mtl.ask :: _ Bool)’ In the first argument of ‘GHC.GHCi.ghciStepIO :: IO a > IO a’, namely ‘(runTransparentT ./> (`Mtl.T.runReaderT` 'a') ./> (`Mtl.T.runReaderT` True) $ (,) <$> (Mtl.ask :: _ Char) <*> (Mtl.ask :: _ Bool))’ ('a',True)

Why does 0.1 and 0.2 = 0.30000000000000004?
GHCi, version 8.10.7: https://www.haskell.org/ghc/ :? for help

I ❤️ PEG
Haskell (in the form of GHC) uses Alex, which is regular expressionbased.

GHC JS and WA backends documentation ?
A good starting point for the JS backend is the modulelevel documentation in GHC.StgToJS, but it doesn't look like there's much good documentation yet, no.

How can type inference represent calculation?
GHCi, version 9.4.2: https://www.haskell.org/ghc/ :? for help ghci> :load Evolution.hs [1 of 2] Compiling Main ( Evolution.hs, interpreted ) Ok, one module loaded. ghci> :t fac four fac four :: Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ (Succ Zero)))))))))))))))))))))))
seed7

Have you heard about the Seed7 programming language?
Seed7 at GitHub
Yes, I am regularly working on improvements for Seed7. The changes are checked in at GitHub (see here for the list of commits) and once a month I do a release which is announced at r/seed7.

Corejs maintainer complains open source is broken
It all depends on the circumstances behind. In the beginning the corejs maintainer had no family and now he has. When I released Seed7 I already had a family. It was clear that my job had to support my family and my hobby (GitHub link).

Installing and Using the Seed7 Programming Language in Ubuntu (Blog Post)
I improved the explanation in read_me.txt. Now make test is recommended but considered optional as it can also be done later. With make test you can be sure that most of the language works as expected (graphics, sockets and some other things are not tested). Explaining that su should not be used for some commands would probably just add confusion. :)

The Julia language has a number of correctness flaws
If you don't like the Seed7 Homepage at SF you can go to GitHub, Rosetta Code or r/seed7 instead.

How would you change/remake your favourite programming language? (Inspired by a post on r/javascript)
Beside the Seed7 Homepage there other sources of information. Several example programs can be found at Rosetta Code. Announcements and discussions take place at r/seed7. Discussions are also in the Seed7 mailing list and announcements are also here. Seed7 is also at GitHub and in Wikipedia.

You need to stop idolizing programming languages.
I just use Emacs without any syntax highlighting for Seed7. Others contributed syntax highlighting files. For vim there is seed7/doc/seed7.vim and seed7/doc/sd7.vim. There is also seed7/doc/seed7.syn and seed7/doc/seed7.uew.
You can find all the released versions of Seed7 at SF and GitHub. There is also r/seed7 where I do announcements.

C Isn't A Programming Language Anymore  Faultlore
I invented the program chkccomp.c to find out all properties of C, its runtime and other C libraries (operating system + third party). When you compile Seed7 this program creates hundreds of little test programs that are compiled linked and executed. With that information chkccomp.c writes several hundred lines of property macros to a file named version.h, Other projects use shell scripts for this purpose (./configure comes into mind), but these scripts usually do not work for Windows.

The wild west of Windows command line parsing
For Seed7 I implemented my own version of CommandLineToArgvW. This function is used if the original one is not available. As mentioned in the article it turned out as much more complicated than expected.
What are some alternatives?
xvm  Ecstasy and XVM
polysemy  :gemini: higherorder, noboilerplate monads
sbcl  Mirror of Steel Bank Common Lisp (SBCL)'s official repository
effectzoo  Comparing Haskell effect systems for ergonomics and speed
vimmultiplecursors  True Sublime Text style multiple selections for Vim
inotherwords  A higherorder effect system where the sky's the limit
fusedeffects  A fast, flexible, fused effect system for Haskell
frpzoo  Comparing many FRP implementations by reimplementing the same toy app in each.
ghcproposals  Proposed compiler and language changes for GHC and GHC/Haskell
TypeScript  TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
linear  Lowdimensional linear algebra primitives for Haskell.