darrenks / nibbles

A codegolf language for mortals

Nibbles is a code golf language for mortals (it aims to be good at code golf while remaining relatively simple). It is also purely functional, statically typed, and fully lazy. Syntax is Polish (prefix) notation. Each instruction is half a byte when automatically converted from ascii to the binary form.

See golfscript.com/nibbles for tutorials and references.

nibbles's Issues

nibbles: failed to compile hs (zip by scalar)

Nibbles code:

! ,4 0 ~ 1

Produces the following error message:

out.hs:192:824: error:
    • Couldn't match type ‘Integer’ with ‘[t0]’
      Expected type: [Integer] -> Integer -> [Integer]
        Actual type: [Integer] -> [t0] -> [Integer]
    • In the third argument of ‘\ a b f -> f a b’, namely
        ‘(((zipWith . \ f a b -> f $ (\ (~a1, ~a2) -> ((a1, a2))) (a, b))
             (\ (arg2t1, arg2t2)
                -> (((((id) (((1)) :: Integer))) :: Integer)))))’
      In the first argument of ‘id
                                . ((\ a b -> intercalate a $ map (sToA . show . confirmInt) b)
                                     secondSep)’, namely
        ‘((((\ a b f -> f a b)
              ((((\ x -> [1 .. x]) ((((id) (((4)) :: Integer))) :: Integer))) ::
                 [Integer]))
             (((\ f -> f (()))
                 (\ (arg2t1) -> (((((id) (((0)) :: Integer))) :: Integer))))))
            (((zipWith . \ f a b -> f $ (\ (~a1, ~a2) -> ((a1, a2))) (a, b))
                (\ (arg2t1, arg2t2)
                   -> (((((id) (((1)) :: Integer))) :: Integer))))))’
      In the expression:
        ((id
          . ((\ a b -> intercalate a $ map (sToA . show . confirmInt) b)
               secondSep))
           ((((\ a b f -> f a b)
                ((((\ x -> [1 .. x]) ((((id) (((4)) :: Integer))) :: Integer))) ::
                   [Integer]))
               (((\ f -> f (()))
                   (\ (arg2t1) -> (((((id) (((0)) :: Integer))) :: Integer))))))
              (((zipWith . \ f a b -> f $ (\ (~a1, ~a2) -> ((a1, a2))) (a, b))
                  (\ (arg2t1, arg2t2)
                     -> (((((id) (((1)) :: Integer))) :: Integer)))))))
nibbles: failed to compile hs (likely an internal nibbles bug, please report it!)
CallStack (from HasCallStack):
  error, called at nibbles.hs:163:24 in main:Main

Min does not work on char

Max works on chars, but min does not, although this would not conflict with another op:

] 'a' 'b' -> 'b'

[ 'a' 'b' ->

nibbles: Parse Error: no matching op, tried: 
[ int num, arg 1 is VChr
[ int vec, arg 1 is VChr
[ int >num, arg 1 is VChr

Incorrect execution in literate mode

This code in literate mode interprets ; @ as save-op instead of referencing ;@:

. , ;4 ~~ $ ; @ $

produces

1 4 4
2 4 4
3 4 4
4 4 4

Compilation converts this to ;@ and produces:

1  1
2  2
3  3
4  4

Extraction bug

Warning: your code's binary would actual extract to:
/,$`p-$$
instead of:
/,$? 1$$
Please report this as it is a bug (there is supposed to be a more clear accidental extension detection, this is just a fail safe)
size = 8 nibbles (4.0 bytes)

https://ato.pxeger.com/run?1=m708LzMpKSe1eMGCpaUlaboWy_V1VOwNVVQgPKjggg3GlgZGxgaWJkbGRsbGJqaGEHEA

nibbles: failed to compile hs (tuples)

I suspect this nibbles code is erroneous, but the error message is "please report a bug" rather than a more helpful error message

My attempt at a minimal repro case:

. ; . ;@ ~$$ `& _ 1

Results in the following output:

size = 13 nibbles (6.5 bytes)

out.hs:192:1162: error:
    • Couldn't match type ‘(t0, t1)’ with ‘()’
      Expected type: () -> Integer
        Actual type: (t0, t1) -> Integer
    • In the first argument of ‘\ a1
                                  -> (((: []) . (\ a1 -> ((sToA . show) a1))) a1)’, namely
        ‘(bb ())’
      In the second argument of ‘($)’, namely
        ‘(\ a1 -> (((: []) . (\ a1 -> ((sToA . show) a1))) a1)) (bb ())’
      In the second argument of ‘($)’, namely
        ‘(\ x -> zip x $ map id x)
         $ (\ a1 -> (((: []) . (\ a1 -> ((sToA . show) a1))) a1)) (bb ())’
    • Relevant bindings include
        bb :: (t0, t1) -> Integer (bound at out.hs:192:975)
nibbles: failed to compile hs (likely an internal nibbles bug, please report it!)
CallStack (from HasCallStack):
  error, called at nibbles.hs:163:24 in main:Main

There are a number of variations of this code that can produce different tuple types, but still error in the same place with "Couldn't match type". I personally am unfamiliar with Haskell so I am not able to interpret what is causing the error here.

nibbles: out: callProcess: posix_spawnp: does not exist (No such file or directory)

I installed Nibbles on Manjaro WSL using the recommended instructions (with ghcup). When I run the executable and enter a Nibbles program, it outputs the program size as expected and then the following error:

nibbles: out: callProcess: posix_spawnp: does not exist (No such file or directory)