rachel rosen @rachelrosen@types.pl

every time you use a monad where you could have used a functor or applicative a kitten cries. it's your fault.

Type Error! At The Parser Generator

/home/deppy/proj/pl/sexprml/dist-newstyle/build/x86_64-linux/ghc-8.10.4/sexprml-0.1.0.0/build/Parser/Parser.hs:818:42: error:
    • Couldn't match type ‘Tk’ with ‘Expr’
      Expected type: HappyStk
                       (HappyAbsSyn
                          [TL]
                          TYSG
                          TYSG
                          TYSG
                          [TYSG]
                          [TYSG]
                          [TL]
                          TL
                          Tk
                          [(Identifier, [Pattern], Expr)]
                          (Identifier, [Pattern], Expr)
                          [(TYSG, Identifier)]
                          [(TYSG, Identifier)]
                          (TYSG, Identifier)
                          [Identifier]
                          [Identifier]
                          [Identifier]
                          [Identifier]
                          Pattern
                          [Pattern]
                          [Pattern]
                          Expr
                          [Arg]
                          [Arg]
                          Arg
                          [(Identifier, Expr)]
                          [(Identifier, Expr)]
                          (Identifier, Expr)
                          Literal
                          Term
                          [(Pattern, Expr)]
                          [(Pattern, Expr)]
                          (Pattern, Expr))
                     -> Tk
                     -> Alex
                          (HappyAbsSyn
                             [TL]
                             TYSG
                             TYSG
                             TYSG
                             [TYSG]
                             [TYSG]
                             [TL]
                             TL
                             Tk
                             [(Identifier, [Pattern], Expr)]
                             (Identifier, [Pattern], Expr)
                             [(TYSG, Identifier)]
                             [(TYSG, Identifier)]
                             (TYSG, Identifier)
                             [Identifier]
                             [Identifier]
                             [Identifier]
                             [Identifier]
                             Pattern
                             [Pattern]
                             [Pattern]
                             Expr
                             [Arg]
                             [Arg]
                             Arg
                             [(Identifier, Expr)]
                             [(Identifier, Expr)]
                             (Identifier, Expr)
                             Literal
                             Term
                             [(Pattern, Expr)]
                             [(Pattern, Expr)]
                             (Pattern, Expr))
        Actual type: HappyStk
                       (HappyAbsSyn
                          [TL]
                          TYSG
                          TYSG
                          TYSG
                          [TYSG]
                          [TYSG]
                          [TL]
                          TL
                          Tk
                          [(Identifier, [Pattern], Expr)]
                          (Identifier, [Pattern], Expr)
                          [(TYSG, Identifier)]
                          [(TYSG, Identifier)]
                          (TYSG, Identifier)
                          [Identifier]
                          [Identifier]
                          [Identifier]
                          [Identifier]
                          Pattern
                          [Pattern]
                          [Pattern]
                          Tk
                          [Arg]
                          [Arg]
                          Arg
                          [(Identifier, Expr)]
                          [(Identifier, Expr)]
                          (Identifier, Expr)
                          Literal
                          Term
                          [(Pattern, Expr)]
                          [(Pattern, Expr)]
                          (Pattern, Expr))
                     -> Tk
                     -> Alex
                          (HappyAbsSyn
                             [TL]
                             TYSG
                             TYSG
                             TYSG
                             [TYSG]
                             [TYSG]
                             [TL]
                             TL
                             Tk
                             [(Identifier, [Pattern], Expr)]
                             (Identifier, [Pattern], Tk)
                             [(TYSG, Identifier)]
                             [(TYSG, Identifier)]
                             (TYSG, Identifier)
                             [Identifier]
                             [Identifier]
                             [Identifier]
                             [Identifier]
                             Pattern
                             [Pattern]
                             [Pattern]
                             Expr
                             [Arg]
                             [Arg]
                             Arg
                             [(Identifier, Expr)]
                             [(Identifier, Expr)]
                             (Identifier, Expr)
                             Literal
                             Term
                             [(Pattern, Expr)]
                             [(Pattern, Expr)]
                             (Pattern, Expr))
    • In the third argument of ‘happyMonadReduce’, namely
        ‘happyReduction_34’
      In the expression: happyMonadReduce 4# 10# happyReduction_34
      In an equation for ‘happyReduce_34’:
          happyReduce_34 = happyMonadReduce 4# 10# happyReduction_34
    |
818 | happyReduce_34 = happyMonadReduce 4# 10# happyReduction_34
    |

the issue of balancing studying for your courses and studying in your free time

linear algebra is so fun because even if you know all the theory you will still fuck up half the problems cause there are so many boring steps that you are bound to do a small error somewhere which then ruins everything

rid yourself of the concept of "cringe" and be yourself unapoligetically.

🍞

if one would like to torture themselfs with category theory, where should they start?

something like this

f :: a -> Bool
f 1 = True
f _ = False

maybe you could write some funky equality functions and stuff. it does remove a lot of info from the type signature though, which sucks...

I think it'd be interesting if you could do type refinement by pattern matching over a polymorphic parameter. sort of like how you can with GADTs, except more general.

I mined a craft
https://youtu.be/7bC7CnW_3FY