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

long error message, EXTREMELY SCREENREADER UNFRIENDLY 

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
|

we have
- incubus (inductive cubus)
- succubus (successor cubus)
so where is the basecubus?

*points at you*

you are the cyclic group of order 2. there is nothing you can do

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.

squimsh : A ≡ A → A ≐ A
squimsh refl = refl

i could solve the halting problem easily, but certain people have been a bitch to me, so i wont

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

haskell code, probably not screenreader friendly 

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...

Show thread

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.

Show older

rachel rosen's choices:

types.pl

A Mastodon instance for programming language theorists and mathematicians. Or just anyone who wants to hang out.